detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/devices/common/drivers/ios/tools/AppleSimUtils.js

@@ -7,7 +7,7 @@ const DetoxRuntimeError = require('../../../../../errors/DetoxRuntimeError');
 const { joinArgs } = require('../../../../../utils/argparse');
 const childProcess = require('../../../../../utils/childProcess');
 const environment = require('../../../../../utils/environment');
-const log = require('../../../../../utils/logger').child({ __filename });
+const log = require('../../../../../utils/logger').child({ cat: 'device' });
 const { quote } = require('../../../../../utils/shellQuote');
 
 class AppleSimUtils {
@@ -93,7 +93,7 @@ class AppleSimUtils {
       `(https://developer.apple.com/xcode/). In case you already have the latest Xcode version installed, ` +
       `try run the command: \`sudo xcode-select -s /Applications/Xcode.app\`. If you are running tests from CI, ` +
       `we recommend running them with "--headless" device configuration (see: ` +
-      `https://wix.github.io/Detox/docs/next/api/configuration/#device-configurations).`
+      `https://wix.github.io/Detox/docs/cli/test/#options).`
     );
   }
 
@@ -140,6 +140,9 @@ class AppleSimUtils {
 
   async launch(udid, bundleId, launchArgs, languageAndLocale) {
     const frameworkPath = await environment.getFrameworkPath();
+
+    delete launchArgs.detoxServer;
+
     const result = await this._launchMagically(frameworkPath, udid, bundleId, launchArgs, languageAndLocale);
     await this._printLoggingHint(udid, bundleId);
 
@@ -156,7 +159,19 @@ class AppleSimUtils {
     );
   }
 
-  async sendToHome(udid) {
+  async _isSpringBoardInaccessible(udid) {
+    const device = await this._findDeviceByUDID(udid);
+    const majorIOSVersion = parseInt(device.os.version.split('.')[0]);
+    return majorIOSVersion >= 16;
+  }
+
+  async _launchAndTerminateSettings(udid) {
+    const bundleId = 'com.apple.Preferences';
+    await this._execSimctl({ cmd: `launch ${udid} ${bundleId}`, retries: 10 });
+    await this._execSimctl({ cmd: `terminate ${udid} ${bundleId}`, retries: 10 });
+  }
+
+  async _launchSpringBoard(udid) {
     await this._execSimctl({ cmd: `launch ${udid} com.apple.springboard`, retries: 10 });
   }
 
@@ -271,7 +286,9 @@ class AppleSimUtils {
       // ```
       // This workaround is done to ignore the error above, as we do not care if the app was running before, we just
       // want to make sure it isn't now.
-      if (err.code === 3 && err.stderr.includes(`the app is not currently running`)) {
+      if (err.code === 3 &&
+          (err.stderr.includes(`the app is not currently running`) ||
+           err.stderr.includes(`The operation couldn’t be completed. found nothing to terminate`))) {
         return;
       }
 

package/src/devices/lifecycle/GenyGlobalLifecycleHandler.js

@@ -1,6 +1,4 @@
-const onSignalExit = require('signal-exit');
-
-const logger = require('../../utils/logger').child({ __filename });
+const logger = require('../../utils/logger').child({ cat: 'device' });
 
 const cleanupLogData = {
   event: 'GENYCLOUD_TEARDOWN',
@@ -8,20 +6,20 @@ const cleanupLogData = {
 
 class GenyGlobalLifecycleHandler {
   constructor({ deviceCleanupRegistry, instanceLifecycleService }) {
+    /** @private */
     this._deviceCleanupRegistry = deviceCleanupRegistry;
+    /** @private */
     this._instanceLifecycleService = instanceLifecycleService;
   }
 
-  async globalInit() {
-    onSignalExit((code, signal) => {
-      if (signal) {
-        const { rawDevices } = this._deviceCleanupRegistry.readRegisteredDevicesUNSAFE();
-        const instanceHandles = rawDevicesToInstanceHandles(rawDevices);
-        if (instanceHandles.length) {
-          reportGlobalCleanupSummary(instanceHandles);
-        }
-      }
-    });
+  async globalInit() {}
+
+  emergencyCleanup() {
+    const { rawDevices } = this._deviceCleanupRegistry.readRegisteredDevicesUNSAFE();
+    const instanceHandles = rawDevicesToInstanceHandles(rawDevices);
+    if (instanceHandles.length) {
+      reportGlobalCleanupSummary(instanceHandles);
+    }
   }
 
   async globalCleanup() {
@@ -34,7 +32,7 @@ class GenyGlobalLifecycleHandler {
 }
 
 async function doSafeCleanup(instanceLifecycleService, instanceHandles) {
-  logger.info(cleanupLogData, 'Initiating Genymotion cloud instances teardown...');
+  logger.info(cleanupLogData, 'Initiating Genymotion SaaS instances teardown...');
 
   const deletionLeaks = [];
   const killPromises = instanceHandles.map((instanceHandle) =>
@@ -47,7 +45,7 @@ async function doSafeCleanup(instanceLifecycleService, instanceHandles) {
 
 function reportGlobalCleanupSummary(deletionLeaks) {
   if (deletionLeaks.length) {
-    logger.warn(cleanupLogData, 'WARNING! Detected a Genymotion cloud instance leakage, for the following instances:');
+    logger.warn(cleanupLogData, 'WARNING! Detected a Genymotion SaaS instance leakage, for the following instances:');
 
     deletionLeaks.forEach(({ uuid, name, error }) => {
       logger.warn(cleanupLogData, [

package/src/devices/runtime/RuntimeDevice.js

@@ -1,6 +1,7 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const debug = require('../../utils/debug'); // debug utils, leave here even if unused
-const { traceCall, traceMethods } = require('../../utils/trace');
+const log = require('../../utils/logger').child({ cat: 'device' });
+const traceMethods = require('../../utils/traceMethods');
 const wrapWithStackTraceCutter = require('../../utils/wrapWithStackTraceCutter');
 
 const LaunchArgsEditor = require('./utils/LaunchArgsEditor');
@@ -20,6 +21,7 @@ class RuntimeDevice {
       'disableSynchronization',
       'enableSynchronization',
       'installApp',
+      'installUtilBinaries',
       'launchApp',
       'matchFace',
       'matchFinger',
@@ -48,9 +50,10 @@ class RuntimeDevice {
       'unreverseTcpPort',
     ];
 
-    traceMethods(this, 'device', methodNames);
+    traceMethods(log, this, methodNames);
     wrapWithStackTraceCutter(this, methodNames);
 
+    this._isTestRunnerConnected = false;
     this._appsConfig = appsConfig;
     this._behaviorConfig = behaviorConfig;
     this._deviceConfig = deviceConfig;
@@ -155,8 +158,11 @@ class RuntimeDevice {
       this._processes[bundleId] = await this.deviceDriver.waitForAppLaunch(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
     } else {
       this._processes[bundleId] = await this.deviceDriver.launchApp(bundleId, this._prepareLaunchArgs(baseLaunchArgs), params.languageAndLocale);
+      console.log('Launched app process:', this._processes[bundleId]);
       await this.deviceDriver.waitUntilReady();
+      console.log('wait for active');
       await this.deviceDriver.waitForActive();
+      console.log('App launched. Running test...');
     }
 
     await this._emitter.emit('appReady', {
@@ -234,29 +240,34 @@ class RuntimeDevice {
   }
 
   async installApp(binaryPath, testBinaryPath) {
-    await traceCall('appInstall', () => {
-      const currentApp = binaryPath ? { binaryPath, testBinaryPath } : this._getCurrentApp();
-      return this.deviceDriver.installApp(currentApp.binaryPath, currentApp.testBinaryPath);
-    });
+    const currentApp = binaryPath ? { binaryPath, testBinaryPath } : this._getCurrentApp();
+    await this.deviceDriver.installApp(currentApp.binaryPath, currentApp.testBinaryPath);
+
+    // This abstraction leaks because our drivers themselves leak,
+    // so don't blame me - DeviceBaseDriver itself has `reverseTcpPort`,
+    // setting a vicious downward spiral. I can't refactor everything
+    // in a single pull request, so let's bear with it for now.
+    if (Array.isArray(currentApp.reversePorts)) {
+      for (const port of currentApp.reversePorts) {
+        await this.reverseTcpPort(port);
+      }
+    }
   }
 
   async uninstallApp(bundleId) {
     const _bundleId = bundleId || this._bundleId;
-    await traceCall('appUninstall', () =>
-      this.deviceDriver.uninstallApp(_bundleId));
+    await this.deviceDriver.uninstallApp(_bundleId);
   }
 
   async installUtilBinaries() {
     const paths = this._deviceConfig.utilBinaryPaths;
     if (paths) {
-      await traceCall('installUtilBinaries', () =>
-        this.deviceDriver.installUtilBinaries(paths));
+      await this.deviceDriver.installUtilBinaries(paths);
     }
   }
 
   async reloadReactNative() {
-    await traceCall('reloadRN', () =>
-      this.deviceDriver.reloadReactNative());
+    await this.deviceDriver.reloadReactNative();
   }
 
   async openURL(params) {
@@ -355,6 +366,7 @@ class RuntimeDevice {
     }
     return this._currentApp;
   }
+
   async _sendPayload(key, params) {
     const payloadFilePath = this.deviceDriver.createPayloadFile(params);
     const payload = {

package/src/devices/runtime/drivers/DeviceDriverBase.js

@@ -4,7 +4,7 @@ const path = require('path');
 
 const fs = require('fs-extra');
 
-const log = require('../../../utils/logger').child({ __filename });
+const log = require('../../../utils/logger').child({ cat: 'device' });
 
 /**
  * @typedef DeviceDriverDeps
@@ -112,6 +112,7 @@ class DeviceDriverBase {
   }
 
   async waitUntilReady() {
+    console.warn('DeviceDriverBase.waitUntilReady()');
     return await this.client.waitUntilReady();
   }
 

package/src/devices/runtime/drivers/android/AndroidDriver.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none" }] */
 // @ts-nocheck
 const path = require('path');
 const URL = require('url').URL;
@@ -18,7 +19,7 @@ const sleep = require('../../../../utils/sleep');
 const apkUtils = require('../../../common/drivers/android/tools/apk');
 const DeviceDriverBase = require('../DeviceDriverBase');
 
-const log = logger.child({ __filename });
+const log = logger.child({ cat: 'device' });
 
 /**
  * @typedef AndroidDriverProps
@@ -31,7 +32,7 @@ const log = logger.child({ __filename });
  * @property adb { ADB }
  * @property aapt { AAPT }
  * @property apkValidator { ApkValidator }
- * @property fileXfer { FileXfer }
+ * @property fileTransfer { FileTransfer }
  * @property appInstallHelper { AppInstallHelper }
  * @property appUninstallHelper { AppUninstallHelper }
  * @property devicePathBuilder { AndroidDevicePathBuilder }
@@ -51,7 +52,7 @@ class AndroidDriver extends DeviceDriverBase {
     this.aapt = deps.aapt;
     this.apkValidator = deps.apkValidator;
     this.invocationManager = deps.invocationManager;
-    this.fileXfer = deps.fileXfer;
+    this.fileTransfer = deps.fileTransfer;
     this.appInstallHelper = deps.appInstallHelper;
     this.appUninstallHelper = deps.appUninstallHelper;
     this.devicePathBuilder = deps.devicePathBuilder;
@@ -148,17 +149,25 @@ class AndroidDriver extends DeviceDriverBase {
 
   async waitUntilReady() {
       try {
-        await Promise.race([super.waitUntilReady(), this.instrumentation.waitForCrash()]);
+        await Promise.race([
+          super.waitUntilReady(),
+          this.instrumentation.waitForCrash()
+        ]);
+      } catch (e) {
+        log.warn({ error: e }, 'An error occurred while waiting for the app to become ready. Waiting for disconnection...');
+        await this.client.waitUntilDisconnected();
+        log.warn('The app disconnected.');
+        throw e;
       } finally {
         this.instrumentation.abortWaitForCrash();
       }
   }
 
-  async pressBack() { // eslint-disable-line no-unused-vars
+  async pressBack() {
     await this.uiDevice.pressBack();
   }
 
-  async sendToHome(params) { // eslint-disable-line no-unused-vars
+  async sendToHome(params) {
     await this.uiDevice.pressHome();
   }
 
@@ -323,8 +332,8 @@ class AndroidDriver extends DeviceDriverBase {
   }
 
   async _sendNotificationDataToDevice(dataFileLocalPath, adbName) {
-    await this.fileXfer.prepareDestinationDir(adbName);
-    return await this.fileXfer.send(adbName, dataFileLocalPath, 'notification.json');
+    await this.fileTransfer.prepareDestinationDir(adbName);
+    return await this.fileTransfer.send(adbName, dataFileLocalPath, 'notification.json');
   }
 
   _startActivityWithUrl(url) {

package/src/devices/runtime/drivers/ios/SimulatorDriver.js

@@ -6,11 +6,14 @@ const _ = require('lodash');
 
 const temporaryPath = require('../../../../artifacts/utils/temporaryPath');
 const DetoxRuntimeError = require('../../../../errors/DetoxRuntimeError');
+const environment = require('../../../../utils/environment');
 const getAbsoluteBinaryPath = require('../../../../utils/getAbsoluteBinaryPath');
-const log = require('../../../../utils/logger').child({ __filename });
+const log = require('../../../../utils/logger').child({ cat: 'driver' });
 const pressAnyKey = require('../../../../utils/pressAnyKey');
 
 const IosDriver = require('./IosDriver');
+const { launchXCUITest } = require('./XCUITestUtils');
+
 
 /**
  * @typedef SimulatorDriverDeps { DeviceDriverDeps }
@@ -40,6 +43,8 @@ class SimulatorDriver extends IosDriver {
     this._deviceName = `${udid} (${this._type})`;
     this._simulatorLauncher = deps.simulatorLauncher;
     this._applesimutils = deps.applesimutils;
+    // TODO: allocate unique-per-worker available port.
+    this._testTargetServerPort = 8997 + _.random(0, 1000);
   }
 
   getExternalId() {
@@ -75,19 +80,48 @@ class SimulatorDriver extends IosDriver {
   }
 
   async launchApp(bundleId, launchArgs, languageAndLocale) {
+    const xcuitestRunnerPath = await environment.getXCUITestRunnerPath();
+
     const { udid } = this;
+    launchArgs = this.enrichArgs(launchArgs);
+
     await this.emitter.emit('beforeLaunchApp', { bundleId, deviceId: udid, launchArgs });
+
+    log.debug({ event: 'CLIENT_CONNECTED', params: { connected: this.client.isConnected } }, 'client connected: ' + this.client.isConnected);
+    if (!this.client.isConnected) {
+      await launchXCUITest(
+        xcuitestRunnerPath,
+        this.udid,
+        launchArgs.detoxServer,
+        launchArgs.detoxSessionId,
+        bundleId,
+        launchArgs.detoxDebugVisibility,
+        launchArgs.detoxDisableHierarchyDump,
+        this._testTargetServerPort
+      );
+    }
+
     const pid = await this._applesimutils.launch(udid, bundleId, launchArgs, languageAndLocale);
     await this.emitter.emit('launchApp', { bundleId, deviceId: udid, launchArgs, pid });
 
     return pid;
   }
 
+  enrichArgs(args) {
+    return {
+      ...args,
+      detoxTestTargetServer: 'ws://localhost:' + this._testTargetServerPort,
+    };
+  }
+
   async waitForAppLaunch(bundleId, launchArgs, languageAndLocale) {
     const { udid } = this;
 
+    launchArgs = this.enrichArgs(launchArgs);
+
     await this.emitter.emit('beforeLaunchApp', { bundleId, deviceId: udid, launchArgs });
 
+    // print xcuitest launch hint
     this._applesimutils.printLaunchHint(udid, bundleId, launchArgs, languageAndLocale);
     await pressAnyKey();
 
@@ -109,6 +143,12 @@ class SimulatorDriver extends IosDriver {
   async terminate(bundleId) {
     const { udid } = this;
     await this.emitter.emit('beforeTerminateApp', { deviceId: udid, bundleId });
+
+    await this.client.terminateIfNeeded();
+
+    // Sleep for 200 ms to allow the XCUITest to terminate gracefully.
+    await new Promise(resolve => setTimeout(resolve, 200));
+
     await this._applesimutils.terminate(udid, bundleId);
     await this.emitter.emit('terminateApp', { deviceId: udid, bundleId });
   }
@@ -134,7 +174,7 @@ class SimulatorDriver extends IosDriver {
   }
 
   async sendToHome() {
-    await this._applesimutils.sendToHome(this.udid);
+    return await this.client.sendToHome();
   }
 
   async setLocation(lat, lon) {

package/src/devices/runtime/drivers/ios/XCUITestUtils.js

@@ -0,0 +1,209 @@
+const { exec } = require('child-process-promise');
+const osascript = require('node-osascript');
+
+const { execWithRetriesAndLogs } = require('../../../../utils/childProcess');
+const log = require('../../../../utils/logger').child({ cat: 'device,xcuitest' });
+
+async function launchXCUITest(
+  xcuitestRunnerPath,
+  simulatorId,
+  detoxServer,
+  detoxSessionId,
+  bundleId,
+  debugVisibility,
+  disableDumpViewHierarchy,
+  testTargetServerPort
+) {
+  log.debug('[XCUITest] Launch was called');
+
+  await _runLaunchCommand(
+    xcuitestRunnerPath,
+    simulatorId,
+    detoxServer,
+    detoxSessionId,
+    bundleId,
+    debugVisibility,
+    disableDumpViewHierarchy,
+    testTargetServerPort
+  );
+
+  log.debug('[XCUITest] Launch succeeded');
+}
+
+async function _runLaunchCommand(
+  xcuitestRunnerPath,
+  simulatorId,
+  detoxServer,
+  detoxSessionId,
+  bundleId,
+  debugVisibility,
+  disableDumpViewHierarchy,
+  testTargetServerPort
+) {
+  log.info(`Launching XUICTest runner. See target logs using:\n` +
+    `\t/usr/bin/xcrun simctl spawn ${simulatorId} log stream --level debug --style compact ` +
+    `--predicate 'process == "DetoxTester-Runner" && subsystem == "com.wix.DetoxTester.xctrunner"'`);
+
+  const spawnedProcess = runXCUITest(
+    xcuitestRunnerPath,
+    simulatorId,
+    detoxServer,
+    detoxSessionId,
+    testTargetServerPort,
+    bundleId,
+    debugVisibility,
+    disableDumpViewHierarchy
+  ).then(r => {
+    log.info(`[XCUITest] XCUITest runner execution finished`);
+  }).catch(e => {
+    log.error(`[XCUITest] xcodebuild error has occurred during XCUITest execution:\n${e}`);
+  });
+
+  // Get firewall global state (Firewall socketfilterfw):
+  const state = await exec(`/usr/libexec/ApplicationFirewall/socketfilterfw --getglobalstate`);
+  const isFirewallDisabled = state.stdout.toString().includes('Firewall is disabled');
+  if (!isFirewallDisabled) {
+    _allowNetworkPermissionsXCUITest();
+  }
+
+  const isServerUp = await _waitForTestTargetServerToStart(testTargetServerPort, spawnedProcess);
+  log.debug(`[XCUITest] Finished waiting for test target server to start, server is up: ${isServerUp}`);
+}
+
+function runXCUITest(
+  xcuitestRunnerPath,
+  simulatorId,
+  detoxServer,
+  detoxSessionId,
+  testTargetServerPort,
+  bundleId,
+  debugVisibility,
+  disableDumpViewHierarchy,
+) {
+  log.debug(`[XCUITest] Running xcodebuild test with bundle id: ${bundleId}`);
+  let xcodebuildBinary = 'xcodebuild';
+  const flags = [
+    '-xctestrun', xcuitestRunnerPath,
+    '-sdk', 'iphonesimulator',
+    '-allowProvisioningUpdates',
+    '-destination', `platform=iOS Simulator,id=${simulatorId}`,
+    'test-without-building'
+  ];
+
+  const env = {
+    TEST_RUNNER_IS_DETOX_ACTIVE: '1',
+    TEST_RUNNER_DETOX_SERVER: detoxServer,
+    TEST_RUNNER_DETOX_SESSION_ID: detoxSessionId,
+    TEST_RUNNER_TEST_TARGET_SERVER_PORT: testTargetServerPort,
+    TEST_RUNNER_BUNDLE_ID: bundleId,
+    TEST_RUNNER_DETOX_DEBUG_VISIBILITY: debugVisibility,
+    TEST_RUNNER_DETOX_DISABLE_VIEW_HIERARCHY_DUMP: disableDumpViewHierarchy
+  };
+
+  const options = {
+    maxBuffer: 1024 * 1024 * 1024,
+    retries: 1,
+    verbosity: 'high',
+  };
+
+  const command = `${env.TEST_RUNNER_IS_DETOX_ACTIVE ? Object.keys(env).map(key => `${key}=${env[key]}`).join(' ') : ''} ${xcodebuildBinary} ${flags.map(flag => flag.includes(' ') ? `"${flag}"` : flag).join(' ')}`;
+  log.debug(`[XCUITest] Running command: ${command}`);
+
+  // TODO: consider using this instead of the Terminal approach below.
+  // const isRunningOnTerminal = process.stdout.isTTY;
+  // if (isRunningOnTerminal === true) {
+  //   return execWithRetriesAndLogs(command, options);
+  // }
+  //
+  // log.info(`[XCUITest] Currently not running through the Terminal, will run the xcodebuild command on the Terminal`);
+  return _runCommandInTerminal(command, options);
+}
+
+function _runCommandInTerminal(command, options) {
+  const escapedCommand = command.replace(/"/g, '\\"'); // escape double quotes
+
+  // opens the Terminal app and runs the command in a new window, then closes the window when the command is done running.
+  const appleScript = `
+        tell application "Terminal"
+            if not running then
+                open
+            end if
+
+            activate
+            do script "${escapedCommand}; exit"
+
+            repeat
+                delay 1
+                if not busy of window 1 then
+                    close window 1
+                    exit repeat
+                end if
+            end repeat
+        end tell
+    `;
+
+  return execWithRetriesAndLogs(`osascript -e '${appleScript}'`, options);
+}
+
+function _allowNetworkPermissionsXCUITest() {
+  log.debug(`[XCUITest] Allowing network permissions`);
+  let didCallback = false;
+
+  const childProcess = osascript.executeFile(
+    `${__dirname}/allowNetworkPermissionsXCUITest.scpt`,
+    function(err, _, __) {
+      if (err) {
+        log.error(`[XCUITest] Failed to approve network permissions for XCUITest target:\n\t${err}`);
+      } else {
+        log.debug(`[XCUITest] Network permissions are allowed`);
+      }
+
+      didCallback = true;
+    });
+
+  setTimeout(() => {
+    if (didCallback || !childProcess) {
+      return;
+    }
+
+    log.debug(`[XCUITest] Killing the process that allows network permissions (timed-out)`);
+    childProcess.stdin.pause();
+    childProcess.kill('SIGTERM');
+
+  }, 30000);
+}
+
+async function _waitForTestTargetServerToStart(testTargetServerPort, cpPromise) {
+  log.debug(`[XCUITest] Waiting for test target server to start on port ${testTargetServerPort}...`);
+  let isServerUp = false;
+  let retries = 0;
+
+  while (!isServerUp && retries++ < 90) {
+    try {
+      await exec(`nc -z localhost ${testTargetServerPort}`);
+      isServerUp = true;
+    } catch (e) {
+      log.debug(`[XCUITest] Test target server is not up yet, waiting...`);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+
+  if (!isServerUp) {
+    log.error(`[XCUITest] Test target server is not up after 90 seconds, aborting`);
+
+    if (cpPromise && cpPromise.childProcess && cpPromise.childProcess.kill('SIGTERM')) {
+      log.debug(`[XCUITest] Test target process was killed`);
+    } else {
+      log.debug(`[XCUITest] Test target process was not killed`);
+    }
+
+    return false;
+  }
+
+  log.debug(`[XCUITest] Test target server is up and running`);
+  return true;
+}
+
+module.exports = {
+  launchXCUITest
+};

package/src/devices/runtime/drivers/ios/allowNetworkPermissionsXCUITest.scpt

@@ -0,0 +1,14 @@
+tell application "System Events"
+    set frontmost of process "UserNotificationCenter" to true
+    tell process "UserNotificationCenter"
+        repeat until (exists button "Allow" of window 1)
+            delay 1
+        end repeat
+
+        repeat while exists button "Allow" of window 1
+            if exists button "Allow" of window 1 then
+                click button "Allow" of window 1
+            end if
+        end repeat
+    end tell
+end tell

package/src/devices/runtime/factories/android.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none" }] */
 const RuntimeDeviceFactory = require('./base');
 
 class RuntimeDriverFactoryAndroid extends RuntimeDeviceFactory {
@@ -6,7 +7,7 @@ class RuntimeDriverFactoryAndroid extends RuntimeDeviceFactory {
     const adb = serviceLocator.adb;
     const aapt = serviceLocator.aapt;
     const apkValidator = serviceLocator.apkValidator;
-    const fileXfer = serviceLocator.fileXfer;
+    const fileTransfer = serviceLocator.fileTransfer;
     const devicePathBuilder = serviceLocator.devicePathBuilder;
 
     const AppInstallHelper = require('../../common/drivers/android/tools/AppInstallHelper');
@@ -18,9 +19,9 @@ class RuntimeDriverFactoryAndroid extends RuntimeDeviceFactory {
       adb,
       aapt,
       apkValidator,
-      fileXfer,
+      fileTransfer,
       devicePathBuilder,
-      appInstallHelper: new AppInstallHelper(adb, fileXfer),
+      appInstallHelper: new AppInstallHelper(adb, fileTransfer),
       appUninstallHelper: new AppUninstallHelper(adb),
       instrumentation: new MonitoredInstrumentation(adb),
     };
@@ -41,7 +42,7 @@ class AndroidEmulator extends RuntimeDriverFactoryAndroid {
 }
 
 class AndroidAttached extends RuntimeDriverFactoryAndroid {
-  _createDriver(deviceCookie, deps, configs) { // eslint-disable-line no-unused-vars
+  _createDriver(deviceCookie, deps, configs) {
     const props = {
       adbName: deviceCookie.adbName,
     };
@@ -52,7 +53,7 @@ class AndroidAttached extends RuntimeDriverFactoryAndroid {
 }
 
 class Genycloud extends RuntimeDriverFactoryAndroid {
-  _createDriver(deviceCookie, deps, configs) { // eslint-disable-line no-unused-vars
+  _createDriver(deviceCookie, deps, configs) {
     const props = {
       instance: deviceCookie.instance,
     };

package/src/devices/runtime/factories/base.js

@@ -1,3 +1,4 @@
+/* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none" }] */
 const RuntimeDevice = require('../RuntimeDevice');
 
 class RuntimeDeviceFactory {
@@ -7,8 +8,8 @@ class RuntimeDeviceFactory {
     return new RuntimeDevice({ ...commonDeps, ...configs }, runtimeDriver);
   }
 
-  _createDriverDependencies(commonDeps) { } // eslint-disable-line no-unused-vars
-  _createDriver(deviceCookie, deps, configs) {} // eslint-disable-line no-unused-vars
+  _createDriverDependencies(commonDeps) { }
+  _createDriver(deviceCookie, deps, configs) {}
 }
 
 module.exports = RuntimeDeviceFactory;