/*
* Copyright (C) 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
package android.net;
import android.Manifest.permission;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.ServiceInfo;
import android.net.NetworkScorerAppManager.NetworkScorerAppData;
import android.os.UserHandle;
import android.test.InstrumentationTestCase;
import org.mockito.ArgumentMatcher;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
public class NetworkScorerAppManagerTest extends InstrumentationTestCase {
@Mock private Context mMockContext;
@Mock private PackageManager mMockPm;
@Override
public void setUp() throws Exception {
super.setUp();
// Configuration needed to make mockito/dexcache work.
System.setProperty("dexmaker.dexcache",
getInstrumentation().getTargetContext().getCacheDir().getPath());
ClassLoader newClassLoader = getInstrumentation().getClass().getClassLoader();
Thread.currentThread().setContextClassLoader(newClassLoader);
MockitoAnnotations.initMocks(this);
Mockito.when(mMockContext.getPackageManager()).thenReturn(mMockPm);
}
public void testGetAllValidScorers() throws Exception {
// Package 1 - Valid scorer.
ResolveInfoHolder package1 = buildResolveInfo("package1", 1, true, true, false, false);
// Package 2 - Receiver does not have BROADCAST_NETWORK_PRIVILEGED permission.
ResolveInfoHolder package2 = buildResolveInfo("package2", 2, false, true, false, false);
// Package 3 - App does not have SCORE_NETWORKS permission.
ResolveInfoHolder package3 = buildResolveInfo("package3", 3, true, false, false, false);
// Package 4 - Valid scorer w/ optional config activity.
ResolveInfoHolder package4 = buildResolveInfo("package4", 4, true, true, true, false);
// Package 5 - Valid scorer w/ optional service to bind to.
ResolveInfoHolder package5 = buildResolveInfo("package5", 5, true, true, false, true);
List<ResolveInfoHolder> scorers = new ArrayList<>();
scorers.add(package1);
scorers.add(package2);
scorers.add(package3);
scorers.add(package4);
scorers.add(package5);
setScorers(scorers);
Iterator<NetworkScorerAppData> result =
NetworkScorerAppManager.getAllValidScorers(mMockContext).iterator();
assertTrue(result.hasNext());
NetworkScorerAppData next = result.next();
assertEquals("package1", next.mPackageName);
assertEquals(1, next.mPackageUid);
assertNull(next.mConfigurationActivityClassName);
assertTrue(result.hasNext());
next = result.next();
assertEquals("package4", next.mPackageName);
assertEquals(4, next.mPackageUid);
assertEquals(".ConfigActivity", next.mConfigurationActivityClassName);
assertTrue(result.hasNext());
next = result.next();
assertEquals("package5", next.mPackageName);
assertEquals(5, next.mPackageUid);
assertEquals(".ScoringService", next.mScoringServiceClassName);
assertFalse(result.hasNext());
}
private void setScorers(List<ResolveInfoHolder> scorers) {
List<ResolveInfo> receivers = new ArrayList<>();
for (final ResolveInfoHolder scorer : scorers) {
receivers.add(scorer.scorerResolveInfo);
if (scorer.configActivityResolveInfo != null) {
// This scorer has a config activity.
Mockito.when(mMockPm.queryIntentActivities(
Mockito.argThat(new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Object object) {
Intent intent = (Intent) object;
return NetworkScoreManager.ACTION_CUSTOM_ENABLE.equals(
intent.getAction())
&& scorer.scorerResolveInfo.activityInfo.packageName.equals(
intent.getPackage());
}
}), Mockito.eq(0))).thenReturn(
Collections.singletonList(scorer.configActivityResolveInfo));
}
if (scorer.serviceResolveInfo != null) {
// This scorer has a service to bind to
Mockito.when(mMockPm.resolveService(
Mockito.argThat(new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Object object) {
Intent intent = (Intent) object;
return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(
intent.getAction())
&& scorer.scorerResolveInfo.activityInfo.packageName.equals(
intent.getPackage());
}
}), Mockito.eq(0))).thenReturn(scorer.serviceResolveInfo);
}
}
Mockito.when(mMockPm.queryBroadcastReceiversAsUser(
Mockito.argThat(new ArgumentMatcher<Intent>() {
@Override
public boolean matches(Object object) {
Intent intent = (Intent) object;
return NetworkScoreManager.ACTION_SCORE_NETWORKS.equals(intent.getAction());
}
}), Mockito.eq(0), Mockito.eq(UserHandle.USER_SYSTEM)))
.thenReturn(receivers);
}
private ResolveInfoHolder buildResolveInfo(String packageName, int packageUid,
boolean hasReceiverPermission, boolean hasScorePermission, boolean hasConfigActivity,
boolean hasServiceInfo) throws Exception {
Mockito.when(mMockPm.checkPermission(permission.SCORE_NETWORKS, packageName))
.thenReturn(hasScorePermission ?
PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED);
ResolveInfo resolveInfo = new ResolveInfo();
resolveInfo.activityInfo = new ActivityInfo();
resolveInfo.activityInfo.packageName = packageName;
resolveInfo.activityInfo.applicationInfo = new ApplicationInfo();
resolveInfo.activityInfo.applicationInfo.uid = packageUid;
if (hasReceiverPermission) {
resolveInfo.activityInfo.permission = permission.BROADCAST_NETWORK_PRIVILEGED;
}
ResolveInfo configActivityInfo = null;
if (hasConfigActivity) {
configActivityInfo = new ResolveInfo();
configActivityInfo.activityInfo = new ActivityInfo();
configActivityInfo.activityInfo.name = ".ConfigActivity";
}
ResolveInfo serviceInfo = null;
if (hasServiceInfo) {
serviceInfo = new ResolveInfo();
serviceInfo.serviceInfo = new ServiceInfo();
serviceInfo.serviceInfo.name = ".ScoringService";
}
return new ResolveInfoHolder(resolveInfo, configActivityInfo, serviceInfo);
}
private static class ResolveInfoHolder {
final ResolveInfo scorerResolveInfo;
final ResolveInfo configActivityResolveInfo;
final ResolveInfo serviceResolveInfo;
public ResolveInfoHolder(ResolveInfo scorerResolveInfo,
ResolveInfo configActivityResolveInfo, ResolveInfo serviceResolveInfo) {
this.scorerResolveInfo = scorerResolveInfo;
this.configActivityResolveInfo = configActivityResolveInfo;
this.serviceResolveInfo = serviceResolveInfo;
}
}
}