core/tests/coretests/src/android/net/NetworkScorerAppManagerTest.java

/*
 * 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;

    private NetworkScorerAppManager mNetworkScorerAppManager;

    @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);
        mNetworkScorerAppManager = new NetworkScorerAppManager(mMockContext);
    }

    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 =
                mNetworkScorerAppManager.getAllValidScorers().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;
        }
    }
}