NetworkScorerAppManagerTest.java revision dd251ef4952b6c7abbfe8cea49285d8cfe62f96e 
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.content.pm.ServiceInfo;
27import android.net.NetworkScorerAppManager.NetworkScorerAppData;
28import android.os.UserHandle;
29import android.test.InstrumentationTestCase;
30
31import org.mockito.ArgumentMatcher;
32import org.mockito.Mock;
33import org.mockito.Mockito;
34import org.mockito.MockitoAnnotations;
35
36import java.util.ArrayList;
37import java.util.Collections;
38import java.util.Iterator;
39import java.util.List;
40
41public class NetworkScorerAppManagerTest extends InstrumentationTestCase {
42    @Mock private Context mMockContext;
43    @Mock private PackageManager mMockPm;
44
45    @Override
46    public void setUp() throws Exception {
47        super.setUp();
48
49        // Configuration needed to make mockito/dexcache work.
50        System.setProperty("dexmaker.dexcache",
51                getInstrumentation().getTargetContext().getCacheDir().getPath());
52        ClassLoader newClassLoader = getInstrumentation().getClass().getClassLoader();
53        Thread.currentThread().setContextClassLoader(newClassLoader);
54
55        MockitoAnnotations.initMocks(this);
56        Mockito.when(mMockContext.getPackageManager()).thenReturn(mMockPm);
57    }
58
59    public void testGetAllValidScorers() throws Exception {
60        // Package 1 - Valid scorer.
61        ResolveInfoHolder package1 = buildResolveInfo("package1", 1, true, true, false, false);
62
63        // Package 2 - Receiver does not have BROADCAST_NETWORK_PRIVILEGED permission.
64        ResolveInfoHolder package2 = buildResolveInfo("package2", 2, false, true, false, false);
65
66        // Package 3 - App does not have SCORE_NETWORKS permission.
67        ResolveInfoHolder package3 = buildResolveInfo("package3", 3, true, false, false, false);
68
69        // Package 4 - Valid scorer w/ optional config activity.
70        ResolveInfoHolder package4 = buildResolveInfo("package4", 4, true, true, true, false);
71
72        // Package 5 - Valid scorer w/ optional service to bind to.
73        ResolveInfoHolder package5 = buildResolveInfo("package5", 5, true, true, false, true);
74
75        List<ResolveInfoHolder> scorers = new ArrayList<>();
76        scorers.add(package1);
77        scorers.add(package2);
78        scorers.add(package3);
79        scorers.add(package4);
80        scorers.add(package5);
81        setScorers(scorers);
82
83        Iterator<NetworkScorerAppData> result =
84                NetworkScorerAppManager.getAllValidScorers(mMockContext).iterator();
85
86        assertTrue(result.hasNext());
87        NetworkScorerAppData next = result.next();
88        assertEquals("package1", next.mPackageName);
89        assertEquals(1, next.mPackageUid);
90        assertNull(next.mConfigurationActivityClassName);
91
92        assertTrue(result.hasNext());
93        next = result.next();
94        assertEquals("package4", next.mPackageName);
95        assertEquals(4, next.mPackageUid);
96        assertEquals(".ConfigActivity", next.mConfigurationActivityClassName);
97
98        assertTrue(result.hasNext());
99        next = result.next();
100        assertEquals("package5", next.mPackageName);
101        assertEquals(5, next.mPackageUid);
102        assertEquals(".ScoringService", next.mScoringServiceClassName);
103
104        assertFalse(result.hasNext());
105    }
106
107    private void setScorers(List<ResolveInfoHolder> scorers) {
108        List<ResolveInfo> receivers = new ArrayList<>();
109        for (final ResolveInfoHolder scorer : scorers) {
110            receivers.add(scorer.scorerResolveInfo);
111            if (scorer.configActivityResolveInfo != null) {
112                // This scorer has a config activity.
113                Mockito.when(mMockPm.queryIntentActivities(
114                        Mockito.argThat(new ArgumentMatcher<Intent>() {
115                            @Override
116                            public boolean matches(Object object) {
117                                Intent intent = (Intent) object;
118                                return NetworkScoreManager.ACTION_CUSTOM_ENABLE.equals(
119                                        intent.getAction())
120                                        && scorer.scorerResolveInfo.activityInfo.packageName.equals(
121                                                intent.getPackage());
122                            }
123                        }), Mockito.eq(0))).thenReturn(
124                                Collections.singletonList(scorer.configActivityResolveInfo));
125            }
126
127            if (scorer.serviceResolveInfo != null) {
128                // This scorer has a service to bind to
129                Mockito.when(mMockPm.resolveService(
130                        Mockito.argThat(new ArgumentMatcher<Intent>() {
131                            @Override
132                            public boolean matches(Object object) {
133                                Intent intent = (Intent) object;
134                                return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(
135                                        intent.getAction())
136                                        && scorer.scorerResolveInfo.activityInfo.packageName.equals(
137                                        intent.getPackage());
138                            }
139                        }), Mockito.eq(0))).thenReturn(scorer.serviceResolveInfo);
140            }
141        }
142
143        Mockito.when(mMockPm.queryBroadcastReceiversAsUser(
144                Mockito.argThat(new ArgumentMatcher<Intent>() {
145                    @Override
146                    public boolean matches(Object object) {
147                        Intent intent = (Intent) object;
148                        return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(intent.getAction());
149                    }
150                }), Mockito.eq(0), Mockito.eq(UserHandle.USER_SYSTEM)))
151                .thenReturn(receivers);
152    }
153
154    private ResolveInfoHolder buildResolveInfo(String packageName, int packageUid,
155            boolean hasReceiverPermission, boolean hasScorePermission, boolean hasConfigActivity,
156            boolean hasServiceInfo) throws Exception {
157        Mockito.when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
158                .thenReturn(hasScorePermission ?
159                        PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED);
160
161        ResolveInfo resolveInfo = new ResolveInfo();
162        resolveInfo.activityInfo = new ActivityInfo();
163        resolveInfo.activityInfo.packageName = packageName;
164        resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
165        resolveInfo.activityInfo.applicationInfo.uid = packageUid;
166        if (hasReceiverPermission) {
167            resolveInfo.activityInfo.permission = permission.BROADCAST_NETWORK_PRIVILEGED;
168        }
169
170        ResolveInfo configActivityInfo = null;
171        if (hasConfigActivity) {
172            configActivityInfo = new ResolveInfo();
173            configActivityInfo.activityInfo = new ActivityInfo();
174            configActivityInfo.activityInfo.name = ".ConfigActivity";
175        }
176
177        ResolveInfo serviceInfo = null;
178        if (hasServiceInfo) {
179            serviceInfo = new ResolveInfo();
180            serviceInfo.serviceInfo = new ServiceInfo();
181            serviceInfo.serviceInfo.name = ".ScoringService";
182        }
183
184        return new ResolveInfoHolder(resolveInfo, configActivityInfo, serviceInfo);
185    }
186
187    private static class ResolveInfoHolder {
188        final ResolveInfo scorerResolveInfo;
189        final ResolveInfo configActivityResolveInfo;
190        final ResolveInfo serviceResolveInfo;
191
192        public ResolveInfoHolder(ResolveInfo scorerResolveInfo,
193                ResolveInfo configActivityResolveInfo, ResolveInfo serviceResolveInfo) {
194            this.scorerResolveInfo = scorerResolveInfo;
195            this.configActivityResolveInfo = configActivityResolveInfo;
196            this.serviceResolveInfo = serviceResolveInfo;
197        }
198    }
199}
200