path: root/prod-tests/src/com/android/framework/tests/PackageManagerHostTestUtils.java

/*
 * Copyright (C) 2010 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 com.android.framework.tests;

import com.android.ddmlib.testrunner.IRemoteAndroidTestRunner;
import com.android.ddmlib.testrunner.RemoteAndroidTestRunner;
import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.device.IFileEntry;
import com.android.tradefed.device.ITestDevice;
import com.android.tradefed.log.LogUtil.CLog;
import com.android.tradefed.result.CollectingTestListener;

import junit.framework.Assert;

import java.io.File;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Set of tests that verify host side install cases
 */
public class PackageManagerHostTestUtils extends Assert {
    private ITestDevice mDevice = null;
    private boolean mEmulatedExternalStorage = false;

    // TODO: get this value from Android Environment instead of hard coding
    public static final String PRE_JB_APP_PRIVATE_PATH = "/data/app-private/";
    public static final String JB_APP_PRIVATE_PATH = "/mnt/asec/";
    public static final String JB_ASEC_PRIVATE_PATH = "/data/app-asec/";
    public static final String DEVICE_APP_PATH = "/data/app/";
    public static final String SDCARD_APP_PATH = "/mnt/secure/asec/";

    private static String mAppPrivatePath = PRE_JB_APP_PRIVATE_PATH;

    private static final int MAX_WAIT_FOR_DEVICE_TIME = 120 * 1000;

    // Install preference on the device-side
    public static enum InstallLocPreference {
        AUTO,
        INTERNAL,
        EXTERNAL
    }

    // Actual install location
    public static enum InstallLocation {
        DEVICE,
        SDCARD
    }

    /**
     * Constructor.
     *
     * @param device the {@link ITestDevice} to use when performing operations.
     * @throws DeviceNotAvailableException
     */
    public PackageManagerHostTestUtils(ITestDevice device)
            throws DeviceNotAvailableException {
        mDevice = device;
        determineExternalStorageEmulation();
    }

    /**
     * Returns the path on the device of forward-locked apps.
     *
     * @return path of forward-locked apps on the device
     */
    public static String getAppPrivatePath() {
        return mAppPrivatePath;
    }

    public static void setAppPrivatePath(String path) {
        mAppPrivatePath = path;
    }

    /**
     * Returns the path on the device of normal apps.
     *
     * @return path of forward-locked apps on the device
     */
    public static String getDeviceAppPath() {
        return DEVICE_APP_PATH;
    }

    /**
     * Returns the path of apps installed on the SD card.
     *
     * @return path of forward-locked apps on the device
     */
    public static String getSDCardAppPath() {
        return SDCARD_APP_PATH;
    }

    /**
     * Helper method to run tests and return the listener that collected the
     * results. For the optional params, pass null to use the default values.
     *
     * @param pkgName Android application package for tests
     * @param className (optional) The class containing the method to test
     * @param methodName (optional) The method in the class of which to test
     * @param runnerName (optional) The name of the TestRunner of the test on
     *            the device to be run
     * @param params (optional) Any additional parameters to pass into the Test
     *            Runner
     * @return the {@link CollectingTestRunListener}
     * @throws DeviceNotAvailableException
     */
    private CollectingTestListener doRunTests(String pkgName, String className,
            String methodName, String runnerName, Map<String, String> params)
            throws DeviceNotAvailableException {
        IRemoteAndroidTestRunner testRunner = new RemoteAndroidTestRunner(pkgName, runnerName,
                mDevice.getIDevice());

        if (className != null && methodName != null) {
            testRunner.setMethodName(className, methodName);
        }

        // Add in any additional args to pass into the test
        if (params != null) {
            for (Entry<String, String> argPair : params.entrySet()) {
                testRunner.addInstrumentationArg(argPair.getKey(), argPair.getValue());
            }
        }

        CollectingTestListener listener = new CollectingTestListener();
        mDevice.runInstrumentationTests(testRunner, listener);
        return listener;
    }

    /**
     * Runs the specified packages tests, and returns whether all tests passed
     * or not.
     *
     * @param pkgName Android application package for tests
     * @param className The class containing the method to test
     * @param methodName The method in the class of which to test
     * @param runnerName The name of the TestRunner of the test on the device to
     *            be run
     * @param params Any additional parameters to pass into the Test Runner
     * @return true if test passed, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean runDeviceTestsDidAllTestsPass(String pkgName, String className,
            String methodName, String runnerName, Map<String, String> params)
            throws DeviceNotAvailableException {
        CollectingTestListener listener = doRunTests(pkgName, className, methodName,
                runnerName, params);
        return !listener.hasFailedTests();
    }

    /**
     * Runs the specified packages tests, and returns whether all tests passed
     * or not.
     *
     * @param pkgName Android application package for tests
     * @return true if every test passed, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean runDeviceTestsDidAllTestsPass(String pkgName)
            throws DeviceNotAvailableException {
        CollectingTestListener listener = doRunTests(pkgName, null, null, null, null);
        return !listener.hasFailedTests();
    }

    /**
     * Helper method to install a file
     *
     * @param localFile the {@link File} to install
     * @param reinstall set to <code>true</code> if re-install of app should be
     *            performed
     * @throws DeviceNotAvailableException
     */
    public void installFile(final File localFile, final boolean replace)
            throws DeviceNotAvailableException {
        String result = mDevice.installPackage(localFile, replace);
        assertEquals(null, result);
    }

    /**
     * Helper method to install a file to device as forward locked.
     *
     * @param apkFile the {@link File} to install
     * @param replace set to <code>true</code> if re-install of app should be
     *            performed
     * @throws DeviceNotAvailableException if communication with device is lost
     */
    public String installFileForwardLocked(final File apkFile, final boolean replace)
            throws DeviceNotAvailableException {
        return mDevice.installPackage(apkFile, replace, "-l");
    }

    /**
     * Helper method to install an encrypted apk to the device.
     *
     * @param apkFile the {@link File} to install
     * @param replace set to <code>true</code> if re-install of app should be
     *            performed
     * @param algorithm the encryption algorithm used for the encrypted apk
     * @param iv the initialization vector used for the encrypted apk
     * @param encryptionKey the encryption key used for the encrypted apk
     * @param macAlgorithm the mac algorithm used
     * @param macKey the mac key used
     * @param macTag the mac tag used
     * @return
     * @throws DeviceNotAvailableException
     */
    public String installFileEncrypted(final File apkFile, final boolean replace,
            final String algorithm, final String iv, final String encryptionKey,
            final String macAlgorithm, final String macKey, final String macTag)
            throws DeviceNotAvailableException {
        return mDevice.installPackage(apkFile, replace, "-l", "--algo", algorithm, "--iv", iv,
                "--key", encryptionKey, "--macalgo", macAlgorithm,
                "--mackey", macKey, "--tag", macTag);
    }

    /**
     * Helper method to determine if file exists on the device containing a
     * given string.
     *
     * @param destPath the absolute path of the file
     * @return <code>true</code> if file exists containing given string,
     *         <code>false</code> otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean doesRemoteFileExistContainingString(String destPath, String searchString)
            throws DeviceNotAvailableException {
        String lsResult = mDevice.executeShellCommand(String.format("ls %s", destPath));
        return lsResult.contains(searchString);
    }

    /**
     * Helper method to determine if package on device exists.
     *
     * @param packageName the Android manifest package to check.
     * @return <code>true</code> if package exists, <code>false</code> otherwise
     * @throws DeviceNotAvailableException
     */
    public boolean doesPackageExist(String packageName) throws DeviceNotAvailableException {
        String pkgGrep = mDevice.executeShellCommand(String.format("pm path %s", packageName));
        return pkgGrep.contains("package:");
    }

    /**
     * Determines if app was installed on device.
     *
     * @param packageName package name to check for
     * @return <code>true</code> if file exists, <code>false</code> otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean doesAppExistOnDevice(String packageName) throws DeviceNotAvailableException {
        return doesRemoteFileExistContainingString(DEVICE_APP_PATH, packageName);
    }

    /**
     * Determines if app was installed on SD card.
     *
     * @param packageName package name to check for
     * @return <code>true</code> if file exists, <code>false</code> otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean doesAppExistOnSDCard(String packageName) throws DeviceNotAvailableException {

        // if we're using emulated storage, the SDcard path is actually the
        // device's normal app path
        if (getIsExternalStorageEmulated()) {
            return doesRemoteFileExistContainingString(DEVICE_APP_PATH, packageName);
        }
        else {
            return doesRemoteFileExistContainingString(SDCARD_APP_PATH, packageName);
        }
    }

    /**
     * Helper method to determine if app was installed as forward locked.
     *
     * @param packageName package name to check for
     * @return <code>true</code> if file exists, <code>false</code> otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean doesAppExistAsForwardLocked(String packageName)
            throws DeviceNotAvailableException {
        return doesRemoteFileExistContainingString(mAppPrivatePath, packageName);
    }

    /**
     * Waits for device's package manager to respond.
     *
     * @throws DeviceNotAvailableException
     */
    public void waitForPackageManager() throws DeviceNotAvailableException {
        CLog.i("waiting for device");
        mDevice.waitForDeviceAvailable(MAX_WAIT_FOR_DEVICE_TIME);
    }

    /**
     * Helper method for installing an app to wherever is specified in its
     * manifest, and then verifying the app was installed onto SD Card.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param the path of the apk to install
     * @param the name of the package
     * @param <code>true</code> if the app should be overwritten,
     *        <code>false</code> otherwise
     * @throws DeviceNotAvailableException
     */
    public void installAppAndVerifyExistsOnSDCard(File apkPath, String pkgName, boolean overwrite)
            throws DeviceNotAvailableException {
        // Start with a clean slate if we're not overwriting
        if (!overwrite) {
            // cleanup test app just in case it already exists
            mDevice.uninstallPackage(pkgName);
            // grep for package to make sure its not installed
            assertFalse(doesPackageExist(pkgName));
        }

        installFile(apkPath, overwrite);
        assertTrue(doesAppExistOnSDCard(pkgName));
        // TODO: is this necessary?
        waitForPackageManager();

        // grep for package to make sure it is installed
        assertTrue(doesPackageExist(pkgName));
    }

    /**
     * Helper method for installing an app to wherever is specified in its
     * manifest, and then verifying the app was installed onto device.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param apkFile the {@link File} of the apk to install
     * @param the name of the package
     * @param <code>true</code> if the app should be overwritten,
     *        <code>false</code> otherwise
     * @throws DeviceNotAvailableException
     */
    public void installAppAndVerifyExistsOnDevice(File apkFile, String pkgName, boolean overwrite)
            throws DeviceNotAvailableException {
        // Start with a clean slate if we're not overwriting
        if (!overwrite) {
            // cleanup test app just in case it already exists
            mDevice.uninstallPackage(pkgName);
            // grep for package to make sure its not installed
            assertFalse(doesPackageExist(pkgName));
        }

        installFile(apkFile, overwrite);
        assertTrue(doesAppExistOnDevice(pkgName));
        // TODO: is this necessary?
        waitForPackageManager();

        // grep for package to make sure it is installed
        assertTrue(doesPackageExist(pkgName));
    }

    /**
     * Helper method for installing an app as forward-locked, and then verifying
     * the app was installed in the proper forward-locked location.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param apkFile the {@link File} of the apk to install
     * @param pkgName the name of the package
     * @param overwrite <code>true</code> if the app should be overwritten,
     *            <code>false</code> otherwise
     * @throws Exception if failed to install app
     */
    public void installFwdLockedAppAndVerifyExists(File apkFile,
            String pkgName, boolean overwrite) throws Exception {
        // Start with a clean slate if we're not overwriting
        if (!overwrite) {
            // cleanup test app just in case it already exists
            mDevice.uninstallPackage(pkgName);
            // grep for package to make sure its not installed
            assertFalse(doesPackageExist(pkgName));
        }

        String result = installFileForwardLocked(apkFile, overwrite);
        assertEquals(null, result);
        assertTrue(doesAppExistAsForwardLocked(pkgName));
        waitForPackageManager();

        // grep for package to make sure it is installed
        assertTrue(doesPackageExist(pkgName));
    }

    /**
     * Helper method for installing an encrypted apk and then verifies the
     * package exists.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param apkFile the {@link File} of the apk to install
     * @param pkgName the name of the package
     * @param overwrite <code>true</code> if the app should be overwritten,
     *            <code>false</code> otherwise
     * @param algorithm the encryption algorithm used for the encrypted apk
     * @param iv the initialization vector used for the encrypted apk
     * @param encryptionKey the encryption key used for the encrypted apk
     * @param macAlgorithm the mac algorithm used
     * @param macKey the mac key used
     * @param macTag the mac tag used
     * @throws DeviceNotAvailableException
     */
    public void installEncryptedAppAndVerifyExists(File apkFile, String pkgName, boolean overwrite,
            final String algorithm, final String iv, final String encryptionKey,
            final String macAlgorithm, final String macKey, final String macTag)
            throws DeviceNotAvailableException {
        // Start with a clean slate if we're not overwriting
        if (!overwrite) {
            // cleanup test app just in case it already exists
            mDevice.uninstallPackage(pkgName);
            // grep for package to make sure its not installed
            assertFalse(doesPackageExist(pkgName));
        }
        String result = installFileEncrypted(apkFile, overwrite, algorithm, iv, encryptionKey,
                macAlgorithm, macKey, macTag);
        assertEquals(null, result);
        waitForPackageManager();

        // grep for package to make sure it is installed
        assertTrue(doesPackageExist(pkgName));
    }

    /**
     * Helper method to ensure that the encrypted apk and asec file are stored
     * in the correct location.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param packageName the name of the package
     * @param externalStorage {@link boolean} whether the file is stored to
     *            external sd card.
     * @return true if the app is indeed encrypted, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean appExistsAsEncrypted(String packageName, boolean externalStorage)
            throws DeviceNotAvailableException {
        // getIsExternalStorageEmulated()
        if (externalStorage) {
            if (doesRemoteFileExistContainingString(JB_APP_PRIVATE_PATH, packageName) &&
                    doesRemoteFileExistContainingString(SDCARD_APP_PATH, packageName)) {
                return true;
            }
        } else {
            if (doesRemoteFileExistContainingString(JB_APP_PRIVATE_PATH, packageName) &&
                    doesRemoteFileExistContainingString(JB_ASEC_PRIVATE_PATH, packageName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Helper method for uninstalling an app.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @param pkgName package name to uninstall
     * @throws DeviceNotAvailableException
     */
    public void uninstallApp(String pkgName) throws DeviceNotAvailableException {
        mDevice.uninstallPackage(pkgName);
        waitForPackageManager();
        // make sure its not installed anymore
        assertFalse(doesPackageExist(pkgName));
    }

    /**
     * Sets the device's install location preference.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @throws DeviceNotAvailableException
     */
    public void setDevicePreferredInstallLocation(InstallLocPreference pref)
            throws DeviceNotAvailableException {
        String command = "pm set-install-location %d";
        int locValue = 0;
        switch (pref) {
            case INTERNAL:
                locValue = 1;
                break;
            case EXTERNAL:
                locValue = 2;
                break;
            default: // AUTO
                locValue = 0;
                break;
        }
        mDevice.executeShellCommand(String.format(command, locValue));
    }

    /**
     * Gets the device's install location preference.
     * <p/>
     * Assumes adb is running as root in device under test.
     *
     * @throws DeviceNotAvailableException
     */
    public InstallLocPreference getDevicePreferredInstallLocation()
            throws DeviceNotAvailableException {
        String result = mDevice.executeShellCommand("pm get-install-location");
        if (result.indexOf('0') != -1) {
            return InstallLocPreference.AUTO;
        }
        else if (result.indexOf('1') != -1) {
            return InstallLocPreference.INTERNAL;
        }
        else {
            return InstallLocPreference.EXTERNAL;
        }
    }

    /**
     * Determines whether the device is using emulated external storage.
     * <p/>
     * Sets mEmulatedExternalStorage based on the result Assumes adb is running
     * as root in device under test.
     *
     * @throws DeviceNotAvailableException
     */
    private void determineExternalStorageEmulation()
            throws DeviceNotAvailableException {
        String result = mDevice.executeShellCommand("dumpsys mount");
        if (result.indexOf("mEmulated=true") != -1) {
            CLog.i("Device is using emulated external storage.");
            mEmulatedExternalStorage = true;
        }
        else if (result.indexOf("mEmulated=false") != -1) {
            CLog.i("Device is using actual external storage.");
            mEmulatedExternalStorage = false;
        }
        else {
            // older devices will not have mEmulated flag in the output
            CLog.i("Unable to precisely determine external storage emulation; assuming false.");
            mEmulatedExternalStorage = false;
        }
    }

    /**
     * Determine the location of the app private path.
     *
     * @param apkFile the {@link File} of test apk to determine packages'
     *            install path.
     * @param pkgName the {@link String} pkgName of the test apk.
     * @throws DeviceNotAvailableException
     */
    public void determinePrivateAppPath(File apkFile, String pkgName)
            throws DeviceNotAvailableException {
        String result = installFileForwardLocked(apkFile, true);
        assertEquals(null, result);
        waitForPackageManager();

        // grep for package to make sure it is installed
        assertTrue(doesPackageExist(pkgName));

        // Determine path of secret path.
        result = mDevice.executeShellCommand("pm path " + pkgName);
        if (result.indexOf(PRE_JB_APP_PRIVATE_PATH) != -1) {
            setAppPrivatePath(PRE_JB_APP_PRIVATE_PATH);
        } else if (result.indexOf(JB_APP_PRIVATE_PATH) != -1) {
            setAppPrivatePath(JB_APP_PRIVATE_PATH);
        } else {
            Assert.fail("Failed to locate private app path on device.");
        }
        CLog.d("Device private app path is: %s", getAppPrivatePath());
        uninstallApp(pkgName);
    }

    /**
     * Returns whether the external storage is emulated or not.
     *
     * @return <code>true</code> if external storage is emulated,
     *         <code>false</code> otherwise.
     */
    public boolean getIsExternalStorageEmulated() {
        return mEmulatedExternalStorage;
    }

    /**
     * Connect device to wifi.
     *
     * @param device
     * @param wifiNetwork
     * @param wifiPsk
     * @param connectionAttempts
     * @return true if able to connect to wifi.
     * @throws DeviceNotAvailableException
     */
    public static boolean connectToWifi(ITestDevice device, String wifiNetwork, String wifiPsk,
            int connectionAttempts) throws DeviceNotAvailableException {
        if (wifiNetwork != null) {
            for (int i = 0; i < connectionAttempts; i++) {
                device.disconnectFromWifi();
                if (device.connectToWifiNetwork(wifiNetwork, wifiPsk)) {
                    CLog.i("Connected to wifi network %s", wifiNetwork);
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * Ensure that the file's permissions matches expectation.
     *
     * @param remoteFilePath {@link String} the remote path for the file to check.
     * @param expectedPerms {@link String} expected permissions.
     * @return true if the permissions for a given file matches, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean checkFilePermissions(String remoteFilePath, String expectedPerms)
            throws DeviceNotAvailableException {
        IFileEntry file = mDevice.getFileEntry(remoteFilePath);
        return file.getPermissions().equals(expectedPerms);
    }

    /**
     * Ensure that the file's owner matches expectation.
     *
     * @param remoteFilePath {@link String} the remote path for the file to check.
     * @param expectedOwner {@link String} the expected owner.
     * @return true if the owner for a given file matches, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean checkFileOwnerName(String remoteFilePath, String expectedOwner)
            throws DeviceNotAvailableException {
        //TODO: uncomment this, when we have support from ddmlib.
        //IFileEntry file = mDevice.getFileEntry(remoteFilePath);
        // return file.getOwner().equals(expectedOwner)
        return true;
    }

    /**
     * Ensure that the file's group matches expectation
     *
     * @param remoteFilePath {@link String} the remote path for the file to check.
     * @param expectedGroup {@link String} the expected group.
     * @return true if the group for a given file matches, false otherwise.
     * @throws DeviceNotAvailableException
     */
    public boolean checkFileGroupName(String remoteFilePath, String expectedGroup)
            throws DeviceNotAvailableException {
        //TODO: uncomment this, when we have support from ddmlib.
        //IFileEntry file = mDevice.getFileEntry(remoteFilePath);
        // return file.getGroup().equals(expectedOwner)
        return true;
    }

    /**
     * Returns the uid of the installed package.
     * @param pkgName package name of the test apk.
     * @return uid of the installed package
     * @throws DeviceNotAvailableException
     */
    public Integer getUid(String pkgName) throws DeviceNotAvailableException {
        String out = mDevice.executeShellCommand(String.format("dumpsys package %s", pkgName));
        Matcher m = Pattern.compile("userId=(\\d+)").matcher(out);
        assertTrue(m.find());

        Integer uid = Integer.parseInt(m.group(1));
        CLog.v("package %s has uid %d", pkgName, uid);
        return uid;
    }

    public String getAbi(String pkgName) throws DeviceNotAvailableException {
        String out = mDevice.executeShellCommand(String.format("dumpsys package %s", pkgName));
        Matcher m = Pattern.compile("primaryCpuAbi=(.+)").matcher(out);
        assertTrue(m.find());

        String abi = m.group(1);
        CLog.i("package %s has abi %s", pkgName, abi);
        return abi;
    }
}