appium-espresso-driver 1.46.0

package/build/lib/espresso-runner.js

@@ -0,0 +1,381 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.TEST_APK_PKG = exports.REQUIRED_PARAMS = exports.EspressoRunner = void 0;
+
+require("source-map-support/register");
+
+var _appiumBaseDriver = require("appium-base-driver");
+
+var _asyncbox = require("asyncbox");
+
+var _logger = _interopRequireDefault(require("./logger"));
+
+var _serverBuilder = require("./server-builder");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _appiumSupport = require("appium-support");
+
+var _package = require("../../package.json");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _utils = require("./utils");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+const TEST_SERVER_ROOT = _path.default.resolve(__dirname, '..', '..', 'espresso-server');
+
+const TEST_APK_PKG = 'io.appium.espressoserver.test';
+exports.TEST_APK_PKG = TEST_APK_PKG;
+const REQUIRED_PARAMS = ['adb', 'tmpDir', 'host', 'systemPort', 'devicePort', 'appPackage', 'forceEspressoRebuild'];
+exports.REQUIRED_PARAMS = REQUIRED_PARAMS;
+const ESPRESSO_SERVER_LAUNCH_TIMEOUT_MS = 45000;
+const TARGET_PACKAGE_CONTAINER = '/data/local/tmp/espresso.apppackage';
+
+class EspressoProxy extends _appiumBaseDriver.JWProxy {
+  async proxyCommand(url, method, body = null) {
+    const {
+      crashed,
+      exited
+    } = this.instrumentationState;
+
+    if (exited) {
+      throw new _appiumBaseDriver.errors.InvalidContextError(`'${method} ${url}' cannot be proxied to Espresso server because ` + `the instrumentation process has ${crashed ? 'crashed' : 'been unexpectedly terminated'}. ` + `Check the Appium server log and the logcat output for more details`);
+    }
+
+    return await super.proxyCommand(url, method, body);
+  }
+
+}
+
+class EspressoRunner {
+  constructor(opts = {}) {
+    for (let req of REQUIRED_PARAMS) {
+      if (!opts || !_appiumSupport.util.hasValue(opts[req])) {
+        throw new Error(`Option '${req}' is required!`);
+      }
+
+      this[req] = opts[req];
+    }
+
+    this.jwproxy = new EspressoProxy({
+      server: this.host,
+      port: this.systemPort,
+      base: '',
+      keepAlive: true
+    });
+    this.proxyReqRes = this.jwproxy.proxyReqRes.bind(this.jwproxy);
+    this.jwproxy.instrumentationState = {
+      exited: false,
+      crashed: false
+    };
+
+    const modServerName = _appiumSupport.fs.sanitizeName(`${TEST_APK_PKG}_${_package.version}_${this.appPackage}_${this.adb.curDeviceId}.apk`, {
+      replacement: '-'
+    });
+
+    this.modServerPath = _path.default.resolve(this.tmpDir, modServerName);
+    this.showGradleLog = opts.showGradleLog;
+    this.espressoBuildConfig = opts.espressoBuildConfig;
+    this.serverLaunchTimeout = opts.serverLaunchTimeout || ESPRESSO_SERVER_LAUNCH_TIMEOUT_MS;
+    this.androidInstallTimeout = opts.androidInstallTimeout;
+    this.disableSuppressAccessibilityService = opts.disableSuppressAccessibilityService;
+
+    if (opts.useKeystore && opts.keystorePath && opts.keystorePassword && opts.keyAlias && opts.keyPassword) {
+      this.signingConfig = (0, _serverBuilder.buildServerSigningConfig)({
+        keystoreFile: opts.keystorePath,
+        keystorePassword: opts.keystorePassword,
+        keyAlias: opts.keyAlias,
+        keyPassword: opts.keyPassword
+      });
+    } else {
+      this.signingConfig = null;
+    }
+  }
+
+  async isAppPackageChanged() {
+    if (!(await this.adb.fileExists(TARGET_PACKAGE_CONTAINER))) {
+      _logger.default.debug('The previous target application package is unknown');
+
+      return true;
+    }
+
+    const previousAppPackage = (await this.adb.shell(['cat', TARGET_PACKAGE_CONTAINER])).trim();
+
+    _logger.default.debug(`The previous target application package was '${previousAppPackage}'. ` + `The current package is '${this.appPackage}'`);
+
+    return previousAppPackage !== this.appPackage;
+  }
+
+  async installServer() {
+    const appState = await this.adb.getApplicationInstallState(this.modServerPath, TEST_APK_PKG);
+    const shouldUninstallApp = [this.adb.APP_INSTALL_STATE.OLDER_VERSION_INSTALLED, this.adb.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED].includes(appState);
+    const shouldInstallApp = shouldUninstallApp || [this.adb.APP_INSTALL_STATE.NOT_INSTALLED].includes(appState);
+
+    if (shouldUninstallApp) {
+      _logger.default.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.default.warn(`Error uninstalling '${TEST_APK_PKG}': ${err.message}`);
+      }
+    }
+
+    if (shouldInstallApp) {
+      _logger.default.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.default.info(`Installed Espresso Test Server apk '${this.modServerPath}' (pkg: '${TEST_APK_PKG}')`);
+      } catch (err) {
+        _logger.default.errorAndThrow(`Cannot install '${this.modServerPath}' because of '${err.message}'`);
+      }
+    }
+  }
+
+  async installTestApk() {
+    let rebuild = this.forceEspressoRebuild;
+
+    if (rebuild) {
+      _logger.default.debug(`'forceEspressoRebuild' capability is enabled`);
+    } else if (await this.isAppPackageChanged()) {
+      _logger.default.info(`Forcing Espresso server rebuild because of changed application package`);
+
+      rebuild = true;
+    }
+
+    if (rebuild && (await _appiumSupport.fs.exists(this.modServerPath))) {
+      _logger.default.debug(`Deleting the obsolete Espresso server package '${this.modServerPath}'`);
+
+      await _appiumSupport.fs.unlink(this.modServerPath);
+    }
+
+    if (!(await _appiumSupport.fs.exists(this.modServerPath))) {
+      await this.buildNewModServer();
+    }
+
+    const isSigned = await this.adb.checkApkCert(this.modServerPath, TEST_APK_PKG);
+
+    if (!isSigned) {
+      await this.adb.sign(this.modServerPath);
+    }
+
+    if ((rebuild || !isSigned) && (await this.adb.uninstallApk(TEST_APK_PKG))) {
+      _logger.default.info('Uninstalled the obsolete Espresso server package from the device under test');
+    }
+
+    await this.installServer();
+  }
+
+  async buildNewModServer() {
+    let buildConfiguration = {};
+
+    if (this.espressoBuildConfig) {
+      let buildConfigurationStr;
+
+      if (await _appiumSupport.fs.exists(this.espressoBuildConfig)) {
+        _logger.default.info(`Loading the build configuration from '${this.espressoBuildConfig}'`);
+
+        buildConfigurationStr = await _appiumSupport.fs.readFile(this.espressoBuildConfig, 'utf8');
+      } else {
+        _logger.default.info(`Loading the build configuration from 'espressoBuildConfig' capability`);
+
+        buildConfigurationStr = this.espressoBuildConfig;
+      }
+
+      try {
+        buildConfiguration = JSON.parse(buildConfigurationStr);
+      } catch (e) {
+        _logger.default.error('Cannot parse the build configuration JSON', e);
+
+        throw e;
+      }
+    }
+
+    const dirName = _appiumSupport.fs.sanitizeName(`espresso-server-${this.adb.curDeviceId}`, {
+      replacement: '-'
+    });
+
+    const serverPath = _path.default.resolve(this.tmpDir, dirName);
+
+    _logger.default.info(`Building espresso server in '${serverPath}'`);
+
+    _logger.default.debug(`The build folder root could be customized by changing the 'tmpDir' capability`);
+
+    await _appiumSupport.fs.rimraf(serverPath);
+    await (0, _appiumSupport.mkdirp)(serverPath);
+
+    _logger.default.debug(`Copying espresso server template from ('${TEST_SERVER_ROOT}' to '${serverPath}')`);
+
+    await (0, _utils.copyGradleProjectRecursively)(TEST_SERVER_ROOT, serverPath);
+
+    _logger.default.debug('Bulding espresso server');
+
+    await new _serverBuilder.ServerBuilder({
+      serverPath,
+      buildConfiguration,
+      showGradleLog: this.showGradleLog,
+      testAppPackage: this.appPackage,
+      signingConfig: this.signingConfig
+    }).build();
+
+    const apkPath = _path.default.resolve(serverPath, 'app', 'build', 'outputs', 'apk', 'androidTest', 'debug', 'app-debug-androidTest.apk');
+
+    _logger.default.debug(`Copying built apk from '${apkPath}' to '${this.modServerPath}'`);
+
+    await _appiumSupport.fs.copyFile(apkPath, this.modServerPath);
+  }
+
+  async cleanupSessionLeftovers() {
+    _logger.default.debug('Performing cleanup of automation leftovers');
+
+    try {
+      const {
+        value
+      } = (await (0, _axios.default)({
+        url: `http://${this.host}:${this.systemPort}/sessions`,
+        timeout: 500
+      })).data;
+      const activeSessionIds = value.map(sess => sess.id);
+
+      if (activeSessionIds.length) {
+        _logger.default.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);
+
+        _logger.default.debug('Cleaning up the obsolete sessions');
+
+        await _bluebird.default.all(activeSessionIds.map(id => (0, _axios.default)({
+          url: `http://${this.host}:${this.systemPort}/session/${id}`,
+          method: 'DELETE'
+        })));
+        await _bluebird.default.delay(1000);
+      } else {
+        _logger.default.debug('No obsolete sessions have been detected');
+      }
+    } catch (e) {
+      _logger.default.debug(`No obsolete sessions have been detected (${e.message})`);
+    }
+  }
+
+  async startSession(caps) {
+    await this.cleanupSessionLeftovers();
+    const cmd = ['shell', 'am', 'instrument', '-w', '-e', 'debug', process.env.ESPRESSO_JAVA_DEBUG === 'true', '-e', 'disableAnalytics', true];
+
+    if (_lodash.default.isBoolean(this.disableSuppressAccessibilityService)) {
+      cmd.push('-e', 'DISABLE_SUPPRESS_ACCESSIBILITY_SERVICES', this.disableSuppressAccessibilityService);
+    }
+
+    cmd.push(`${TEST_APK_PKG}/androidx.test.runner.AndroidJUnitRunner`);
+
+    _logger.default.info(`Starting Espresso Server v${_package.version} with cmd: adb ${cmd.join(' ')}`);
+
+    let hasSocketError = false;
+    this.jwproxy.instrumentationState = {
+      exited: false,
+      crashed: false
+    };
+    this.instProcess = this.adb.createSubProcess(cmd);
+    this.instProcess.on('exit', (code, signal) => {
+      _logger.default.info(`Instrumentation process exited with code ${code} from signal ${signal}`);
+
+      this.jwproxy.instrumentationState.exited = true;
+    });
+    this.instProcess.on('output', (stdout, stderr) => {
+      const line = stdout || stderr;
+
+      if (_lodash.default.isEmpty(line.trim())) {
+        return;
+      }
+
+      _logger.default.debug(`[Instrumentation] ${line.trim()}`);
+
+      if (line.toLowerCase().includes('java.net.socketexception')) {
+        hasSocketError = true;
+      } else if (line.includes('Process crashed')) {
+        this.jwproxy.instrumentationState.crashed = true;
+      }
+    });
+    const timer = new _appiumSupport.timing.Timer().start();
+    await this.instProcess.start(0);
+
+    _logger.default.info(`Waiting up to ${this.serverLaunchTimeout}ms for Espresso server to be online`);
+
+    try {
+      await (0, _asyncbox.waitForCondition)(async () => {
+        if (hasSocketError) {
+          _logger.default.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.default.errorAndThrow(`Espresso server process has been unexpectedly terminated. ` + `Check the Appium server log and the logcat output for more details`);
+        }
+
+        try {
+          await this.jwproxy.command('/status', 'GET');
+          return true;
+        } catch (e) {
+          return false;
+        }
+      }, {
+        waitMs: this.serverLaunchTimeout,
+        intervalMs: 500
+      });
+    } catch (e) {
+      if (/Condition unmet/.test(e.message)) {
+        _logger.default.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.default.info(`Espresso server is online. ` + `The initialization process took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+
+    _logger.default.info('Starting the session');
+
+    await this.jwproxy.command('/session', 'POST', {
+      capabilities: {
+        firstMatch: [caps],
+        alwaysMatch: {}
+      }
+    });
+    await this.recordTargetAppPackage();
+  }
+
+  async recordTargetAppPackage() {
+    await this.adb.shell([`echo "${this.appPackage}" > "${TARGET_PACKAGE_CONTAINER}"`]);
+
+    _logger.default.info(`Recorded the target application package '${this.appPackage}' to ${TARGET_PACKAGE_CONTAINER}`);
+  }
+
+  async deleteSession() {
+    _logger.default.debug('Deleting Espresso server session');
+
+    try {
+      await this.jwproxy.command('/', 'DELETE');
+    } catch (err) {
+      _logger.default.warn(`Did not get confirmation Espresso deleteSession worked; ` + `Error was: ${err}`);
+    }
+
+    if (this.instProcess && this.instProcess.isRunning) {
+      await this.instProcess.stop();
+    }
+  }
+
+}
+
+exports.EspressoRunner = EspressoRunner;
+var _default = EspressoRunner;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/espresso-runner.js"],"names":["TEST_SERVER_ROOT","path","resolve","__dirname","TEST_APK_PKG","REQUIRED_PARAMS","ESPRESSO_SERVER_LAUNCH_TIMEOUT_MS","TARGET_PACKAGE_CONTAINER","EspressoProxy","JWProxy","proxyCommand","url","method","body","crashed","exited","instrumentationState","errors","InvalidContextError","EspressoRunner","constructor","opts","req","util","hasValue","Error","jwproxy","server","host","port","systemPort","base","keepAlive","proxyReqRes","bind","modServerName","fs","sanitizeName","version","appPackage","adb","curDeviceId","replacement","modServerPath","tmpDir","showGradleLog","espressoBuildConfig","serverLaunchTimeout","androidInstallTimeout","disableSuppressAccessibilityService","useKeystore","keystorePath","keystorePassword","keyAlias","keyPassword","signingConfig","keystoreFile","isAppPackageChanged","fileExists","logger","debug","previousAppPackage","shell","trim","installServer","appState","getApplicationInstallState","shouldUninstallApp","APP_INSTALL_STATE","OLDER_VERSION_INSTALLED","NEWER_VERSION_INSTALLED","includes","shouldInstallApp","NOT_INSTALLED","info","uninstallApk","err","warn","message","install","replace","timeout","errorAndThrow","installTestApk","rebuild","forceEspressoRebuild","exists","unlink","buildNewModServer","isSigned","checkApkCert","sign","buildConfiguration","buildConfigurationStr","readFile","JSON","parse","e","error","dirName","serverPath","rimraf","ServerBuilder","testAppPackage","build","apkPath","copyFile","cleanupSessionLeftovers","value","data","activeSessionIds","map","sess","id","length","stringify","B","all","delay","startSession","caps","cmd","process","env","ESPRESSO_JAVA_DEBUG","_","isBoolean","push","join","hasSocketError","instProcess","createSubProcess","on","code","signal","stdout","stderr","line","isEmpty","toLowerCase","timer","timing","Timer","start","command","waitMs","intervalMs","test","getDuration","asMilliSeconds","toFixed","capabilities","firstMatch","alwaysMatch","recordTargetAppPackage","deleteSession","isRunning","stop"],"mappings":"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","sourcesContent":["import { JWProxy, errors } from 'appium-base-driver';\nimport { waitForCondition } from 'asyncbox';\nimport logger from './logger';\nimport { ServerBuilder, buildServerSigningConfig } from './server-builder';\nimport path from 'path';\nimport { fs, util, mkdirp, timing } from 'appium-support';\nimport { version } from '../../package.json'; // eslint-disable-line import/no-unresolved\nimport B from 'bluebird';\nimport _ from 'lodash';\nimport { copyGradleProjectRecursively } from './utils';\nimport axios from 'axios';\n\n\nconst TEST_SERVER_ROOT = path.resolve(__dirname, '..', '..', 'espresso-server');\nconst TEST_APK_PKG = 'io.appium.espressoserver.test';\nconst REQUIRED_PARAMS = [\n  'adb',\n  'tmpDir',\n  'host',\n  'systemPort',\n  'devicePort',\n  'appPackage',\n  'forceEspressoRebuild',\n];\nconst ESPRESSO_SERVER_LAUNCH_TIMEOUT_MS = 45000;\nconst TARGET_PACKAGE_CONTAINER = '/data/local/tmp/espresso.apppackage';\n\nclass EspressoProxy extends JWProxy {\n  async proxyCommand (url, method, body = null) {\n    const {crashed, exited} = this.instrumentationState;\n    if (exited) {\n      throw new errors.InvalidContextError(`'${method} ${url}' cannot be proxied to Espresso server because ` +\n        `the instrumentation process has ${crashed ? 'crashed' : 'been unexpectedly terminated'}. ` +\n        `Check the Appium server log and the logcat output for more details`);\n    }\n    return await super.proxyCommand(url, method, body);\n  }\n}\n\nclass EspressoRunner {\n  constructor (opts = {}) {\n    for (let req of REQUIRED_PARAMS) {\n      if (!opts || !util.hasValue(opts[req])) {\n        throw new Error(`Option '${req}' is required!`);\n      }\n      this[req] = opts[req];\n    }\n    this.jwproxy = new EspressoProxy({\n      server: this.host,\n      port: this.systemPort,\n      base: '',\n      keepAlive: true,\n    });\n    this.proxyReqRes = this.jwproxy.proxyReqRes.bind(this.jwproxy);\n    this.jwproxy.instrumentationState = {\n      exited: false,\n      crashed: false,\n    };\n\n    const modServerName = fs.sanitizeName(`${TEST_APK_PKG}_${version}_${this.appPackage}_${this.adb.curDeviceId}.apk`, {\n      replacement: '-',\n    });\n    this.modServerPath = path.resolve(this.tmpDir, modServerName);\n    this.showGradleLog = opts.showGradleLog;\n    this.espressoBuildConfig = opts.espressoBuildConfig;\n\n    this.serverLaunchTimeout = opts.serverLaunchTimeout || ESPRESSO_SERVER_LAUNCH_TIMEOUT_MS;\n    this.androidInstallTimeout = opts.androidInstallTimeout;\n\n    this.disableSuppressAccessibilityService = opts.disableSuppressAccessibilityService;\n\n    // Espresso Server app needs to be signed with same keyStore as appPackage\n    if (opts.useKeystore && opts.keystorePath && opts.keystorePassword && opts.keyAlias && opts.keyPassword) {\n      this.signingConfig = buildServerSigningConfig({\n        keystoreFile: opts.keystorePath,\n        keystorePassword: opts.keystorePassword,\n        keyAlias: opts.keyAlias,\n        keyPassword: opts.keyPassword\n      });\n    } else {\n      this.signingConfig = null;\n    }\n  }\n\n  async isAppPackageChanged () {\n    if (!await this.adb.fileExists(TARGET_PACKAGE_CONTAINER)) {\n      logger.debug('The previous target application package is unknown');\n      return true;\n    }\n    const previousAppPackage = (await this.adb.shell(['cat', TARGET_PACKAGE_CONTAINER])).trim();\n    logger.debug(`The previous target application package was '${previousAppPackage}'. ` +\n      `The current package is '${this.appPackage}'`);\n    return previousAppPackage !== this.appPackage;\n  }\n\n  /**\n   * Installs Espresso server apk on to the device or emulator.\n   * Each adb command uses default timeout by them.\n   */\n  async installServer () {\n    const appState = await this.adb.getApplicationInstallState(this.modServerPath, TEST_APK_PKG);\n\n    const shouldUninstallApp = [\n      this.adb.APP_INSTALL_STATE.OLDER_VERSION_INSTALLED,\n      this.adb.APP_INSTALL_STATE.NEWER_VERSION_INSTALLED\n    ].includes(appState);\n    const shouldInstallApp = shouldUninstallApp || [\n      this.adb.APP_INSTALL_STATE.NOT_INSTALLED\n    ].includes(appState);\n\n    if (shouldUninstallApp) {\n      logger.info(`Uninstalling Espresso Test Server apk from the target device (pkg: '${TEST_APK_PKG}')`);\n      try {\n        await this.adb.uninstallApk(TEST_APK_PKG);\n      } catch (err) {\n        logger.warn(`Error uninstalling '${TEST_APK_PKG}': ${err.message}`);\n      }\n    }\n\n    if (shouldInstallApp) {\n      logger.info(`Installing Espresso Test Server apk from the target device (path: '${this.modServerPath}')`);\n      try {\n        await this.adb.install(this.modServerPath, { replace: false, timeout: this.androidInstallTimeout });\n        logger.info(`Installed Espresso Test Server apk '${this.modServerPath}' (pkg: '${TEST_APK_PKG}')`);\n      } catch (err) {\n        logger.errorAndThrow(`Cannot install '${this.modServerPath}' because of '${err.message}'`);\n      }\n    }\n  }\n\n  async installTestApk () {\n    let rebuild = this.forceEspressoRebuild;\n    if (rebuild) {\n      logger.debug(`'forceEspressoRebuild' capability is enabled`);\n    } else if (await this.isAppPackageChanged()) {\n      logger.info(`Forcing Espresso server rebuild because of changed application package`);\n      rebuild = true;\n    }\n\n    if (rebuild && await fs.exists(this.modServerPath)) {\n      logger.debug(`Deleting the obsolete Espresso server package '${this.modServerPath}'`);\n      await fs.unlink(this.modServerPath);\n    }\n    if (!(await fs.exists(this.modServerPath))) {\n      await this.buildNewModServer();\n    }\n    const isSigned = await this.adb.checkApkCert(this.modServerPath, TEST_APK_PKG);\n    if (!isSigned) {\n      await this.adb.sign(this.modServerPath);\n    }\n    if ((rebuild || !isSigned) && await this.adb.uninstallApk(TEST_APK_PKG)) {\n      logger.info('Uninstalled the obsolete Espresso server package from the device under test');\n    }\n\n    await this.installServer();\n  }\n\n  async buildNewModServer () {\n    let buildConfiguration = {};\n    if (this.espressoBuildConfig) {\n      let buildConfigurationStr;\n      if (await fs.exists(this.espressoBuildConfig)) {\n        logger.info(`Loading the build configuration from '${this.espressoBuildConfig}'`);\n        buildConfigurationStr = await fs.readFile(this.espressoBuildConfig, 'utf8');\n      } else {\n        logger.info(`Loading the build configuration from 'espressoBuildConfig' capability`);\n        buildConfigurationStr = this.espressoBuildConfig;\n      }\n      try {\n        buildConfiguration = JSON.parse(buildConfigurationStr);\n      } catch (e) {\n        logger.error('Cannot parse the build configuration JSON', e);\n        throw e;\n      }\n    }\n    const dirName = fs.sanitizeName(`espresso-server-${this.adb.curDeviceId}`, {\n      replacement: '-',\n    });\n    const serverPath = path.resolve(this.tmpDir, dirName);\n    logger.info(`Building espresso server in '${serverPath}'`);\n    logger.debug(`The build folder root could be customized by changing the 'tmpDir' capability`);\n    await fs.rimraf(serverPath);\n    await mkdirp(serverPath);\n    logger.debug(`Copying espresso server template from ('${TEST_SERVER_ROOT}' to '${serverPath}')`);\n    await copyGradleProjectRecursively(TEST_SERVER_ROOT, serverPath);\n    logger.debug('Bulding espresso server');\n    await new ServerBuilder({\n      serverPath, buildConfiguration,\n      showGradleLog: this.showGradleLog,\n      testAppPackage: this.appPackage,\n      signingConfig: this.signingConfig\n    }).build();\n    const apkPath = path.resolve(serverPath, 'app', 'build', 'outputs', 'apk', 'androidTest', 'debug', 'app-debug-androidTest.apk');\n    logger.debug(`Copying built apk from '${apkPath}' to '${this.modServerPath}'`);\n    await fs.copyFile(apkPath, this.modServerPath);\n  }\n\n  async cleanupSessionLeftovers () {\n    logger.debug('Performing cleanup of automation leftovers');\n\n    try {\n      const {value} = (await axios({\n        url: `http://${this.host}:${this.systemPort}/sessions`,\n        timeout: 500,\n      })).data;\n      const activeSessionIds = value.map((sess) => sess.id);\n      if (activeSessionIds.length) {\n        logger.debug(`The following obsolete sessions are still running: ${JSON.stringify(activeSessionIds)}`);\n        logger.debug('Cleaning up the obsolete sessions');\n        await B.all(activeSessionIds.map((id) =>\n          axios({\n            url: `http://${this.host}:${this.systemPort}/session/${id}`,\n            method: 'DELETE',\n          })\n        ));\n        // Let all sessions to be properly terminated before continuing\n        await B.delay(1000);\n      } else {\n        logger.debug('No obsolete sessions have been detected');\n      }\n    } catch (e) {\n      logger.debug(`No obsolete sessions have been detected (${e.message})`);\n    }\n  }\n\n  async startSession (caps) {\n    await this.cleanupSessionLeftovers();\n\n    const cmd = [\n      'shell',\n      'am', 'instrument',\n      '-w',\n      '-e', 'debug', process.env.ESPRESSO_JAVA_DEBUG === 'true',\n      '-e', 'disableAnalytics', true, // To avoid unexpected error by google analytics\n    ];\n\n    if (_.isBoolean(this.disableSuppressAccessibilityService)) {\n      cmd.push('-e', 'DISABLE_SUPPRESS_ACCESSIBILITY_SERVICES', this.disableSuppressAccessibilityService);\n    }\n\n    cmd.push(`${TEST_APK_PKG}/androidx.test.runner.AndroidJUnitRunner`);\n\n    logger.info(`Starting Espresso Server v${version} with cmd: adb ${cmd.join(' ')}`);\n\n    let hasSocketError = false;\n    // start the instrumentation process\n    this.jwproxy.instrumentationState = {\n      exited: false,\n      crashed: false,\n    };\n    this.instProcess = this.adb.createSubProcess(cmd);\n    this.instProcess.on('exit', (code, signal) => {\n      logger.info(`Instrumentation process exited with code ${code} from signal ${signal}`);\n      this.jwproxy.instrumentationState.exited = true;\n    });\n    this.instProcess.on('output', (stdout, stderr) => {\n      const line = stdout || stderr;\n      if (_.isEmpty(line.trim())) {\n        // Do not print empty lines into the system log\n        return;\n      }\n\n      logger.debug(`[Instrumentation] ${line.trim()}`);\n      // A 'SocketException' indicates that we couldn't connect to the Espresso server,\n      // because the INTERNET permission is not set\n      if (line.toLowerCase().includes('java.net.socketexception')) {\n        hasSocketError = true;\n      } else if (line.includes('Process crashed')) {\n        this.jwproxy.instrumentationState.crashed = true;\n      }\n    });\n\n    const timer = new timing.Timer().start();\n    await this.instProcess.start(0);\n    logger.info(`Waiting up to ${this.serverLaunchTimeout}ms for Espresso server to be online`);\n    try {\n      await waitForCondition(async () => {\n        if (hasSocketError) {\n          logger.errorAndThrow(`Espresso server has failed to start due to an unexpected exception. ` +\n            `Make sure the 'INTERNET' permission is requested in the Android manifest of your ` +\n            `application under test (<uses-permission android:name=\"android.permission.INTERNET\" />)`);\n        } else if (this.jwproxy.instrumentationState.exited) {\n          logger.errorAndThrow(`Espresso server process has been unexpectedly terminated. ` +\n            `Check the Appium server log and the logcat output for more details`);\n        }\n        try {\n          await this.jwproxy.command('/status', 'GET');\n          return true;\n        } catch (e) {\n          return false;\n        }\n      }, {\n        waitMs: this.serverLaunchTimeout,\n        intervalMs: 500,\n      });\n    } catch (e) {\n      if (/Condition unmet/.test(e.message)) {\n        logger.errorAndThrow(`Timed out waiting for Espresso server to be ` +\n          `online within ${this.serverLaunchTimeout}ms. The timeout value could be ` +\n          `customized using 'espressoServerLaunchTimeout' capability`);\n      }\n      throw e;\n    }\n    logger.info(`Espresso server is online. ` +\n      `The initialization process took ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);\n    logger.info('Starting the session');\n\n    await this.jwproxy.command('/session', 'POST', {\n      capabilities: {\n        firstMatch: [caps],\n        alwaysMatch: {}\n      }\n    });\n    await this.recordTargetAppPackage();\n  }\n\n  async recordTargetAppPackage () {\n    await this.adb.shell([`echo \"${this.appPackage}\" > \"${TARGET_PACKAGE_CONTAINER}\"`]);\n    logger.info(`Recorded the target application package '${this.appPackage}' to ${TARGET_PACKAGE_CONTAINER}`);\n  }\n\n  async deleteSession () {\n    logger.debug('Deleting Espresso server session');\n    // rely on jwproxy's intelligence to know what we're talking about and\n    // delete the current session\n    try {\n      await this.jwproxy.command('/', 'DELETE');\n    } catch (err) {\n      logger.warn(`Did not get confirmation Espresso deleteSession worked; ` +\n          `Error was: ${err}`);\n    }\n\n    if (this.instProcess && this.instProcess.isRunning) {\n      await this.instProcess.stop();\n    }\n  }\n}\n\nexport { EspressoRunner, REQUIRED_PARAMS, TEST_APK_PKG };\nexport default EspressoRunner;\n"],"file":"lib/espresso-runner.js","sourceRoot":"../.."}

package/build/lib/logger.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+require("source-map-support/register");
+
+var _appiumSupport = require("appium-support");
+
+const log = _appiumSupport.logger.getLogger('Espresso');
+
+var _default = log;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImxpYi9sb2dnZXIuanMiXSwibmFtZXMiOlsibG9nIiwibG9nZ2VyIiwiZ2V0TG9nZ2VyIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTs7QUFHQSxNQUFNQSxHQUFHLEdBQUdDLHNCQUFPQyxTQUFQLENBQWlCLFVBQWpCLENBQVo7O2VBRWVGLEciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBsb2dnZXIgfSBmcm9tICdhcHBpdW0tc3VwcG9ydCc7XG5cblxuY29uc3QgbG9nID0gbG9nZ2VyLmdldExvZ2dlcignRXNwcmVzc28nKTtcblxuZXhwb3J0IGRlZmF1bHQgbG9nO1xuIl0sImZpbGUiOiJsaWIvbG9nZ2VyLmpzIiwic291cmNlUm9vdCI6Ii4uLy4uIn0=