appium-espresso-driver 2.1.1 → 2.2.1

package/lib/espresso-runner.js

@@ -1,6 +1,5 @@
 import { JWProxy, errors } from '@appium/base-driver';
 import { waitForCondition } from 'asyncbox';
-import logger from './logger';
 import { ServerBuilder, buildServerSigningConfig } from './server-builder';
 import path from 'path';
 import { fs, util, mkdirp, timing } from '@appium/support';
@@ -38,14 +37,16 @@ class EspressoProxy extends JWProxy {
 }
 
 class EspressoRunner {
-  constructor (opts = {}) {
+  constructor (log, opts = {}) {
     for (let req of REQUIRED_PARAMS) {
       if (!opts || !util.hasValue(opts[req])) {
         throw new Error(`Option '${req}' is required!`);
       }
       this[req] = opts[req];
     }
+    this.log = log;
     this.jwproxy = new EspressoProxy({
+      log,
       server: this.host,
       port: this.systemPort,
       base: '',
@@ -85,11 +86,11 @@ class EspressoRunner {
 
   async isAppPackageChanged () {
     if (!await this.adb.fileExists(TARGET_PACKAGE_CONTAINER)) {
-      logger.debug('The previous target application package is unknown');
+      this.log.debug('The previous target application package is unknown');
       return true;
     }
     const previousAppPackage = (await this.adb.shell(['cat', TARGET_PACKAGE_CONTAINER])).trim();
-    logger.debug(`The previous target application package was '${previousAppPackage}'. ` +
+    this.log.debug(`The previous target application package was '${previousAppPackage}'. ` +
       `The current package is '${this.appPackage}'`);
     return previousAppPackage !== this.appPackage;
   }
@@ -110,21 +111,21 @@ class EspressoRunner {
     ].includes(appState);
 
     if (shouldUninstallApp) {
-      logger.info(`Uninstalling Espresso Test Server apk from the target device (pkg: '${TEST_APK_PKG}')`);
+      this.log.info(`Uninstalling Espresso Test Server apk from the target device (pkg: '${TEST_APK_PKG}')`);
       try {
         await this.adb.uninstallApk(TEST_APK_PKG);
       } catch (err) {
-        logger.warn(`Error uninstalling '${TEST_APK_PKG}': ${err.message}`);
+        this.log.warn(`Error uninstalling '${TEST_APK_PKG}': ${err.message}`);
       }
     }
 
     if (shouldInstallApp) {
-      logger.info(`Installing Espresso Test Server apk from the target device (path: '${this.modServerPath}')`);
+      this.log.info(`Installing Espresso Test Server apk from the target device (path: '${this.modServerPath}')`);
       try {
         await this.adb.install(this.modServerPath, { replace: false, timeout: this.androidInstallTimeout });
-        logger.info(`Installed Espresso Test Server apk '${this.modServerPath}' (pkg: '${TEST_APK_PKG}')`);
+        this.log.info(`Installed Espresso Test Server apk '${this.modServerPath}' (pkg: '${TEST_APK_PKG}')`);
       } catch (err) {
-        logger.errorAndThrow(`Cannot install '${this.modServerPath}' because of '${err.message}'`);
+        this.log.errorAndThrow(`Cannot install '${this.modServerPath}' because of '${err.message}'`);
       }
     }
   }
@@ -132,14 +133,14 @@ class EspressoRunner {
   async installTestApk () {
     let rebuild = this.forceEspressoRebuild;
     if (rebuild) {
-      logger.debug(`'forceEspressoRebuild' capability is enabled`);
+      this.log.debug(`'forceEspressoRebuild' capability is enabled`);
     } else if (await this.isAppPackageChanged()) {
-      logger.info(`Forcing Espresso server rebuild because of changed application package`);
+      this.log.info(`Forcing Espresso server rebuild because of changed application package`);
       rebuild = true;
     }
 
     if (rebuild && await fs.exists(this.modServerPath)) {
-      logger.debug(`Deleting the obsolete Espresso server package '${this.modServerPath}'`);
+      this.log.debug(`Deleting the obsolete Espresso server package '${this.modServerPath}'`);
       await fs.unlink(this.modServerPath);
     }
     if (!(await fs.exists(this.modServerPath))) {
@@ -150,7 +151,7 @@ class EspressoRunner {
       await this.adb.sign(this.modServerPath);
     }
     if ((rebuild || !isSigned) && await this.adb.uninstallApk(TEST_APK_PKG)) {
-      logger.info('Uninstalled the obsolete Espresso server package from the device under test');
+      this.log.info('Uninstalled the obsolete Espresso server package from the device under test');
     }
 
     await this.installServer();
@@ -161,16 +162,16 @@ class EspressoRunner {
     if (this.espressoBuildConfig) {
       let buildConfigurationStr;
       if (await fs.exists(this.espressoBuildConfig)) {
-        logger.info(`Loading the build configuration from '${this.espressoBuildConfig}'`);
+        this.log.info(`Loading the build configuration from '${this.espressoBuildConfig}'`);
         buildConfigurationStr = await fs.readFile(this.espressoBuildConfig, 'utf8');
       } else {
-        logger.info(`Loading the build configuration from 'espressoBuildConfig' capability`);
+        this.log.info(`Loading the build configuration from 'espressoBuildConfig' capability`);
         buildConfigurationStr = this.espressoBuildConfig;
       }
       try {
         buildConfiguration = JSON.parse(buildConfigurationStr);
       } catch (e) {
-        logger.error('Cannot parse the build configuration JSON', e);
+        this.log.error('Cannot parse the build configuration JSON', e);
         throw e;
       }
     }
@@ -178,26 +179,26 @@ class EspressoRunner {
       replacement: '-',
     });
     const serverPath = path.resolve(this.tmpDir, dirName);
-    logger.info(`Building espresso server in '${serverPath}'`);
-    logger.debug(`The build folder root could be customized by changing the 'tmpDir' capability`);
+    this.log.info(`Building espresso server in '${serverPath}'`);
+    this.log.debug(`The build folder root could be customized by changing the 'tmpDir' capability`);
     await fs.rimraf(serverPath);
     await mkdirp(serverPath);
-    logger.debug(`Copying espresso server template from ('${TEST_SERVER_ROOT}' to '${serverPath}')`);
+    this.log.debug(`Copying espresso server template from ('${TEST_SERVER_ROOT}' to '${serverPath}')`);
     await copyGradleProjectRecursively(TEST_SERVER_ROOT, serverPath);
-    logger.debug('Bulding espresso server');
-    await new ServerBuilder({
+    this.log.debug('Bulding espresso server');
+    await new ServerBuilder(this.log, {
       serverPath, buildConfiguration,
       showGradleLog: this.showGradleLog,
       testAppPackage: this.appPackage,
       signingConfig: this.signingConfig
     }).build();
     const apkPath = path.resolve(serverPath, 'app', 'build', 'outputs', 'apk', 'androidTest', 'debug', 'app-debug-androidTest.apk');
-    logger.debug(`Copying built apk from '${apkPath}' to '${this.modServerPath}'`);
+    this.log.debug(`Copying built apk from '${apkPath}' to '${this.modServerPath}'`);
     await fs.copyFile(apkPath, this.modServerPath);
   }
 
   async cleanupSessionLeftovers () {
-    logger.debug('Performing cleanup of automation leftovers');
+    this.log.debug('Performing cleanup of automation leftovers');
 
     try {
       const {value} = (await axios({
@@ -206,8 +207,8 @@ class EspressoRunner {
       })).data;
       const activeSessionIds = value.map((sess) => sess.id);
       if (activeSessionIds.length) {
-        logger.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);
-        logger.debug('Cleaning up the obsolete sessions');
+        this.log.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);
+        this.log.debug('Cleaning up the obsolete sessions');
         await B.all(activeSessionIds.map((id) =>
           axios({
             url: `http://${this.host}:${this.systemPort}/session/${id}`,
@@ -217,10 +218,10 @@ class EspressoRunner {
         // Let all sessions to be properly terminated before continuing
         await B.delay(1000);
       } else {
-        logger.debug('No obsolete sessions have been detected');
+        this.log.debug('No obsolete sessions have been detected');
       }
     } catch (e) {
-      logger.debug(`No obsolete sessions have been detected (${e.message})`);
+      this.log.debug(`No obsolete sessions have been detected (${e.message})`);
     }
   }
 
@@ -241,7 +242,7 @@ class EspressoRunner {
 
     cmd.push(`${TEST_APK_PKG}/androidx.test.runner.AndroidJUnitRunner`);
 
-    logger.info(`Starting Espresso Server v${version} with cmd: adb ${cmd.join(' ')}`);
+    this.log.info(`Starting Espresso Server v${version} with cmd: adb ${cmd.join(' ')}`);
 
     let hasSocketError = false;
     // start the instrumentation process
@@ -251,7 +252,7 @@ class EspressoRunner {
     };
     this.instProcess = this.adb.createSubProcess(cmd);
     this.instProcess.on('exit', (code, signal) => {
-      logger.info(`Instrumentation process exited with code ${code} from signal ${signal}`);
+      this.log.info(`Instrumentation process exited with code ${code} from signal ${signal}`);
       this.jwproxy.instrumentationState.exited = true;
     });
     this.instProcess.on('output', (stdout, stderr) => {
@@ -261,7 +262,7 @@ class EspressoRunner {
         return;
       }
 
-      logger.debug(`[Instrumentation] ${line.trim()}`);
+      this.log.debug(`[Instrumentation] ${line.trim()}`);
       // A 'SocketException' indicates that we couldn't connect to the Espresso server,
       // because the INTERNET permission is not set
       if (line.toLowerCase().includes('java.net.socketexception')) {
@@ -273,15 +274,15 @@ class EspressoRunner {
 
     const timer = new timing.Timer().start();
     await this.instProcess.start(0);
-    logger.info(`Waiting up to ${this.serverLaunchTimeout}ms for Espresso server to be online`);
+    this.log.info(`Waiting up to ${this.serverLaunchTimeout}ms for Espresso server to be online`);
     try {
       await waitForCondition(async () => {
         if (hasSocketError) {
-          logger.errorAndThrow(`Espresso server has failed to start due to an unexpected exception. ` +
+          this.log.errorAndThrow(`Espresso server has failed to start due to an unexpected exception. ` +
             `Make sure the 'INTERNET' permission is requested in the Android manifest of your ` +
             `application under test (<uses-permission android:name="android.permission.INTERNET" />)`);
         } else if (this.jwproxy.instrumentationState.exited) {
-          logger.errorAndThrow(`Espresso server process has been unexpectedly terminated. ` +
+          this.log.errorAndThrow(`Espresso server process has been unexpectedly terminated. ` +
             `Check the Appium server log and the logcat output for more details`);
         }
         try {
@@ -296,15 +297,15 @@ class EspressoRunner {
       });
     } catch (e) {
       if (/Condition unmet/.test(e.message)) {
-        logger.errorAndThrow(`Timed out waiting for Espresso server to be ` +
+        this.log.errorAndThrow(`Timed out waiting for Espresso server to be ` +
           `online within ${this.serverLaunchTimeout}ms. The timeout value could be ` +
           `customized using 'espressoServerLaunchTimeout' capability`);
       }
       throw e;
     }
-    logger.info(`Espresso server is online. ` +
+    this.log.info(`Espresso server is online. ` +
       `The initialization process took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
-    logger.info('Starting the session');
+    this.log.info('Starting the session');
 
     await this.jwproxy.command('/session', 'POST', {
       capabilities: {
@@ -317,17 +318,17 @@ class EspressoRunner {
 
   async recordTargetAppPackage () {
     await this.adb.shell([`echo "${this.appPackage}" > "${TARGET_PACKAGE_CONTAINER}"`]);
-    logger.info(`Recorded the target application package '${this.appPackage}' to ${TARGET_PACKAGE_CONTAINER}`);
+    this.log.info(`Recorded the target application package '${this.appPackage}' to ${TARGET_PACKAGE_CONTAINER}`);
   }
 
   async deleteSession () {
-    logger.debug('Deleting Espresso server session');
+    this.log.debug('Deleting Espresso server session');
     // rely on jwproxy's intelligence to know what we're talking about and
     // delete the current session
     try {
       await this.jwproxy.command('/', 'DELETE');
     } catch (err) {
-      logger.warn(`Did not get confirmation Espresso deleteSession worked; ` +
+      this.log.warn(`Did not get confirmation Espresso deleteSession worked; ` +
           `Error was: ${err}`);
     }
 

package/lib/server-builder.js

@@ -1,7 +1,6 @@
 import { SubProcess } from 'teen_process';
-import { fs, logger, system } from '@appium/support';
+import { fs, system } from '@appium/support';
 import _ from 'lodash';
-import log from './logger';
 import path from 'path';
 import { EOL } from 'os';
 import { updateDependencyLines } from './utils';
@@ -22,11 +21,10 @@ const VERSION_KEYS = [
   'kotlin',
   'sourceCompatibility',
   'targetCompatibility',
-  'jvmTarget'
+  'jvmTarget',
+  'composeVersion'
 ];
 
-const gradleLog = logger.getLogger('Gradle');
-
 function buildServerSigningConfig (args) {
   return {
     zipAlign: true,
@@ -38,7 +36,8 @@ function buildServerSigningConfig (args) {
 }
 
 class ServerBuilder {
-  constructor (args = {}) {
+  constructor (log, args = {}) {
+    this.log = log;
     this.serverPath = args.serverPath;
     this.showGradleLog = args.showGradleLog;
 
@@ -73,7 +72,7 @@ class ServerBuilder {
   }
 
   getCommand () {
-    const cmd = system.isWindows() ? 'gradlew.bat' : './gradlew';
+    const cmd = system.isWindows() ? 'gradlew.bat' : path.resolve(this.serverPath, 'gradlew');
     const buildProperty = (key, value) => value ? `-P${key}=${value}` : null;
     let args = VERSION_KEYS
       .filter((key) => key !== GRADLE_VERSION_KEY)
@@ -150,7 +149,7 @@ class ServerBuilder {
         continue;
       }
 
-      log.info(`Adding the following ${propName} to build.gradle.kts: ${deps}`);
+      this.log.info(`Adding the following ${propName} to build.gradle.kts: ${deps}`);
       configuration = updateDependencyLines(configuration, propName, deps);
     }
     await fs.writeFile(buildPath, configuration, 'utf8');
@@ -158,7 +157,7 @@ class ServerBuilder {
 
   async runBuildProcess () {
     const {cmd, args} = this.getCommand();
-    log.debug(`Beginning build with command '${cmd} ${args.join(' ')}' ` +
+    this.log.debug(`Beginning build with command '${cmd} ${args.join(' ')}' ` +
       `in directory '${this.serverPath}'`);
     const gradlebuild = new SubProcess(cmd, args, {
       cwd: this.serverPath,
@@ -168,13 +167,13 @@ class ServerBuilder {
     let buildLastLines = [];
 
     const logMsg = `Output from Gradle ${this.showGradleLog ? 'will' : 'will not'} be logged`;
-    log.debug(`${logMsg}. To change this, use 'showGradleLog' desired capability`);
+    this.log.debug(`${logMsg}. To change this, use 'showGradleLog' desired capability`);
     gradlebuild.on('stream-line', (line) => {
       if (this.showGradleLog) {
         if (line.startsWith('[STDERR]')) {
-          gradleLog.warn(line);
+          this.log.warn(`[Gradle] ${line}`);
         } else {
-          gradleLog.info(line);
+          this.log.info(`[Gradle] ${line}`);
         }
       }
       buildLastLines.push(`${EOL}${line}`);
@@ -189,7 +188,7 @@ class ServerBuilder {
     } catch (err) {
       let msg = `Unable to build Espresso server - ${err.message}\n` +
         `Gradle error message:${EOL}${buildLastLines}`;
-      log.errorAndThrow(msg);
+      this.log.errorAndThrow(msg);
     }
   }
 }