1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package android.net;
18
19import android.Manifest.permission;
20import android.content.Context;
21import android.content.Intent;
22import android.content.pm.ActivityInfo;
23import android.content.pm.ApplicationInfo;
24import android.content.pm.PackageManager;
25import android.content.pm.ResolveInfo;
26import android.net.NetworkScorerAppManager.NetworkScorerAppData;
27import android.test.InstrumentationTestCase;
28import android.util.Pair;
29
30import org.mockito.ArgumentMatcher;
31import org.mockito.Mock;
32import org.mockito.Mockito;
33import org.mockito.MockitoAnnotations;
34
35import java.util.ArrayList;
36import java.util.Collections;
37import java.util.Iterator;
38import java.util.List;
39
40public class NetworkScorerAppManagerTest extends InstrumentationTestCase {
41    @Mock private Context mMockContext;
42    @Mock private PackageManager mMockPm;
43
44    @Override
45    public void setUp() throws Exception {
46        super.setUp();
47
48        // Configuration needed to make mockito/dexcache work.
49        System.setProperty("dexmaker.dexcache",
50                getInstrumentation().getTargetContext().getCacheDir().getPath());
51        ClassLoader newClassLoader = getInstrumentation().getClass().getClassLoader();
52        Thread.currentThread().setContextClassLoader(newClassLoader);
53
54        MockitoAnnotations.initMocks(this);
55        Mockito.when(mMockContext.getPackageManager()).thenReturn(mMockPm);
56    }
57
58    public void testGetAllValidScorers() throws Exception {
59        // Package 1 - Valid scorer.
60        Pair<ResolveInfo, ResolveInfo> package1 = buildResolveInfo("package1", 1, true, true,
61                false);
62
63        // Package 2 - Receiver does not have BROADCAST_NETWORK_PRIVILEGED permission.
64        Pair<ResolveInfo, ResolveInfo> package2 = buildResolveInfo("package2", 2, false, true,
65                false);
66
67        // Package 3 - App does not have SCORE_NETWORKS permission.
68        Pair<ResolveInfo, ResolveInfo> package3 = buildResolveInfo("package3", 3, true, false,
69                false);
70
71        // Package 4 - Valid scorer w/ optional config activity.
72        Pair<ResolveInfo, ResolveInfo> package4 = buildResolveInfo("package4", 4, true, true, true);
73
74        List<Pair<ResolveInfo, ResolveInfo>> scorers = new ArrayList<>();
75        scorers.add(package1);
76        scorers.add(package2);
77        scorers.add(package3);
78        scorers.add(package4);
79        setScorers(scorers);
80
81        Iterator<NetworkScorerAppData> result =
82                NetworkScorerAppManager.getAllValidScorers(mMockContext).iterator();
83
84        assertTrue(result.hasNext());
85        NetworkScorerAppData next = result.next();
86        assertEquals("package1", next.mPackageName);
87        assertEquals(1, next.mPackageUid);
88        assertNull(next.mConfigurationActivityClassName);
89
90        assertTrue(result.hasNext());
91        next = result.next();
92        assertEquals("package4", next.mPackageName);
93        assertEquals(4, next.mPackageUid);
94        assertEquals(".ConfigActivity", next.mConfigurationActivityClassName);
95
96        assertFalse(result.hasNext());
97    }
98
99    private void setScorers(List<Pair<ResolveInfo, ResolveInfo>> scorers) {
100        List<ResolveInfo> receivers = new ArrayList<>();
101        for (final Pair<ResolveInfo, ResolveInfo> scorer : scorers) {
102            receivers.add(scorer.first);
103            if (scorer.second != null) {
104                // This scorer has a config activity.
105                Mockito.when(mMockPm.queryIntentActivities(
106                        Mockito.argThat(new ArgumentMatcher<Intent>() {
107                            @Override
108                            public boolean matches(Object object) {
109                                Intent intent = (Intent) object;
110                                return NetworkScoreManager.ACTION_CUSTOM_ENABLE.equals(
111                                        intent.getAction())
112                                        && scorer.first.activityInfo.packageName.equals(
113                                                intent.getPackage());
114                            }
115                        }), Mockito.eq(0))).thenReturn(Collections.singletonList(scorer.second));
116            }
117        }
118
119        Mockito.when(mMockPm.queryBroadcastReceivers(
120                Mockito.argThat(new ArgumentMatcher<Intent>() {
121                    @Override
122                    public boolean matches(Object object) {
123                        Intent intent = (Intent) object;
124                        return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(intent.getAction());
125                    }
126                }), Mockito.eq(0)))
127                .thenReturn(receivers);
128    }
129
130    private Pair<ResolveInfo, ResolveInfo> buildResolveInfo(String packageName, int packageUid,
131            boolean hasReceiverPermission, boolean hasScorePermission, boolean hasConfigActivity)
132            throws Exception {
133        Mockito.when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
134                .thenReturn(hasScorePermission ?
135                        PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED);
136
137        ResolveInfo resolveInfo = new ResolveInfo();
138        resolveInfo.activityInfo = new ActivityInfo();
139        resolveInfo.activityInfo.packageName = packageName;
140        resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
141        resolveInfo.activityInfo.applicationInfo.uid = packageUid;
142        if (hasReceiverPermission) {
143            resolveInfo.activityInfo.permission = permission.BROADCAST_NETWORK_PRIVILEGED;
144        }
145
146        ResolveInfo configActivityInfo = null;
147        if (hasConfigActivity) {
148            configActivityInfo = new ResolveInfo();
149            configActivityInfo.activityInfo = new ActivityInfo();
150            configActivityInfo.activityInfo.name = ".ConfigActivity";
151        }
152        return Pair.create(resolveInfo, configActivityInfo);
153    }
154}
155