xref: /frameworks/base/core/tests/coretests/src/android/content/pm/PackageHelperTests.java

/*
 * Copyright (C) 2011 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.content.pm;

import android.content.Context;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.ServiceManager;
import android.os.storage.IStorageManager;
import android.os.storage.StorageManager;
import android.os.storage.VolumeInfo;
import android.test.AndroidTestCase;
import android.util.Log;

import com.android.internal.content.PackageHelper;

import org.mockito.Mockito;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import static android.net.TrafficStats.MB_IN_BYTES;
import static android.os.storage.VolumeInfo.STATE_MOUNTED;

public class PackageHelperTests extends AndroidTestCase {
    private static final boolean localLOGV = true;
    public static final String TAG = "PackageHelperTests";
    protected final String PREFIX = "android.content.pm";
    private IStorageManager mSm;
    private String fullId;
    private String fullId2;

    private static final String sInternalVolPath = "/data";
    private static final String sAdoptedVolPath = "/mnt/expand/123";
    private static final String sPublicVolPath = "/emulated";

    private static final String sInternalVolUuid = StorageManager.UUID_PRIVATE_INTERNAL;
    private static final String sAdoptedVolUuid = "adopted";
    private static final String sPublicVolUuid = "emulated";

    private static final long sInternalSize = 20000;
    private static final long sAdoptedSize = 10000;
    private static final long sPublicSize = 1000000;

    private static StorageManager sStorageManager;

    private static StorageManager createStorageManagerMock() throws Exception {
        VolumeInfo internalVol = new VolumeInfo("private",
                VolumeInfo.TYPE_PRIVATE, null /*DiskInfo*/, null /*partGuid*/);
        internalVol.path = sInternalVolPath;
        internalVol.state = STATE_MOUNTED;
        internalVol.fsUuid = sInternalVolUuid;

        VolumeInfo adoptedVol = new VolumeInfo("adopted",
                VolumeInfo.TYPE_PRIVATE, null /*DiskInfo*/, null /*partGuid*/);
        adoptedVol.path = sAdoptedVolPath;
        adoptedVol.state = STATE_MOUNTED;
        adoptedVol.fsUuid = sAdoptedVolUuid;

        VolumeInfo publicVol = new VolumeInfo("public",
                VolumeInfo.TYPE_PUBLIC, null /*DiskInfo*/, null /*partGuid*/);
        publicVol.state = STATE_MOUNTED;
        publicVol.path = sPublicVolPath;
        publicVol.fsUuid = sPublicVolUuid;

        List<VolumeInfo> volumes = new ArrayList<>();
        volumes.add(internalVol);
        volumes.add(adoptedVol);
        volumes.add(publicVol);

        StorageManager storageManager = Mockito.mock(StorageManager.class);
        Mockito.when(storageManager.getVolumes()).thenReturn(volumes);

        File internalFile = new File(sInternalVolPath);
        File adoptedFile = new File(sAdoptedVolPath);
        File publicFile = new File(sPublicVolPath);
        UUID internalUuid = UUID.randomUUID();
        UUID adoptedUuid = UUID.randomUUID();
        UUID publicUuid = UUID.randomUUID();
        Mockito.when(storageManager.getStorageBytesUntilLow(internalFile)).thenReturn(sInternalSize);
        Mockito.when(storageManager.getStorageBytesUntilLow(adoptedFile)).thenReturn(sAdoptedSize);
        Mockito.when(storageManager.getStorageBytesUntilLow(publicFile)).thenReturn(sPublicSize);
        Mockito.when(storageManager.getUuidForPath(Mockito.eq(internalFile))).thenReturn(internalUuid);
        Mockito.when(storageManager.getUuidForPath(Mockito.eq(adoptedFile))).thenReturn(adoptedUuid);
        Mockito.when(storageManager.getUuidForPath(Mockito.eq(publicFile))).thenReturn(publicUuid);
        Mockito.when(storageManager.getAllocatableBytes(Mockito.eq(internalUuid), Mockito.anyInt()))
                .thenReturn(sInternalSize);
        Mockito.when(storageManager.getAllocatableBytes(Mockito.eq(adoptedUuid), Mockito.anyInt()))
                .thenReturn(sAdoptedSize);
        Mockito.when(storageManager.getAllocatableBytes(Mockito.eq(publicUuid), Mockito.anyInt()))
                .thenReturn(sPublicSize);
        return storageManager;
    }

    private static final class MockedInterface extends PackageHelper.TestableInterface {
        private boolean mForceAllowOnExternal = false;
        private boolean mAllow3rdPartyOnInternal = true;
        private ApplicationInfo mApplicationInfo = null;

        public void setMockValues(ApplicationInfo applicationInfo,
                boolean forceAllowOnExternal, boolean allow3rdPartyOnInternal) {
            mForceAllowOnExternal = forceAllowOnExternal;
            mAllow3rdPartyOnInternal = allow3rdPartyOnInternal;
            mApplicationInfo = applicationInfo;
        }

        @Override
        public StorageManager getStorageManager(Context context) {
            return sStorageManager;
        }

        @Override
        public boolean getForceAllowOnExternalSetting(Context context) {
            return mForceAllowOnExternal;
        }

        @Override
        public boolean getAllow3rdPartyOnInternalConfig(Context context) {
            return mAllow3rdPartyOnInternal;
        }

        @Override
        public ApplicationInfo getExistingAppInfo(Context context, String packagename) {
            return mApplicationInfo;
        }

        @Override
        public File getDataDirectory() {
            return new File(sInternalVolPath);
        }
    }

    private IStorageManager getSm() {
        IBinder service = ServiceManager.getService("mount");
        if (service != null) {
            return IStorageManager.Stub.asInterface(service);
        } else {
            Log.e(TAG, "Can't get mount service");
        }
        return null;
    }

    private void cleanupContainers() throws RemoteException {
        Log.d(TAG,"cleanUp");
        IStorageManager sm = getSm();
        String[] containers = sm.getSecureContainerList();
        for (int i = 0; i < containers.length; i++) {
            if (containers[i].startsWith(PREFIX)) {
                Log.d(TAG,"cleaing up "+containers[i]);
                sm.destroySecureContainer(containers[i], true);
            }
        }
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();
        sStorageManager = createStorageManagerMock();
        if (localLOGV) Log.i(TAG, "Cleaning out old test containers");
        cleanupContainers();
    }

    @Override
    protected void tearDown() throws Exception {
        super.tearDown();
        sStorageManager = null;
        if (localLOGV) Log.i(TAG, "Cleaning out old test containers");
        cleanupContainers();
    }

    public void testMountAndPullSdCard() throws Exception {
        fullId = PREFIX;
        fullId2 = PackageHelper.createSdDir(1024 * MB_IN_BYTES, fullId, "none",
                android.os.Process.myUid(), true);

        Log.d(TAG, "getSdDir=" + PackageHelper.getSdDir(fullId));
        PackageHelper.unMountSdDir(fullId);

        Runnable r1 = getMountRunnable();
        Runnable r2 = getDestroyRunnable();
        Thread thread = new Thread(r1);
        Thread thread2 = new Thread(r2);
        thread2.start();
        thread.start();
    }

    public Runnable getMountRunnable() {
        Runnable r = new Runnable () {
            public void run () {
                try {
                    Thread.sleep(5);
                    String path = PackageHelper.mountSdDir(fullId, "none",
                            android.os.Process.myUid());
                    Log.e(TAG, "mount done " + path);
                } catch (IllegalArgumentException iae) {
                    throw iae;
                } catch (Throwable t) {
                    Log.e(TAG, "mount failed", t);
                }
            }
        };
        return r;
    }

    public Runnable getDestroyRunnable() {
        Runnable r = new Runnable () {
            public void run () {
                try {
                    PackageHelper.destroySdDir(fullId);
                    Log.e(TAG, "destroy done: " + fullId);
                } catch (Throwable t) {
                    Log.e(TAG, "destroy failed", t);
                }
            }
        };
        return r;
    }

    public void testResolveInstallVolumeInternal_SystemApp() throws IOException {
        ApplicationInfo systemAppInfo = new ApplicationInfo();
        systemAppInfo.flags = ApplicationInfo.FLAG_SYSTEM;

        // All test cases for when the system app fits on internal.
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(systemAppInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            1 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(StorageManager.UUID_PRIVATE_INTERNAL, volume);

        mockedInterface.setMockValues(systemAppInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                1 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(StorageManager.UUID_PRIVATE_INTERNAL, volume);

        mockedInterface.setMockValues(systemAppInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                1 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(StorageManager.UUID_PRIVATE_INTERNAL, volume);

        mockedInterface.setMockValues(systemAppInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                1 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(StorageManager.UUID_PRIVATE_INTERNAL, volume);


        // All test cases for when the system app does not fit on internal.
        // Exception should be thrown.
        mockedInterface.setMockValues(systemAppInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location*/, 1000000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch(IOException e) {
            // expected
        }

        mockedInterface.setMockValues(systemAppInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location*/, 1000000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch(IOException e) {
            // expected
        }

        mockedInterface.setMockValues(systemAppInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location*/, 1000000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch(IOException e) {
            // expected
        }

        mockedInterface.setMockValues(systemAppInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location*/, 1000000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch(IOException e) {
            // expected
        }
    }

    public void testResolveInstallVolumeInternal_3rdParty_existing_not_too_big()
            throws IOException {
        // Existing apps always stay on the same volume.
        // Test cases for existing app on internal.
        ApplicationInfo appInfo = new ApplicationInfo();
        appInfo.volumeUuid = sInternalVolUuid;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sInternalVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sInternalVolUuid, volume);
    }

    public void testResolveInstallVolumeInternal_3rdParty_existing_not_too_big_adopted()
            throws IOException {
        // Test cases for existing app on the adopted media.
        ApplicationInfo appInfo = new ApplicationInfo();
        MockedInterface mockedInterface = new MockedInterface();
        String volume;
        appInfo.volumeUuid = sAdoptedVolUuid;
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);

        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);
    }

    public void testResolveInstallVolumeAdopted_3rdParty_existing_too_big() {
        // Test: update size too big, will throw exception.
        ApplicationInfo appInfo = new ApplicationInfo();
        appInfo.volumeUuid = sAdoptedVolUuid;

        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    0 /*install location*/, 10000001 /*BIG size, won't fit*/, mockedInterface);
            fail("Expected exception was not thrown " + appInfo.volumeUuid);
        } catch (IOException e) {
            //expected
        }

        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    0 /*install location*/, 10000001 /*BIG size, won't fit*/, mockedInterface);
            fail("Expected exception was not thrown " + appInfo.volumeUuid);
        } catch (IOException e) {
            //expected
        }

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    0 /*install location*/, 10000001 /*BIG size, won't fit*/, mockedInterface);
            fail("Expected exception was not thrown " + appInfo.volumeUuid);
        } catch (IOException e) {
            //expected
        }

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        try {
            PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    0 /*install location*/, 10000001 /*BIG size, won't fit*/, mockedInterface);
            fail("Expected exception was not thrown " + appInfo.volumeUuid);
        } catch (IOException e) {
            //expected
        }
    }

    public void testResolveInstallVolumeInternal_3rdParty_auto() throws IOException {
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the volume with bigger available space.
        assertEquals(sInternalVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the volume with bigger available space.
        assertEquals(sInternalVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the volume with bigger available space.
        assertEquals(sAdoptedVolUuid, volume);

        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the volume with bigger available space.
        assertEquals(sAdoptedVolUuid, volume);


    }

    public void testResolveInstallVolumeInternal_3rdParty_internal_only() throws IOException {
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            1 /*install location internal ONLY*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sInternalVolUuid, volume);

        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                1 /*install location internal ONLY*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sInternalVolUuid, volume);

        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        try {
            volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location internal only*/, 1000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch (IOException e) {
            //expected
        }

        appInfo = null;
        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                1 /*install location internal only*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);
    }

    public void testResolveInstallVolumeInternal_3rdParty_not_allowed_on_internal()
        throws IOException {
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the non-internal volume.
        assertEquals(sAdoptedVolUuid, volume);

        appInfo = null;
        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                0 /*install location auto*/, 1000 /*size bytes*/, mockedInterface);
        // Should return the non-internal volume.
        assertEquals(sAdoptedVolUuid, volume);
    }

    public void testResolveInstallVolumeInternal_3rdParty_internal_only_too_big() {
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                true /*allow 3rd party on internal*/);
        String volume = null;
        try {
            volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location internal ONLY*/,
                    1000000 /*size too big*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch (IOException e) {
            //expected
        }
    }

    public void testResolveInstallVolumeInternal_3rdParty_internal_only_not_allowed()
        throws IOException {
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, false /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        String volume = null;
        try {
            volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
                    1 /*install location internal only*/, 1000 /*size bytes*/, mockedInterface);
            fail("Expected exception in resolveInstallVolume was not thrown");
        } catch (IOException e) {
            //expected
        }

        appInfo = null;
        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            1 /*install location internal only*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);

    }

    public void testResolveInstallVolumeInternal_3rdParty_internal_only_forced_to_external()
        throws IOException {
        // New/existing installation: New
        // app request location: Internal Only
        // 3rd party allowed on internal: False
        // Force allow external in setting: True
        // Size fit? Yes
        ApplicationInfo appInfo = null;
        MockedInterface mockedInterface = new MockedInterface();
        mockedInterface.setMockValues(appInfo, true /*force allow on external*/,
                false /*allow 3rd party on internal*/);
        String volume = null;
        volume = PackageHelper.resolveInstallVolume(getContext(), "package.name",
            1 /*install location internal only*/, 1000 /*size bytes*/, mockedInterface);
        assertEquals(sAdoptedVolUuid, volume);
    }
}