Home | History | Annotate | Download | only in net 
      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 
     17 package android.net;
     18 
     19 import android.Manifest.permission;
     20 import android.content.Context;
     21 import android.content.Intent;
     22 import android.content.pm.ActivityInfo;
     23 import android.content.pm.ApplicationInfo;
     24 import android.content.pm.PackageManager;
     25 import android.content.pm.ResolveInfo;
     26 import android.net.NetworkScorerAppManager.NetworkScorerAppData;
     27 import android.test.InstrumentationTestCase;
     28 import android.util.Pair;
     29 
     30 import org.mockito.ArgumentMatcher;
     31 import org.mockito.Mock;
     32 import org.mockito.Mockito;
     33 import org.mockito.MockitoAnnotations;
     34 
     35 import java.util.ArrayList;
     36 import java.util.Collections;
     37 import java.util.Iterator;
     38 import java.util.List;
     39 
     40 public 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", true, true, false);
     61 
     62         // Package 2 - Receiver does not have BROADCAST_SCORE_NETWORKS permission.
     63         Pair<ResolveInfo, ResolveInfo> package2 = buildResolveInfo("package2", false, true, false);
     64 
     65         // Package 3 - App does not have SCORE_NETWORKS permission.
     66         Pair<ResolveInfo, ResolveInfo> package3 = buildResolveInfo("package3", true, false, false);
     67 
     68         // Package 4 - Valid scorer w/ optional config activity.
     69         Pair<ResolveInfo, ResolveInfo> package4 = buildResolveInfo("package4", true, true, true);
     70 
     71         List<Pair<ResolveInfo, ResolveInfo>> scorers = new ArrayList<>();
     72         scorers.add(package1);
     73         scorers.add(package2);
     74         scorers.add(package3);
     75         scorers.add(package4);
     76         setScorers(scorers);
     77 
     78         Iterator<NetworkScorerAppData> result =
     79                 NetworkScorerAppManager.getAllValidScorers(mMockContext).iterator();
     80 
     81         assertTrue(result.hasNext());
     82         NetworkScorerAppData next = result.next();
     83         assertEquals("package1", next.mPackageName);
     84         assertNull(next.mConfigurationActivityClassName);
     85 
     86         assertTrue(result.hasNext());
     87         next = result.next();
     88         assertEquals("package4", next.mPackageName);
     89         assertEquals(".ConfigActivity", next.mConfigurationActivityClassName);
     90 
     91         assertFalse(result.hasNext());
     92     }
     93 
     94     private void setScorers(List<Pair<ResolveInfo, ResolveInfo>> scorers) {
     95         List<ResolveInfo> receivers = new ArrayList<>();
     96         for (final Pair<ResolveInfo, ResolveInfo> scorer : scorers) {
     97             receivers.add(scorer.first);
     98             if (scorer.second != null) {
     99                 // This scorer has a config activity.
    100                 Mockito.when(mMockPm.queryIntentActivities(
    101                         Mockito.argThat(new ArgumentMatcher<Intent>() {
    102                             @Override
    103                             public boolean matches(Object object) {
    104                                 Intent intent = (Intent) object;
    105                                 return NetworkScoreManager.ACTION_CUSTOM_ENABLE.equals(
    106                                         intent.getAction())
    107                                         && scorer.first.activityInfo.packageName.equals(
    108                                                 intent.getPackage());
    109                             }
    110                         }), Mockito.eq(0))).thenReturn(Collections.singletonList(scorer.second));
    111             }
    112         }
    113 
    114         Mockito.when(mMockPm.queryBroadcastReceivers(
    115                 Mockito.argThat(new ArgumentMatcher<Intent>() {
    116                     @Override
    117                     public boolean matches(Object object) {
    118                         Intent intent = (Intent) object;
    119                         return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(intent.getAction());
    120                     }
    121                 }), Mockito.eq(0)))
    122                 .thenReturn(receivers);
    123     }
    124 
    125     private Pair<ResolveInfo, ResolveInfo> buildResolveInfo(String packageName,
    126             boolean hasReceiverPermission, boolean hasScorePermission, boolean hasConfigActivity)
    127             throws Exception {
    128         Mockito.when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
    129                 .thenReturn(hasScorePermission ?
    130                         PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED);
    131 
    132         ResolveInfo resolveInfo = new ResolveInfo();
    133         resolveInfo.activityInfo = new ActivityInfo();
    134         resolveInfo.activityInfo.packageName = packageName;
    135         resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
    136         if (hasReceiverPermission) {
    137             resolveInfo.activityInfo.permission = permission.BROADCAST_SCORE_NETWORKS;
    138         }
    139 
    140         ResolveInfo configActivityInfo = null;
    141         if (hasConfigActivity) {
    142             configActivityInfo = new ResolveInfo();
    143             configActivityInfo.activityInfo = new ActivityInfo();
    144             configActivityInfo.activityInfo.name = ".ConfigActivity";
    145         }
    146         return Pair.create(resolveInfo, configActivityInfo);
    147     }
    148 }
    149