appium-espresso-driver 2.1.1 → 2.2.1

package/espresso-server/app/build.gradle.kts

@@ -84,6 +84,9 @@ android {
     }
 }
 
+val kotlinVersion = rootProject.extra["appiumKotlin"]
+val composeVersion = getStringProperty("appiumComposeVersion", Version.compose)
+
 dependencies {
     implementation(fileTree(mapOf("dir" to "libs", "include" to listOf("*.jar"))))
     // additionalAppDependencies placeholder (don't change or delete this line)
@@ -105,11 +108,11 @@ dependencies {
     testImplementation("org.mockito:mockito-core:${Version.mockito}")
     testImplementation("org.nanohttpd:nanohttpd-webserver:${Version.nanohttpd}")
     testImplementation("org.robolectric:robolectric:${Version.robolectric}")
-    testImplementation("org.jetbrains.kotlin:kotlin-test:${Version.kotlin}")
-    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:${Version.kotlin}")
-    testImplementation("org.jetbrains.kotlin:kotlin-reflect:${Version.kotlin}")
-    testImplementation("androidx.compose.ui:ui-test:${Version.compose}")
-    testImplementation("androidx.compose.ui:ui-test-junit4:${Version.compose}")
+    testImplementation("org.jetbrains.kotlin:kotlin-test:${kotlinVersion}")
+    testImplementation("org.jetbrains.kotlin:kotlin-test-junit:$kotlinVersion")
+    testImplementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
+    testImplementation("androidx.compose.ui:ui-test:${composeVersion}")
+    testImplementation("androidx.compose.ui:ui-test-junit4:${composeVersion}")
 
     androidTestImplementation("androidx.annotation:annotation:${Version.annotation}")
     androidTestImplementation("androidx.test.espresso:espresso-contrib:${Version.espresso}") {
@@ -124,10 +127,10 @@ dependencies {
     androidTestImplementation("androidx.test:rules:${Version.testlib}")
     androidTestImplementation("com.google.code.gson:gson:${Version.gson}")
     androidTestImplementation("org.nanohttpd:nanohttpd-webserver:${Version.nanohttpd}")
-    androidTestImplementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${Version.kotlin}")
-    androidTestImplementation("org.jetbrains.kotlin:kotlin-reflect:${Version.kotlin}")
-    androidTestImplementation("androidx.compose.ui:ui-test:${Version.compose}")
-    androidTestImplementation("androidx.compose.ui:ui-test-junit4:${Version.compose}"){
+    androidTestImplementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${kotlinVersion}")
+    androidTestImplementation("org.jetbrains.kotlin:kotlin-reflect:${kotlinVersion}")
+    androidTestImplementation("androidx.compose.ui:ui-test:${composeVersion}")
+    androidTestImplementation("androidx.compose.ui:ui-test-junit4:${composeVersion}"){
         isTransitive = false
     }
 
@@ -139,7 +142,6 @@ tasks.withType<Test> {
 }
 
 object Version {
-    const val kotlin = "1.5.10"
     const val espresso = "3.4.0"
     const val testlib = "1.4.0"
     const val mocklib = "2.0.9"

package/espresso-server/build.gradle.kts

@@ -1,20 +1,21 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-
-    val appiumKotlin =
-        properties.getOrDefault("appiumKotlin", "1.5.10")
-
-    val appiumAndroidGradlePlugin =
-        properties.getOrDefault("appiumAndroidGradlePlugin", "7.0.3")
+    extra.apply {
+        set("appiumKotlin", properties.getOrDefault("appiumKotlin", "1.5.10"))
+        set(
+            "appiumAndroidGradlePlugin",
+            properties.getOrDefault("appiumAndroidGradlePlugin", "7.0.3")
+        )
+    }
 
     repositories {
         google()
         mavenCentral()
     }
     dependencies {
-        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$appiumKotlin")
-        classpath("com.android.tools.build:gradle:$appiumAndroidGradlePlugin")
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${rootProject.extra["appiumKotlin"]}")
+        classpath("com.android.tools.build:gradle:${rootProject.extra["appiumAndroidGradlePlugin"]}")
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle.kts files

package/lib/commands/general.js

@@ -1,11 +1,10 @@
 import _ from 'lodash';
 import { util } from '@appium/support';
-import logger from '../logger';
 import validate from 'validate.js';
 import { errors } from '@appium/base-driver';
 import { qualifyActivityName } from '../utils';
 
-let commands = {}, helpers = {}, extensions = {};
+const commands = {}, helpers = {}, extensions = {};
 
 function assertRequiredOptions (options, requiredOptionNames) {
   if (!_.isArray(requiredOptionNames)) {
@@ -62,7 +61,7 @@ commands.mobileGetDeviceInfo = async function mobileGetDeviceInfo () {
 commands.mobileIsToastVisible = async function mobileIsToastVisible (opts = {}) {
   const {text, isRegexp} = opts;
   if (!util.hasValue(text)) {
-    logger.errorAndThrow(`'text' argument is mandatory`);
+    throw new errors.InvalidArgumentError(`'text' argument is mandatory`);
   }
   return await this.espresso.jwproxy.command('/appium/execute_mobile/is_toast_displayed', 'POST', {
     text,
@@ -110,8 +109,7 @@ commands.mobileNavigateTo = async function mobileNavigateTo (opts = {}) {
 
   let menuItemIdAsNumber = parseInt(menuItemId, 10);
   if (_.isNaN(menuItemIdAsNumber) || menuItemIdAsNumber < 0) {
-    logger.errorAndThrow(`'menuItemId' must be a non-negative number. Found ${menuItemId}`);
-    menuItemId = menuItemIdAsNumber;
+    throw new errors.InvalidArgumentError(`'menuItemId' must be a non-negative number. Found ${menuItemId}`);
   }
 
   return await this.espresso.jwproxy.command(`/appium/execute_mobile/${util.unwrapElement(element)}/navigate_to`, 'POST', {
@@ -163,15 +161,14 @@ commands.mobileScrollToPage = async function mobileScrollToPage (opts = {}) {
       },
     },
   });
-
   if (util.hasValue(res)) {
-    logger.errorAndThrow(`Invalid scrollTo parameters: ${JSON.stringify(res)}`);
+    throw new errors.InvalidArgumentError(`Invalid scrollTo parameters: ${JSON.stringify(res)}`);
   }
 
   const {element, scrollTo, scrollToPage, smoothScroll} = opts;
 
   if (util.hasValue(scrollTo) && util.hasValue(scrollToPage)) {
-    logger.warn(`'scrollTo' and 'scrollToPage' where both provided. Defaulting to 'scrollTo'`);
+    this.log.warn(`'scrollTo' and 'scrollToPage' where both provided. Defaulting to 'scrollTo'`);
   }
 
   return await this.espresso.jwproxy.command(`/appium/execute_mobile/${util.unwrapElement(element)}/scroll_to_page`, 'POST', {
@@ -307,7 +304,7 @@ commands.startActivity = async function startActivity (appPackage, appActivity,
   appWaitPackage = appWaitPackage || appPackage;
   appActivity = qualifyActivityName(appActivity, appPackage);
   appWaitActivity = qualifyActivityName(appWaitActivity || appActivity, appWaitPackage);
-  logger.debug(`Starting activity '${appActivity}' for package '${appPackage}'`);
+  this.log.debug(`Starting activity '${appActivity}' for package '${appPackage}'`);
   await this.espresso.jwproxy.command(`/appium/device/start_activity`, 'POST', {
     appPackage,
     appActivity,

package/lib/driver.js

@@ -1,8 +1,8 @@
 import _ from 'lodash';
+import path from 'path';
 import { BaseDriver, errors, isErrorType, DeviceSettings} from '@appium/base-driver';
 import { EspressoRunner, TEST_APK_PKG } from './espresso-runner';
-import { fs } from '@appium/support';
-import logger from './logger';
+import { fs, tempDir, zip } from '@appium/support';
 import commands from './commands';
 import { DEFAULT_ADB_PORT } from 'appium-adb';
 import { androidHelpers, androidCommands, SETTINGS_HELPER_PKG_ID } from 'appium-android-driver';
@@ -120,6 +120,10 @@ const CHROME_NO_PROXY = [
 ];
 
 
+const APK_EXT = '.apk';
+const AAB_EXT = '.aab';
+const SUPPORTED_EXTENSIONS = [APK_EXT, AAB_EXT];
+
 class EspressoDriver extends BaseDriver {
   constructor (opts = {}, shouldValidateCaps = true) {
     // `shell` overwrites adb.shell, so remove
@@ -175,11 +179,11 @@ class EspressoDriver extends BaseDriver {
 
       if (this.isChromeSession) {
         if (this.opts.app) {
-          logger.warn(`'browserName' capability will be ignored`);
-          logger.warn(`Chrome browser cannot be run in Espresso sessions because Espresso automation doesn't ` +
+          this.log.warn(`'browserName' capability will be ignored`);
+          this.log.warn(`Chrome browser cannot be run in Espresso sessions because Espresso automation doesn't ` +
               `have permission to access Chrome`);
         } else {
-          logger.errorAndThrow(`Chrome browser sessions cannot be run in Espresso because Espresso ` +
+          this.log.errorAndThrow(`Chrome browser sessions cannot be run in Espresso because Espresso ` +
             `automation doesn't have permission to access Chrome`);
         }
       }
@@ -204,15 +208,15 @@ class EspressoDriver extends BaseDriver {
         // find and copy, or download and unzip an app url or path
         this.opts.app = await this.helpers.configureApp(this.opts.app, {
           onPostProcess: this.onPostConfigureApp.bind(this),
-          supportedExtensions: ['.apk', '.aab']
+          supportedExtensions: SUPPORTED_EXTENSIONS
         });
       } else if (this.appOnDevice) {
         // the app isn't an actual app file but rather something we want to
         // assume is on the device and just launch via the appPackage
-        logger.info(`App file was not listed, instead we're going to run ` +
+        this.log.info(`App file was not listed, instead we're going to run ` +
             `${this.opts.appPackage} directly on the device`);
         if (!await this.adb.isAppInstalled(this.opts.appPackage)) {
-          logger.errorAndThrow(`Could not find the package '${this.opts.appPackage}' ` +
+          this.log.errorAndThrow(`Could not find the package '${this.opts.appPackage}' ` +
             `installed on the device`);
         }
       }
@@ -233,10 +237,40 @@ class EspressoDriver extends BaseDriver {
     }
   }
 
+  /**
+   * Unzip the given app path and return the first package that has SUPPORTED_EXTENSIONS
+   * in the archived file.
+   *
+   * @param {string} appPath The path to app file.
+   * @returns {string} Retuns the path to an unzipped app file path.
+   * @throws Raise an exception if the zip did not have any SUPPORTED_EXTENSIONS packages.
+   */
+  async unzipApp (appPath) {
+    const useSystemUnzipEnv = process.env.APPIUM_PREFER_SYSTEM_UNZIP;
+    const useSystemUnzip = _.isEmpty(useSystemUnzipEnv)
+      || !['0', 'false'].includes(_.toLower(useSystemUnzipEnv));
+    const tmpRoot = await tempDir.openDir();
+    await zip.extractAllTo(appPath, tmpRoot, {useSystemUnzip});
+
+    const globPattern = `**/*.+(${SUPPORTED_EXTENSIONS.map((ext) => ext.replace(/^\./, '')).join('|')})`;
+    const sortedBundleItems = (await fs.glob(globPattern, {
+      cwd: tmpRoot,
+      strict: false,
+    })).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
+    if (sortedBundleItems.length === 0) {
+      // no expected packages in the zip
+      this.log.errorAndThrow(`${this.opts.app} did not have any of '${SUPPORTED_EXTENSIONS.join(', ')}' ` +
+        `extension packages. Please make sure the provided .zip archive contains at least one valid application package.`);
+    }
+    const unzippedAppPath = path.join(tmpRoot, _.first(sortedBundleItems));
+    this.log.debug(`'${unzippedAppPath}' is the unzipped file from '${appPath}'`);
+    return unzippedAppPath;
+  }
+
   async onPostConfigureApp ({cachedAppInfo, isUrl, appPath}) {
     const presignApp = async (appLocation) => {
       if (this.opts.noSign) {
-        logger.info('Skipping application signing because noSign capability is set to true. ' +
+        this.log.info('Skipping application signing because noSign capability is set to true. ' +
           'Having the application under test with improper signature/non-signed will cause ' +
           'Espresso automation startup failure.');
       } else if (!await this.adb.checkApkCert(appLocation, this.opts.appPackage)) {
@@ -244,25 +278,51 @@ class EspressoDriver extends BaseDriver {
       }
     };
 
-    const isApk = _.endsWith(_.toLower(appPath), '.apk');
-    // Do not cache .apk if was already present on the local file system
-    const shouldResultAppPathBeCached = !isApk || (isApk && isUrl);
+    const hasApkExt = (appPath) => _.endsWith(_.toLower(appPath), APK_EXT);
+    const hasAabExt = (appPath) => _.endsWith(_.toLower(appPath), AAB_EXT);
+    const extractUniversalApk = async (shouldExtract, appPath) =>
+      shouldExtract ? appPath : await this.adb.extractUniversalApk(appPath);
+
     let pathInCache = null;
     let isResultAppPathAlreadyCached = false;
     if (_.isPlainObject(cachedAppInfo)) {
       const packageHash = await fs.hash(appPath);
       if (packageHash === cachedAppInfo.packageHash && await fs.exists(cachedAppInfo.fullPath)) {
+        this.log.info(`Using '${cachedAppInfo.fullPath}' which is cached from '${appPath}'`);
         isResultAppPathAlreadyCached = true;
         pathInCache = cachedAppInfo.fullPath;
       }
     }
+
+    // appPath can be .zip, .apk or .aab
+    const isApk = hasApkExt(appPath);
+    // Only local .apk files that are available in-place should not be cached
+    const shouldResultAppPathBeCached = !isApk || (isApk && isUrl);
+
     if (!isResultAppPathAlreadyCached) {
       if (shouldResultAppPathBeCached) {
-        pathInCache = isApk ? appPath : await this.adb.extractUniversalApk(appPath);
+        // .zip, .aab or downloaded .apk
+
+        let unzippedAppPath;
+        let isUnzippedApk = false;
+        if (!(hasApkExt(appPath) || hasAabExt(appPath))) {
+          unzippedAppPath = await this.unzipApp(appPath);
+          isUnzippedApk = hasApkExt(unzippedAppPath);
+        }
+
+        // unzippedAppPath or appPath has SUPPORTED_EXTENSIONS.
+        pathInCache = unzippedAppPath
+          ? await extractUniversalApk(isUnzippedApk, unzippedAppPath)
+          : await extractUniversalApk(isApk, appPath);
+
         if (!isApk && isUrl) {
-          // Clean up the temporarily downloaded .aab package
+          // Clean up the temporarily downloaded .aab or .zip package
           await fs.rimraf(appPath);
         }
+        if (hasAabExt(unzippedAppPath)) {
+          // Cleanup the local unzipped .aab file
+          await fs.rimraf(unzippedAppPath);
+        }
         await presignApp(pathInCache);
       } else if (isApk) {
         // It is probably not the best idea to modify the provided app in-place,
@@ -285,13 +345,13 @@ class EspressoDriver extends BaseDriver {
   // TODO this method is duplicated from uiautomator2-driver; consolidate
   setAvdFromCapabilities (caps) {
     if (this.opts.avd) {
-      logger.info('avd name defined, ignoring device name and platform version');
+      this.log.info('avd name defined, ignoring device name and platform version');
     } else {
       if (!caps.deviceName) {
-        logger.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
+        this.log.errorAndThrow('avd or deviceName should be specified when reboot option is enables');
       }
       if (!caps.platformVersion) {
-        logger.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
+        this.log.errorAndThrow('avd or platformVersion should be specified when reboot option is enabled');
       }
       let avdDevice = caps.deviceName.replace(/[^a-zA-Z0-9_.]/g, '-');
       this.opts.avd = `${avdDevice}__${caps.platformVersion}`;
@@ -309,11 +369,11 @@ class EspressoDriver extends BaseDriver {
 
   // TODO much of this logic is duplicated from uiautomator2
   async startEspressoSession () {
-    logger.info(`EspressoDriver version: ${version}`);
+    this.log.info(`EspressoDriver version: ${version}`);
 
     // Read https://github.com/appium/appium-android-driver/pull/461 what happens if ther is no setHiddenApiPolicy for Android P+
     if (await this.adb.getApiLevel() >= 28) { // Android P
-      logger.warn('Relaxing hidden api policy');
+      this.log.warn('Relaxing hidden api policy');
       await this.adb.setHiddenApiPolicy('1', !!this.opts.ignoreHiddenApiPolicyError);
     }
 
@@ -335,7 +395,7 @@ class EspressoDriver extends BaseDriver {
         await this.adb.setAnimationState(false);
         this.wasAnimationEnabled = true;
       } catch (err) {
-        logger.warn(`Unable to turn off animations: ${err.message}`);
+        this.log.warn(`Unable to turn off animations: ${err.message}`);
       }
     }
 
@@ -346,14 +406,14 @@ class EspressoDriver extends BaseDriver {
     // set up the modified espresso server etc
     this.initEspressoServer();
     // Further prepare the device by forwarding the espresso port
-    logger.debug(`Forwarding Espresso Server port ${DEVICE_PORT} to ${this.opts.systemPort}`);
+    this.log.debug(`Forwarding Espresso Server port ${DEVICE_PORT} to ${this.opts.systemPort}`);
     await this.adb.forwardPort(this.opts.systemPort, DEVICE_PORT);
 
     if (!this.opts.skipUnlock) {
       // unlock the device to prepare it for testing
       await helpers.unlock(this, this.adb, this.caps);
     } else {
-      logger.debug(`'skipUnlock' capability set, so skipping device unlock`);
+      this.log.debug(`'skipUnlock' capability set, so skipping device unlock`);
     }
 
     // set up app under test
@@ -382,7 +442,7 @@ class EspressoDriver extends BaseDriver {
     // launch espresso and wait till its online and we have a session
     await this.espresso.startSession(this.caps);
     if (this.caps.autoLaunch === false) {
-      logger.info(`Not waiting for the application activity to start because 'autoLaunch' is disabled`);
+      this.log.info(`Not waiting for the application activity to start because 'autoLaunch' is disabled`);
     } else {
       await this.adb.waitForActivity(this.caps.appWaitPackage, this.caps.appWaitActivity, this.opts.appWaitDuration);
     }
@@ -402,7 +462,7 @@ class EspressoDriver extends BaseDriver {
   async initWebview () {
     const viewName = androidCommands.defaultWebviewName.call(this);
     const timeout = this.opts.autoWebviewTimeout || 2000;
-    logger.info(`Setting webview to context '${viewName}' with timeout ${timeout}ms`);
+    this.log.info(`Setting webview to context '${viewName}' with timeout ${timeout}ms`);
     await retryInterval(timeout / 500, 500, this.setContext.bind(this), viewName);
   }
 
@@ -426,7 +486,7 @@ class EspressoDriver extends BaseDriver {
   initEspressoServer () {
     // now that we have package and activity, we can create an instance of
     // espresso with the appropriate data
-    this.espresso = new EspressoRunner({
+    this.espresso = new EspressoRunner(this.log, {
       host: this.opts.remoteAdbHost || this.opts.host || '127.0.0.1',
       systemPort: this.opts.systemPort,
       devicePort: DEVICE_PORT,
@@ -471,9 +531,9 @@ class EspressoDriver extends BaseDriver {
 
     if (!this.opts.app) {
       if (this.opts.fullReset) {
-        logger.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');
+        this.log.errorAndThrow('Full reset requires an app capability, use fastReset if app is not provided');
       }
-      logger.debug('No app capability. Assuming it is already on the device');
+      this.log.debug('No app capability. Assuming it is already on the device');
       if (this.opts.fastReset) {
         await helpers.resetApp(this.adb, this.opts);
       }
@@ -486,20 +546,20 @@ class EspressoDriver extends BaseDriver {
       await helpers.installApk(this.adb, this.opts);
     }
     if (this.opts.skipServerInstallation) {
-      logger.debug('skipServerInstallation capability is set. Not installig espresso-server ');
+      this.log.debug('skipServerInstallation capability is set. Not installig espresso-server ');
     } else {
       await this.espresso.installTestApk();
       try {
         await this.adb.addToDeviceIdleWhitelist(SETTINGS_HELPER_PKG_ID, TEST_APK_PKG);
       } catch (e) {
-        logger.warn(`Cannot add server packages to the Doze whitelist. Original error: ` +
+        this.log.warn(`Cannot add server packages to the Doze whitelist. Original error: ` +
           (e.stderr || e.message));
       }
     }
   }
 
   async deleteSession () {
-    logger.debug('Deleting espresso session');
+    this.log.debug('Deleting espresso session');
 
     try {
       if (!_.isEmpty(this._screenRecordingProperties)) {
@@ -525,29 +585,29 @@ class EspressoDriver extends BaseDriver {
         try {
           await this.adb.setAnimationState(true);
         } catch (err) {
-          logger.warn(`Unable to reset animation: ${err.message}`);
+          this.log.warn(`Unable to reset animation: ${err.message}`);
         }
       }
       if (this.opts.unicodeKeyboard && this.opts.resetKeyboard &&
           this.defaultIME) {
-        logger.debug(`Resetting IME to '${this.defaultIME}'`);
+        this.log.debug(`Resetting IME to '${this.defaultIME}'`);
         await this.adb.setIME(this.defaultIME);
       }
       if (!this.isChromeSession && this.opts.appPackage && !this.opts.dontStopAppOnReset) {
         await this.adb.forceStop(this.opts.appPackage);
       }
       if (this.opts.fullReset && !this.opts.skipUninstall && !this.appOnDevice) {
-        logger.debug(`FULL_RESET set to 'true', Uninstalling '${this.opts.appPackage}'`);
+        this.log.debug(`FULL_RESET set to 'true', Uninstalling '${this.opts.appPackage}'`);
         await this.adb.uninstallApk(this.opts.appPackage);
       }
       await this.adb.stopLogcat();
       if (this.opts.reboot) {
         let avdName = this.opts.avd.replace('@', '');
-        logger.debug(`closing emulator '${avdName}'`);
+        this.log.debug(`closing emulator '${avdName}'`);
         await this.adb.killEmulator(avdName);
       }
       if (await this.adb.getApiLevel() >= 28) { // Android P
-        logger.info('Restoring hidden api policy to the device default configuration');
+        this.log.info('Restoring hidden api policy to the device default configuration');
         await this.adb.setDefaultHiddenApiPolicy(!!this.opts.ignoreHiddenApiPolicyError);
       }
     }
@@ -556,7 +616,7 @@ class EspressoDriver extends BaseDriver {
       try {
         await this.adb.removePortForward(this.opts.systemPort);
       } catch (error) {
-        logger.warn(`Unable to remove port forward '${error.message}'`);
+        this.log.warn(`Unable to remove port forward '${error.message}'`);
         //Ignore, this block will also be called when we fall in catch block
         // and before even port forward.
       }