NetworkScorerAppManagerTest.java revision 7aa0b0d94e577cb0e9620f0ea53ed37795be7e52 
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 com.android.server;
18
19import static junit.framework.Assert.assertEquals;
20import static junit.framework.Assert.assertNotNull;
21import static junit.framework.Assert.assertNull;
22import static junit.framework.Assert.assertTrue;
23
24import static org.junit.Assert.assertFalse;
25import static org.mockito.ArgumentMatchers.anyString;
26import static org.mockito.Matchers.any;
27import static org.mockito.Matchers.anyInt;
28import static org.mockito.Matchers.eq;
29import static org.mockito.Mockito.never;
30import static org.mockito.Mockito.verify;
31import static org.mockito.Mockito.when;
32
33import android.Manifest.permission;
34import android.content.ComponentName;
35import android.content.Context;
36import android.content.Intent;
37import android.content.pm.ActivityInfo;
38import android.content.pm.ApplicationInfo;
39import android.content.pm.PackageManager;
40import android.content.pm.ResolveInfo;
41import android.content.pm.ServiceInfo;
42import android.content.res.Resources;
43import android.net.NetworkScoreManager;
44import android.net.NetworkScorerAppData;
45import android.os.Bundle;
46import android.provider.Settings;
47import android.support.test.runner.AndroidJUnit4;
48
49import com.android.internal.R;
50
51import org.junit.Before;
52import org.junit.Test;
53import org.junit.runner.RunWith;
54import org.mockito.Mock;
55import org.mockito.Mockito;
56import org.mockito.MockitoAnnotations;
57import org.mockito.compat.ArgumentMatcher;
58
59import java.util.ArrayList;
60import java.util.List;
61
62@RunWith(AndroidJUnit4.class)
63public class NetworkScorerAppManagerTest {
64    private static String MOCK_SERVICE_LABEL = "Mock Service";
65    private static String MOCK_OVERRIDEN_SERVICE_LABEL = "Mock Service Label Override";
66    private static String MOCK_NETWORK_AVAILABLE_NOTIFICATION_CHANNEL_ID =
67            "Mock Network Available Notification Channel Id";
68
69    @Mock private Context mMockContext;
70    @Mock private PackageManager mMockPm;
71    @Mock private Resources mResources;
72    @Mock private NetworkScorerAppManager.SettingsFacade mSettingsFacade;
73    private NetworkScorerAppManager mNetworkScorerAppManager;
74    private List<ResolveInfo> mAvailableServices;
75
76    @Before
77    public void setUp() throws Exception {
78        MockitoAnnotations.initMocks(this);
79        mAvailableServices = new ArrayList<>();
80        when(mMockContext.getPackageManager()).thenReturn(mMockPm);
81        when(mMockPm.queryIntentServices(Mockito.argThat(new ArgumentMatcher<Intent>() {
82            @Override
83            public boolean matchesObject(Object object) {
84                Intent intent = (Intent) object;
85                return NetworkScoreManager.ACTION_RECOMMEND_NETWORKS.equals(intent.getAction());
86            }
87        }), eq(PackageManager.GET_META_DATA))).thenReturn(mAvailableServices);
88        when(mMockContext.getResources()).thenReturn(mResources);
89
90        mNetworkScorerAppManager = new NetworkScorerAppManager(mMockContext, mSettingsFacade);
91    }
92
93    @Test
94    public void testGetActiveScorer_providerAvailable() throws Exception {
95        final ComponentName recoComponent = new ComponentName("package1", "class1");
96        setNetworkRecoPackageSetting(recoComponent.getPackageName());
97        mockScoreNetworksGranted(recoComponent.getPackageName());
98        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */);
99
100        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
101        assertNotNull(activeScorer);
102        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
103        assertEquals(924, activeScorer.packageUid);
104        assertEquals(MOCK_SERVICE_LABEL, activeScorer.getRecommendationServiceLabel());
105    }
106
107    @Test
108    public void testGetActiveScorer_providerAvailable_serviceLabelOverride() throws Exception {
109        final ComponentName recoComponent = new ComponentName("package1", "class1");
110        setNetworkRecoPackageSetting(recoComponent.getPackageName());
111        mockScoreNetworksGranted(recoComponent.getPackageName());
112        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
113                null /* enableUseOpenWifiPackageActivityPackage*/, true /* serviceLabelOverride */);
114
115        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
116        assertNotNull(activeScorer);
117        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
118        assertEquals(924, activeScorer.packageUid);
119        assertEquals(MOCK_OVERRIDEN_SERVICE_LABEL, activeScorer.getRecommendationServiceLabel());
120    }
121
122    @Test
123    public void testGetActiveScorer_permissionMissing() throws Exception {
124        final ComponentName recoComponent = new ComponentName("package1", "class1");
125        setNetworkRecoPackageSetting(recoComponent.getPackageName());
126        mockScoreNetworksDenied(recoComponent.getPackageName());
127        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */);
128
129        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
130        assertNull(activeScorer);
131    }
132
133    @Test
134    public void testGetActiveScorer_providerAvailable_enableUseOpenWifiActivityNotSet()
135            throws Exception {
136        final ComponentName recoComponent = new ComponentName("package1", "class1");
137        setNetworkRecoPackageSetting(recoComponent.getPackageName());
138        mockScoreNetworksGranted(recoComponent.getPackageName());
139        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
140                null /* enableUseOpenWifiPackageActivityPackage*/);
141
142        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
143        assertNotNull(activeScorer);
144        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
145        assertEquals(924, activeScorer.packageUid);
146        assertNull(activeScorer.getEnableUseOpenWifiActivity());
147    }
148
149    @Test
150    public void testGetActiveScorer_providerAvailable_enableUseOpenWifiActivityNotResolved()
151            throws Exception {
152        final ComponentName recoComponent = new ComponentName("package1", "class1");
153        setNetworkRecoPackageSetting(recoComponent.getPackageName());
154        mockScoreNetworksGranted(recoComponent.getPackageName());
155        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
156                "package2" /* enableUseOpenWifiPackageActivityPackage*/);
157
158        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
159        assertNotNull(activeScorer);
160        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
161        assertEquals(924, activeScorer.packageUid);
162        assertNull(activeScorer.getEnableUseOpenWifiActivity());
163    }
164
165    @Test
166    public void testGetActiveScorer_providerAvailable_enableUseOpenWifiActivityResolved()
167            throws Exception {
168        final ComponentName recoComponent = new ComponentName("package1", "class1");
169        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
170        setNetworkRecoPackageSetting(recoComponent.getPackageName());
171        mockScoreNetworksGranted(recoComponent.getPackageName());
172        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
173                enableUseOpenWifiComponent.getPackageName());
174        mockEnableUseOpenWifiActivity(enableUseOpenWifiComponent);
175
176        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
177        assertNotNull(activeScorer);
178        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
179        assertEquals(924, activeScorer.packageUid);
180        assertEquals(enableUseOpenWifiComponent, activeScorer.getEnableUseOpenWifiActivity());
181        assertNull(activeScorer.getNetworkAvailableNotificationChannelId());
182    }
183
184    @Test
185    public void testGetActiveScorer_providerAvailable_networkAvailableNotificationChannelIdSet() {
186        final ComponentName recoComponent = new ComponentName("package1", "class1");
187        setNetworkRecoPackageSetting(recoComponent.getPackageName());
188        mockScoreNetworksGranted(recoComponent.getPackageName());
189        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
190                null /* enableUseOpenWifiActivityPackage */, false /* serviceLabelOverride */,
191                true /* setNotificationChannelId */);
192
193        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
194        assertNotNull(activeScorer);
195        assertEquals(recoComponent, activeScorer.getRecommendationServiceComponent());
196        assertEquals(924, activeScorer.packageUid);
197        assertEquals(MOCK_NETWORK_AVAILABLE_NOTIFICATION_CHANNEL_ID,
198                activeScorer.getNetworkAvailableNotificationChannelId());
199    }
200
201    @Test
202    public void testGetActiveScorer_packageSettingIsNull()
203            throws Exception {
204        // NETWORK_RECOMMENDATIONS_PACKAGE is null
205
206        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
207        assertNull(activeScorer);
208    }
209
210    @Test
211    public void testGetActiveScorer_packageSettingIsInvalid() throws Exception {
212        final ComponentName recoComponent = new ComponentName("package1", "class1");
213        setDefaultNetworkRecommendationPackage(recoComponent.getPackageName());
214        mockScoreNetworksGranted(recoComponent.getPackageName());
215        // NETWORK_RECOMMENDATIONS_PACKAGE is set to a package that isn't a recommender.
216
217        final NetworkScorerAppData activeScorer = mNetworkScorerAppManager.getActiveScorer();
218        assertNull(activeScorer);
219    }
220
221    @Test
222    public void testSetActiveScorer_noChange() throws Exception {
223        String packageName = "package";
224        setNetworkRecoPackageSetting(packageName);
225
226        assertTrue(mNetworkScorerAppManager.setActiveScorer(packageName));
227        verify(mSettingsFacade, never()).putString(any(), any(), any());
228    }
229
230    @Test
231    public void testSetActiveScorer_nullPackage_currentIsSet() throws Exception {
232        setNetworkRecoPackageSetting("package");
233
234        assertTrue(mNetworkScorerAppManager.setActiveScorer(null));
235        verify(mSettingsFacade).putString(mMockContext,
236                Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE, null);
237        verify(mSettingsFacade).putInt(mMockContext,
238                Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED,
239                NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF);
240    }
241
242    @Test
243    public void testSetActiveScorer_nullPackage_currentIsNull() throws Exception {
244        setNetworkRecoPackageSetting(null);
245
246        assertTrue(mNetworkScorerAppManager.setActiveScorer(null));
247        verify(mSettingsFacade, never()).putString(any(), any(), any());
248    }
249
250    @Test
251    public void testSetActiveScorer_validPackage() throws Exception {
252        String packageName = "package";
253        String newPackage = "newPackage";
254        setNetworkRecoPackageSetting(packageName);
255        final ComponentName recoComponent = new ComponentName(newPackage, "class1");
256        mockScoreNetworksGranted(recoComponent.getPackageName());
257        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */, null);
258
259        assertTrue(mNetworkScorerAppManager.setActiveScorer(newPackage));
260        verify(mSettingsFacade).putString(mMockContext,
261                Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE, newPackage);
262        verify(mSettingsFacade).putInt(mMockContext,
263                Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED,
264                NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON);
265    }
266
267    @Test
268    public void testSetActiveScorer_invalidPackage() throws Exception {
269        String packageName = "package";
270        String newPackage = "newPackage";
271        setNetworkRecoPackageSetting(packageName);
272        // newPackage doesn't resolve to a valid recommender
273
274        assertFalse(mNetworkScorerAppManager.setActiveScorer(newPackage));
275        verify(mSettingsFacade, never()).putString(any(), any(), any());
276    }
277
278    @Test
279    public void testUpdateState_recommendationsForcedOff() throws Exception {
280        setRecommendationsEnabledSetting(NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF);
281
282        mNetworkScorerAppManager.updateState();
283
284        verify(mSettingsFacade, never()).getString(any(),
285                eq(Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE));
286        verify(mSettingsFacade, never()).putInt(any(),
287                eq(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED), anyInt());
288    }
289
290    @Test
291    public void testUpdateState_currentPackageValid() throws Exception {
292        String packageName = "package";
293        setNetworkRecoPackageSetting(packageName);
294        final ComponentName recoComponent = new ComponentName(packageName, "class1");
295        mockScoreNetworksGranted(recoComponent.getPackageName());
296        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */, null);
297
298        mNetworkScorerAppManager.updateState();
299
300        verify(mSettingsFacade, never()).putString(any(),
301                eq(Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE), any());
302        verify(mSettingsFacade).putInt(mMockContext,
303                Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED,
304                NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON);
305    }
306
307    @Test
308    public void testUpdateState_currentPackageNotValid_validDefault() throws Exception {
309        String defaultPackage = "defaultPackage";
310        setDefaultNetworkRecommendationPackage(defaultPackage);
311        final ComponentName recoComponent = new ComponentName(defaultPackage, "class1");
312        mockScoreNetworksGranted(recoComponent.getPackageName());
313        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */, null);
314
315        mNetworkScorerAppManager.updateState();
316
317        verify(mSettingsFacade).putString(mMockContext,
318                Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE, defaultPackage);
319        verify(mSettingsFacade).putInt(mMockContext,
320                Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED,
321                NetworkScoreManager.RECOMMENDATIONS_ENABLED_ON);
322    }
323
324    @Test
325    public void testUpdateState_currentPackageNotValid_invalidDefault() throws Exception {
326        String defaultPackage = "defaultPackage";
327        setDefaultNetworkRecommendationPackage(defaultPackage);
328        setNetworkRecoPackageSetting("currentPackage");
329
330        mNetworkScorerAppManager.updateState();
331
332        verify(mSettingsFacade).putString(mMockContext,
333                Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE, defaultPackage);
334        verify(mSettingsFacade).putInt(mMockContext,
335                Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED,
336                NetworkScoreManager.RECOMMENDATIONS_ENABLED_OFF);
337    }
338
339    @Test
340    public void testUpdateState_currentPackageNull_defaultNull() throws Exception {
341        setDefaultNetworkRecommendationPackage(null);
342        setNetworkRecoPackageSetting(null);
343
344        mNetworkScorerAppManager.updateState();
345
346        verify(mSettingsFacade, never()).putString(any(),
347                eq(Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE), anyString());
348        verify(mSettingsFacade, never()).putInt(any(),
349                eq(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED), anyInt());
350    }
351
352    @Test
353    public void testUpdateState_currentPackageEmpty_defaultEmpty() throws Exception {
354        setDefaultNetworkRecommendationPackage("");
355        setNetworkRecoPackageSetting("");
356
357        mNetworkScorerAppManager.updateState();
358
359        verify(mSettingsFacade, never()).putString(any(),
360                eq(Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE), anyString());
361        verify(mSettingsFacade, never()).putInt(any(),
362                eq(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED), anyInt());
363    }
364
365    @Test
366    public void testUpdateState_currentPackageNotValid_sameAsDefault() throws Exception {
367        String defaultPackage = "defaultPackage";
368        setDefaultNetworkRecommendationPackage(defaultPackage);
369        setNetworkRecoPackageSetting(defaultPackage);
370
371        mNetworkScorerAppManager.updateState();
372
373        verify(mSettingsFacade, never()).putString(any(),
374                eq(Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE), any());
375    }
376
377    @Test
378    public void testMigrateNetworkScorerAppSettingIfNeeded_networkScorerAppIsNull()
379            throws Exception {
380        when(mSettingsFacade.getString(mMockContext,
381                Settings.Global.NETWORK_SCORER_APP)).thenReturn(null);
382
383        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
384
385        verify(mSettingsFacade, never()).putString(eq(mMockContext),
386                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
387    }
388
389    @Test
390    public void testMigrateNetworkScorerAppSettingIfNeeded_networkScorerAppIsEmpty()
391            throws Exception {
392        when(mSettingsFacade.getString(mMockContext,
393                Settings.Global.NETWORK_SCORER_APP)).thenReturn("");
394
395        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
396
397        verify(mSettingsFacade, never()).putString(eq(mMockContext),
398                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
399    }
400
401    @Test
402    public void testMigrateNetworkScorerAppSettingIfNeeded_networkScorerIsNotActive()
403            throws Exception {
404        when(mSettingsFacade.getString(mMockContext,
405                Settings.Global.NETWORK_SCORER_APP)).thenReturn("com.foo.package");
406        // Make getActiveScorer() return null.
407        setRecommendationsEnabledSetting(NetworkScoreManager.RECOMMENDATIONS_ENABLED_FORCED_OFF);
408
409        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
410
411        verify(mSettingsFacade, never()).putString(eq(mMockContext),
412                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
413    }
414
415    @Test
416    public void testMigrateNetworkScorerAppSettingIfNeeded_useOpenWifiSettingIsNotEmpty()
417            throws Exception {
418        final ComponentName recoComponent = new ComponentName("package1", "class1");
419        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
420        setNetworkRecoPackageSetting(recoComponent.getPackageName());
421        mockScoreNetworksGranted(recoComponent.getPackageName());
422        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
423                enableUseOpenWifiComponent.getPackageName());
424        mockEnableUseOpenWifiActivity(enableUseOpenWifiComponent);
425        when(mSettingsFacade.getString(mMockContext,
426                Settings.Global.NETWORK_SCORER_APP))
427                .thenReturn(enableUseOpenWifiComponent.getPackageName());
428        // The setting has a value so the migration shouldn't touch it.
429        when(mSettingsFacade.getString(mMockContext,
430                Settings.Global.USE_OPEN_WIFI_PACKAGE))
431                .thenReturn(enableUseOpenWifiComponent.getPackageName());
432
433        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
434
435        verify(mSettingsFacade, never()).putString(eq(mMockContext),
436                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
437        verify(mSettingsFacade).putString(eq(mMockContext),
438                eq(Settings.Global.NETWORK_SCORER_APP), eq(null));
439    }
440
441    @Test
442    public void testMigrateNetworkScorerAppSettingIfNeeded_useOpenWifiActivityNotAvail()
443            throws Exception {
444        final ComponentName recoComponent = new ComponentName("package1", "class1");
445        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
446        setNetworkRecoPackageSetting(recoComponent.getPackageName());
447        mockScoreNetworksGranted(recoComponent.getPackageName());
448        // The active component doesn't have an open wifi activity so the migration shouldn't
449        // set USE_OPEN_WIFI_PACKAGE.
450        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
451                null /*useOpenWifiActivityPackage*/);
452        when(mSettingsFacade.getString(mMockContext,
453                Settings.Global.NETWORK_SCORER_APP))
454                .thenReturn(enableUseOpenWifiComponent.getPackageName());
455        when(mSettingsFacade.getString(mMockContext,
456                Settings.Global.USE_OPEN_WIFI_PACKAGE)).thenReturn(null);
457
458        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
459
460        verify(mSettingsFacade, never()).putString(eq(mMockContext),
461                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
462        verify(mSettingsFacade).putString(eq(mMockContext),
463                eq(Settings.Global.NETWORK_SCORER_APP), eq(null));
464    }
465
466    @Test
467    public void testMigrateNetworkScorerAppSettingIfNeeded_packageMismatch_activity()
468            throws Exception {
469        final ComponentName recoComponent = new ComponentName("package1", "class1");
470        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
471        setNetworkRecoPackageSetting(recoComponent.getPackageName());
472        mockScoreNetworksGranted(recoComponent.getPackageName());
473        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
474                enableUseOpenWifiComponent.getPackageName());
475        mockEnableUseOpenWifiActivity(enableUseOpenWifiComponent);
476        // The older network scorer app setting doesn't match the new use open wifi activity package
477        // so the migration shouldn't set USE_OPEN_WIFI_PACKAGE.
478        when(mSettingsFacade.getString(mMockContext,
479                Settings.Global.NETWORK_SCORER_APP))
480                .thenReturn(enableUseOpenWifiComponent.getPackageName() + ".diff");
481        when(mSettingsFacade.getString(mMockContext,
482                Settings.Global.USE_OPEN_WIFI_PACKAGE)).thenReturn(null);
483
484        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
485
486        verify(mSettingsFacade, never()).putString(eq(mMockContext),
487                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
488        verify(mSettingsFacade).putString(eq(mMockContext),
489                eq(Settings.Global.NETWORK_SCORER_APP), eq(null));
490    }
491
492    @Test
493    public void testMigrateNetworkScorerAppSettingIfNeeded_packageMismatch_service()
494            throws Exception {
495        final ComponentName recoComponent = new ComponentName("package1", "class1");
496        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
497        setNetworkRecoPackageSetting(recoComponent.getPackageName());
498        mockScoreNetworksGranted(recoComponent.getPackageName());
499        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
500                enableUseOpenWifiComponent.getPackageName());
501        mockEnableUseOpenWifiActivity(enableUseOpenWifiComponent);
502        // The older network scorer app setting doesn't match the active package so the migration
503        // shouldn't set USE_OPEN_WIFI_PACKAGE.
504        when(mSettingsFacade.getString(mMockContext,
505                Settings.Global.NETWORK_SCORER_APP))
506                .thenReturn(recoComponent.getPackageName() + ".diff");
507        when(mSettingsFacade.getString(mMockContext,
508                Settings.Global.USE_OPEN_WIFI_PACKAGE)).thenReturn(null);
509
510        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
511
512        verify(mSettingsFacade, never()).putString(eq(mMockContext),
513                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE), anyString());
514        verify(mSettingsFacade).putString(eq(mMockContext),
515                eq(Settings.Global.NETWORK_SCORER_APP), eq(null));
516    }
517
518    @Test
519    public void testMigrateNetworkScorerAppSettingIfNeeded_packageMatch_activity()
520            throws Exception {
521        final ComponentName recoComponent = new ComponentName("package1", "class1");
522        final ComponentName enableUseOpenWifiComponent = new ComponentName("package2", "class2");
523        setNetworkRecoPackageSetting(recoComponent.getPackageName());
524        mockScoreNetworksGranted(recoComponent.getPackageName());
525        mockRecommendationServiceAvailable(recoComponent, 924 /* packageUid */,
526                enableUseOpenWifiComponent.getPackageName());
527        mockEnableUseOpenWifiActivity(enableUseOpenWifiComponent);
528        // Old setting matches the new activity package, migration should happen.
529        when(mSettingsFacade.getString(mMockContext,
530                Settings.Global.NETWORK_SCORER_APP))
531                .thenReturn(enableUseOpenWifiComponent.getPackageName());
532        when(mSettingsFacade.getString(mMockContext,
533                Settings.Global.USE_OPEN_WIFI_PACKAGE)).thenReturn(null);
534
535        mNetworkScorerAppManager.migrateNetworkScorerAppSettingIfNeeded();
536
537        verify(mSettingsFacade).putString(eq(mMockContext),
538                eq(Settings.Global.USE_OPEN_WIFI_PACKAGE),
539                eq(enableUseOpenWifiComponent.getPackageName()));
540        verify(mSettingsFacade).putString(eq(mMockContext),
541                eq(Settings.Global.NETWORK_SCORER_APP), eq(null));
542    }
543
544    private void setRecommendationsEnabledSetting(int value) {
545        when(mSettingsFacade.getInt(eq(mMockContext),
546                eq(Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED), anyInt())).thenReturn(value);
547    }
548
549    private void setNetworkRecoPackageSetting(String packageName) {
550        when(mSettingsFacade.getString(mMockContext,
551                Settings.Global.NETWORK_RECOMMENDATIONS_PACKAGE)).thenReturn(packageName);
552    }
553
554    private void setDefaultNetworkRecommendationPackage(String name) {
555        when(mResources.getString(R.string.config_defaultNetworkRecommendationProviderPackage))
556                .thenReturn(name);
557    }
558
559    private void mockScoreNetworksGranted(String packageName) {
560        when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
561                .thenReturn(PackageManager.PERMISSION_GRANTED);
562    }
563
564    private void mockScoreNetworksDenied(String packageName) {
565        when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
566                .thenReturn(PackageManager.PERMISSION_DENIED);
567    }
568
569    private void mockRecommendationServiceAvailable(final ComponentName compName, int packageUid) {
570        mockRecommendationServiceAvailable(compName, packageUid, null, false);
571    }
572
573    private void mockRecommendationServiceAvailable(final ComponentName compName, int packageUid,
574            String enableUseOpenWifiActivityPackage) {
575        mockRecommendationServiceAvailable(
576                compName, packageUid, enableUseOpenWifiActivityPackage, false);
577    }
578
579    private void mockRecommendationServiceAvailable(final ComponentName compName, int packageUid,
580            String enableUseOpenWifiActivityPackage, boolean serviceLabelOverride) {
581        mockRecommendationServiceAvailable(compName, packageUid, enableUseOpenWifiActivityPackage,
582                serviceLabelOverride, false);
583    }
584
585    private void mockRecommendationServiceAvailable(final ComponentName compName, int packageUid,
586            String enableUseOpenWifiActivityPackage, boolean serviceLabelOverride,
587            boolean setNotificationChannel) {
588        final ResolveInfo serviceInfo = new ResolveInfo();
589        serviceInfo.serviceInfo = new ServiceInfo();
590        serviceInfo.serviceInfo.name = compName.getClassName();
591        serviceInfo.serviceInfo.packageName = compName.getPackageName();
592        serviceInfo.serviceInfo.applicationInfo = new ApplicationInfo();
593        serviceInfo.serviceInfo.applicationInfo.uid = packageUid;
594        if (enableUseOpenWifiActivityPackage != null) {
595            serviceInfo.serviceInfo.metaData = new Bundle();
596            serviceInfo.serviceInfo.metaData.putString(
597                    NetworkScoreManager.USE_OPEN_WIFI_PACKAGE_META_DATA,
598                    enableUseOpenWifiActivityPackage);
599        }
600        if (serviceLabelOverride) {
601            if (serviceInfo.serviceInfo.metaData == null) {
602                serviceInfo.serviceInfo.metaData = new Bundle();
603            }
604            serviceInfo.serviceInfo.metaData.putString(
605                    NetworkScoreManager.RECOMMENDATION_SERVICE_LABEL_META_DATA,
606                    MOCK_OVERRIDEN_SERVICE_LABEL);
607        } else {
608            serviceInfo.serviceInfo.nonLocalizedLabel = MOCK_SERVICE_LABEL;
609        }
610        if (setNotificationChannel) {
611            if (serviceInfo.serviceInfo.metaData == null) {
612                serviceInfo.serviceInfo.metaData = new Bundle();
613            }
614            serviceInfo.serviceInfo.metaData.putString(
615                    NetworkScoreManager.NETWORK_AVAILABLE_NOTIFICATION_CHANNEL_ID_META_DATA,
616                    MOCK_NETWORK_AVAILABLE_NOTIFICATION_CHANNEL_ID);
617        }
618
619        final int flags = PackageManager.GET_META_DATA;
620        when(mMockPm.resolveService(
621                Mockito.argThat(new ArgumentMatcher<Intent>() {
622                    @Override
623                    public boolean matchesObject(Object object) {
624                        Intent intent = (Intent) object;
625                        return NetworkScoreManager.ACTION_RECOMMEND_NETWORKS
626                                .equals(intent.getAction())
627                                && compName.getPackageName().equals(intent.getPackage());
628                    }
629                }), Mockito.eq(flags))).thenReturn(serviceInfo);
630
631        mAvailableServices.add(serviceInfo);
632    }
633
634    private void mockEnableUseOpenWifiActivity(final ComponentName useOpenWifiComp) {
635        final ResolveInfo resolveActivityInfo = new ResolveInfo();
636        resolveActivityInfo.activityInfo = new ActivityInfo();
637        resolveActivityInfo.activityInfo.name = useOpenWifiComp.getClassName();
638        resolveActivityInfo.activityInfo.packageName = useOpenWifiComp.getPackageName();
639
640        final int flags = 0;
641        when(mMockPm.resolveActivity(
642                Mockito.argThat(new ArgumentMatcher<Intent>() {
643                    @Override
644                    public boolean matchesObject(Object object) {
645                        Intent intent = (Intent) object;
646                        return NetworkScoreManager.ACTION_CUSTOM_ENABLE.equals(intent.getAction())
647                                && useOpenWifiComp.getPackageName().equals(intent.getPackage());
648                    }
649                }), Mockito.eq(flags))).thenReturn(resolveActivityInfo);
650    }
651}
652