detox 20.11.4 → 20.12.0-smoke.0

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-javadoc.jar.md5

@@ -0,0 +1 @@
+9e1ed6595db1eb79fd10b72e768b9561

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-javadoc.jar.sha1

@@ -0,0 +1 @@
+d94beb57b34924c9ff07315304976d12682bcb64

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-javadoc.jar.sha256

@@ -0,0 +1 @@
+282729592fa58c2559eaeae9eb7524552ef025e306c20b6619b2ab79e0187f08

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-javadoc.jar.sha512

@@ -0,0 +1 @@
+bea0140ed5de7a5b9143c3cfbe6a65e5a11d5d7fa4699c0ed81f1d50a4978a72b3cd60a2908d88be78a908260bdb081258edcfd5ee34a5ec3a72a73d1fae7161

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-sources.jar.md5

@@ -0,0 +1 @@
+2cd5617bb26a597c18bd4a2fcc3e47a5

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-sources.jar.sha1

@@ -0,0 +1 @@
+e3addaba91ad374e5e74a90b848ce1691e089f9c

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-sources.jar.sha256

@@ -0,0 +1 @@
+ea34470f9caff1392d20c486c997cbcee75f7aad8dfa4cf9268d6984ae620d3c

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0-sources.jar.sha512

@@ -0,0 +1 @@
+f66e64dc2055ed7bb0ef4ce4434308e607f7f5cfa27bc5b447b94a355aacb731664e1ab8a86816dc64f5b8a949ab7bd76753413a84aa9ad610a11cc2d0c91534

package/Detox-android/com/wix/detox/{20.11.4/detox-20.11.4.pom → 20.12.0-smoke.0/detox-20.12.0-smoke.0.pom}

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
-  <version>20.11.4</version>
+  <version>20.12.0-smoke.0</version>
   <packaging>aar</packaging>
   <name>Detox</name>
   <description>Gray box end-to-end testing and automation library for mobile apps</description>

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0.pom.md5

@@ -0,0 +1 @@
+b657a85f93b0087e4bd3d2ef359cdcca

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0.pom.sha1

@@ -0,0 +1 @@
+abbf983b4b77e1b748513273b9fb853feea6cfc9

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0.pom.sha256

@@ -0,0 +1 @@
+8532ca9a4f54fcbdedcea406b715c7d7150d031e9478996ab505e453dca5d9bc

package/Detox-android/com/wix/detox/20.12.0-smoke.0/detox-20.12.0-smoke.0.pom.sha512

@@ -0,0 +1 @@
+20dc62ea32120332c031cc66c5b90e9917c7bd5ebe0bfff2c30014a05b7e613572fdd6a45b08260fb3b5f8feafc916034c6015a8a3627e67db6205b57cd4697f

package/Detox-android/com/wix/detox/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
   <versioning>
-    <latest>20.11.4</latest>
-    <release>20.11.4</release>
+    <latest>20.12.0-smoke.0</latest>
+    <release>20.12.0-smoke.0</release>
     <versions>
-      <version>20.11.4</version>
+      <version>20.12.0-smoke.0</version>
     </versions>
-    <lastUpdated>20230824160037</lastUpdated>
+    <lastUpdated>20230905081618</lastUpdated>
   </versioning>
 </metadata>

package/Detox-android/com/wix/detox/maven-metadata.xml.md5

@@ -1 +1 @@
-1fae4b4769a24aabf21136e0157420ca
+c0ebd655b45d26da7f4503b42682e6ac

package/Detox-android/com/wix/detox/maven-metadata.xml.sha1

@@ -1 +1 @@
-b19a09221ce9a7e60f6cd29822839a8f24729b21
+b28e7e113a3adf4f4ac956666bef4767712332c5

package/Detox-android/com/wix/detox/maven-metadata.xml.sha256

@@ -1 +1 @@
-65c7ae9291289f20b2cfcf022b0f72553d062eb4b5cc4a751c821b5f272a6392
+428cdbf9560b42fa11a47e4ad09d61f067e46c0222b046489e8cfdb914d43d3e

package/Detox-android/com/wix/detox/maven-metadata.xml.sha512

@@ -1 +1 @@
-1cde86cbf9a88db4bdb189f901a27e2d8fb495b689ee17d3a81492ead7f7da92b9a679c379010dfcb97c5bc14f658a7b38d5cca616bc041c78ee78fb29b85448
+c7042d22a9567df5b06587e91169041fb202a4881b61f76a2b8a3db7b31c571cd8a1b51e4a44fe54ac80499bc249e0b195f67854408cfa47f2388c2c2d0f76ca

package/local-cli/reset-lock-file.js

@@ -1,16 +1,12 @@
 const { log } = require('../internals');
-const DeviceRegistry = require('../src/devices/DeviceRegistry');
-const { getDetoxLibraryRootPath } = require('../src/utils/environment');
-
+const DeviceRegistry = require('../src/devices/allocation/DeviceRegistry');
 
 module.exports.command = 'reset-lock-file';
-module.exports.desc = 'Resets all Detox lock files. Useful when you need to run multiple `detox test` commands in parallel with --keepLockFile.';
+module.exports.desc = 'Resets all Detox lock files. Useful when you need to clean up leftover locks from a crashed Detox instance.';
 
 module.exports.handler = async function resetLockFile() {
-  await Promise.all([
-    DeviceRegistry.forIOS().reset(),
-    DeviceRegistry.forAndroid().reset(),
-  ]);
+  const registry = new DeviceRegistry();
+  await registry.reset();
 
-  log.info(`Cleaned lock files from: ${getDetoxLibraryRootPath()}`);
+  log.info(`Cleaned lock file at: ${registry.lockFilePath}`);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.11.4",
+  "version": "20.12.0-smoke.0",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -196,15 +196,15 @@
     ],
     "coverageThreshold": {
       "global": {
-        "statements": 100,
-        "branches": 100,
-        "functions": 100,
-        "lines": 100
+        "statements": 50,
+        "branches": 50,
+        "functions": 50,
+        "lines": 50
       }
     }
   },
   "browserslist": [
     "node 14"
   ],
-  "gitHead": "1b48840c8d68721ee3968ccaa2783f9f2cfd3339"
+  "gitHead": "6a0b45ddbd1eaae9158e6e27f7d6b85b1411f553"
 }

package/src/DetoxWorker.js

@@ -33,7 +33,6 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
-
     /** @type {DetoxInternals.RuntimeConfig['apps']} */
     this._appsConfig = null;
     /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
@@ -115,14 +114,13 @@ class DetoxWorker {
     const {
       // @ts-ignore
       envValidatorFactory,
-      deviceAllocatorFactory,
       // @ts-ignore
       artifactsManagerFactory,
       // @ts-ignore
       matchersFactory,
       // @ts-ignore
       runtimeDeviceFactory,
-    } = environmentFactory.createFactories(this._deviceConfig);
+    } = environmentFactory.createFactories(deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
     yield envValidator.validate();
@@ -135,10 +133,7 @@ class DetoxWorker {
     };
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
-    this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
-    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
-
-    yield this._deviceAllocator.postAllocate(this._deviceCookie);
+    this._deviceCookie = yield this._context[symbols.allocateDevice]();
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -157,6 +152,8 @@ class DetoxWorker {
     });
     Object.assign(this, matchers);
 
+    yield this._eventEmitter.emit('bootDevice', { deviceId: this.device.id });
+
     if (behaviorConfig.init.exposeGlobals) {
       const injectedGlobals = {
         ...matchers,
@@ -207,8 +204,7 @@ class DetoxWorker {
     }
 
     if (this._deviceCookie) {
-      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
-      await this._deviceAllocator.free(this._deviceCookie, { shutdown });
+      await this._context[symbols.deallocateDevice](this._deviceCookie);
     }
 
     this._deviceAllocator = null;

package/src/artifacts/providers/index.js

@@ -4,7 +4,7 @@ class ArtifactPluginsProvider {
 
 class AndroidArtifactPluginsProvider extends ArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../servicelocator/android');
+    const serviceLocator = require('../../devices/servicelocator/android');
     const adb = serviceLocator.adb;
     const devicePathBuilder = serviceLocator.devicePathBuilder;
 
@@ -34,8 +34,8 @@ class IosArtifactPluginsProvider extends ArtifactPluginsProvider {
 
 class IosSimulatorArtifactPluginsProvider extends IosArtifactPluginsProvider {
   declareArtifactPlugins({ client }) {
-    const serviceLocator = require('../../servicelocator/ios');
-    const appleSimUtils = serviceLocator.appleSimUtils;
+    const AppleSimUtils = require('../../devices/common/drivers/ios/tools/AppleSimUtils');
+    const appleSimUtils = new AppleSimUtils();
 
     const SimulatorInstrumentsPlugin = require('../instruments/ios/SimulatorInstrumentsPlugin');
     const SimulatorLogPlugin = require('../log/ios/SimulatorLogPlugin');

package/src/artifacts/screenshot/SimulatorScreenshotPlugin.js

@@ -22,23 +22,6 @@ class SimulatorScreenshotPlugin extends ScreenshotArtifactPlugin {
     }
   }
 
-  async onBootDevice(event) {
-    await super.onBootDevice(event);
-
-    if (this.enabled && event.coldBoot) {
-      await this.appleSimUtils.takeScreenshot(event.deviceId, '/dev/null').catch(() => {
-        log.debug({}, `
-          NOTE: For an unknown yet reason, taking the first screenshot is apt
-          to fail when booting iOS Simulator in a hidden window mode (or on CI).
-          Detox applies a workaround by taking a dummy screenshot to ensure
-          that the future ones are going to work fine. This screenshot is not
-          saved anywhere, and the error above is suppressed for all log levels
-          except for "debug" and "trace."
-        `.trim());
-      });
-    }
-  }
-
   async onBeforeUninstallApp(event) {
     await this.api.requestIdleCallback(async () => {
       const snapshots = [

package/src/devices/allocation/DeviceAllocator.js

@@ -1,5 +1,5 @@
 // @ts-nocheck
-const log = require('../../utils/logger').child({ cat: 'device' });
+const log = require('../../utils/logger').child({ cat: 'device,device-allocation' });
 const traceMethods = require('../../utils/traceMethods');
 
 class DeviceAllocator {
@@ -8,36 +8,71 @@ class DeviceAllocator {
    */
   constructor(allocationDriver) {
     this._driver = allocationDriver;
-    traceMethods(log, this, ['allocate', 'postAllocate', 'free']);
+    traceMethods(log, this, ['init', 'cleanup', 'emergencyCleanup']);
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async init() {
+    if (typeof this._driver.init === 'function') {
+      await this._driver.init();
+    }
   }
 
   /**
    * @param deviceConfig { Object }
-   * @return {Promise<DeviceCookie>}
+   * @returns {Promise<DeviceCookie>}
    */
-  allocate(deviceConfig) {
-    return this._driver.allocate(deviceConfig);
+  async allocate(deviceConfig) {
+    return await log.trace.complete({ data: deviceConfig, id: Math.random() }, 'allocate', async () => {
+      const cookie = await this._driver.allocate(deviceConfig);
+      log.debug({ event: undefined }, `settled on ${cookie}`);
+      return cookie;
+    });
   }
 
   /**
    * @param {DeviceCookie} deviceCookie
-   * @return {Promise<unknown>}
+   * @returns {Promise<DeviceCookie>}
    */
-  postAllocate(deviceCookie) {
-    if (typeof this._driver.postAllocate !== 'function') {
-      return Promise.resolve();
-    }
+  async postAllocate(deviceCookie) {
+    return await log.trace.complete({ data: deviceCookie, id: Math.random() }, `post-allocate: ${deviceCookie}`, async () => {
+      const updatedCookie = typeof this._driver.postAllocate === 'function'
+        ? await this._driver.postAllocate(deviceCookie)
+        : undefined;
 
-    return this._driver.postAllocate(deviceCookie);
+      return updatedCookie || deviceCookie;
+    });
   }
 
   /**
    * @param cookie { DeviceCookie }
-   * @param options { DeallocOptions }
-   * @return {Promise<void>}
+   * @param options { Partial<DeallocOptions> }
+   * @returns {Promise<void>}
+   */
+  async free(cookie, options = {}) {
+    await log.trace.complete({ data: options, id: Math.random() }, `free: ${cookie}`, async () => {
+      await this._driver.free(cookie, options);
+    });
+  }
+
+  /**
+   * @returns {Promise<void>}
+   */
+  async cleanup() {
+    if (typeof this._driver.cleanup === 'function') {
+      await this._driver.cleanup();
+    }
+  }
+
+  /**
+   * @returns {void}
    */
-  free(cookie, options) {
-    return this._driver.free(cookie, options);
+  emergencyCleanup() {
+    if (typeof this._driver.emergencyCleanup === 'function') {
+      this._driver.emergencyCleanup();
+    }
   }
 }
 

package/src/devices/allocation/DeviceList.js

@@ -0,0 +1,44 @@
+class DeviceListReadonly {
+  constructor(devices = []) {
+    this._devices = new Map(devices.map(device => [device.id, device]));
+  }
+
+  concat(other) {
+    return new DeviceListReadonly([...this, ...other]);
+  }
+
+  getIds() {
+    return [...this._devices.keys()];
+  }
+
+  [Symbol.iterator]() {
+    return this._devices.values();
+  }
+
+  /**
+   * @param {string} deviceId
+   * @returns {boolean}
+   */
+  includes(deviceId) {
+    return this._devices.has(deviceId);
+  }
+}
+
+class DeviceList extends DeviceListReadonly {
+  filter(predicate) {
+    return new DeviceListReadonly([...this].filter(predicate));
+  }
+
+  add(deviceId, data) {
+    this._devices.set(deviceId, {
+      id: deviceId,
+      ...data,
+    });
+  }
+
+  delete(deviceId) {
+    this._devices.delete(deviceId);
+  }
+}
+
+module.exports = DeviceList;

package/src/devices/allocation/DeviceRegistry.js

@@ -0,0 +1,186 @@
+const ExclusiveLockfile = require('../../utils/ExclusiveLockfile');
+const PIDService = require('../../utils/PIDService');
+const { getDeviceRegistryPath } = require('../../utils/environment');
+const safeAsync = require('../../utils/safeAsync');
+
+const DeviceList = require('./DeviceList');
+
+const readOptions = {
+  encoding: 'utf8',
+};
+
+class DeviceRegistry {
+  constructor({
+    lockfilePath = getDeviceRegistryPath(),
+    sessionId = '',
+    pidService = new PIDService(),
+  } = {}) {
+    /***
+     * @private
+     * @type {string}
+     */
+    this._lockfilePath = lockfilePath;
+    /***
+     * @private
+     * @type {string}
+     */
+    this._sessionId = sessionId;
+    /***
+     * @private
+     */
+    this._pidService = pidService;
+    /***
+     * @protected
+     * @type {ExclusiveLockfile}
+     */
+    this._lockfile = new ExclusiveLockfile(this._lockfilePath, {
+      getInitialState: this._getInitialLockFileState.bind(this),
+      readOptions,
+    });
+  }
+
+  get lockFilePath() {
+    return this._lockfilePath;
+  }
+
+  /**
+   * Safety method to ensure that there are no remains of previously crashed Detox sessions.
+   */
+  async reset() {
+    await this._lockfile.exclusively(() => {
+      const empty = this._getInitialLockFileState();
+      this._lockfile.write(empty);
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async registerDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: true,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<string>}
+   */
+  async releaseDevice(getDeviceId) {
+    return this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._upsertDevice(deviceId, {
+          busy: false,
+          sessionId: this._sessionId,
+          pid: this._pidService.getPid(),
+        });
+      }
+      return deviceId;
+    });
+  }
+
+  /***
+   * @param {string|Function} getDeviceId
+   * @returns {Promise<void>}
+   */
+  async unregisterDevice(getDeviceId) {
+    await this._lockfile.exclusively(async () => {
+      const deviceId = await safeAsync(getDeviceId);
+      if (deviceId) {
+        this._deleteDevice(deviceId);
+      }
+    });
+  }
+
+  async unregisterSessionDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const sessionDevices = allDevices.filter(device => device.sessionId === this._sessionId);
+      for (const id of sessionDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  async unregisterZombieDevices() {
+    await this._lockfile.exclusively(async () => {
+      const allDevices = this._getRegisteredDevices();
+      const zombieDevices = allDevices.filter(device => {
+        return device.sessionId !== this._sessionId && !this._pidService.isAlive(device.pid);
+      });
+
+      for (const id of zombieDevices.getIds()) {
+        allDevices.delete(id);
+      }
+      this._lockfile.write([...allDevices]);
+    });
+  }
+
+  async readSessionDevices() {
+    let devices;
+    await this._lockfile.exclusively(() => {
+      devices = this._getSessionDevicesSync();
+    });
+    return devices;
+  }
+
+  getTakenDevicesSync() {
+    const allDevices = this._getRegisteredDevices();
+    const busyDevices = allDevices.filter(device => device.busy);
+    const externalDevices = allDevices.filter(device => device.sessionId !== this._sessionId);
+    return busyDevices.concat(externalDevices);
+  }
+
+  /***
+   * @private
+   */
+  _getInitialLockFileState() {
+    return [];
+  }
+
+  /**
+   * @private
+   */
+  _upsertDevice(deviceId, data) {
+    const devices = this._getRegisteredDevices();
+    devices.add(deviceId, data);
+    this._lockfile.write([...devices]);
+  }
+
+  /**
+   * @private
+   */
+  _deleteDevice(deviceId) {
+    const devices = this._getRegisteredDevices();
+    devices.delete(deviceId);
+    this._lockfile.write([...devices]);
+  }
+
+  /***
+   * @private
+   * @returns {DeviceList}
+   */
+  _getRegisteredDevices() {
+    const devices = this._lockfile.read();
+    return new DeviceList(devices);
+  }
+
+  _getSessionDevicesSync() {
+    const devices = this._getRegisteredDevices();
+    const sessionDevices = devices.filter(device => device.sessionId === this._sessionId);
+    return sessionDevices;
+  }
+}
+
+module.exports = DeviceRegistry;

package/src/devices/allocation/drivers/AllocationDriverBase.js

@@ -7,24 +7,30 @@
  */
 
 class AllocationDriverBase {
+  async init() {}
+
   /**
    * @param deviceConfig { Object }
-   * @return {Promise<DeviceCookie>}
+   * @return {Promise<import('../../cookies/DeviceCookie')>}
    */
   async allocate(deviceConfig) {}
 
   /**
-   * @param {DeviceCookie} deviceCookie
-   * @return {Promise<void>}
+   * @param {import('../../cookies/DeviceCookie')} deviceCookie
+   * @return {Promise<import('../../cookies/DeviceCookie') | void>}
    */
   async postAllocate(deviceCookie) {}
 
   /**
-   * @param cookie { DeviceCookie }
+   * @param cookie { import('../../cookies/DeviceCookie') }
    * @param options { DeallocOptions }
    * @return {Promise<void>}
    */
   async free(cookie, options) {}
+
+  async cleanup() {}
+
+  emergencyCleanup() {}
 }
 
 module.exports = AllocationDriverBase;

package/src/devices/{common/drivers/android/tools → allocation/drivers/android}/FreeDeviceFinder.js

@@ -1,6 +1,6 @@
-const log = require('../../../../../utils/logger').child({ cat: 'device' });
+const log = require('../../../../utils/logger').child({ cat: 'device' });
 
-const DEVICE_LOOKUP_LOG_EVT = 'DEVICE_LOOKUP';
+const DEVICE_LOOKUP = { event: 'DEVICE_LOOKUP' };
 
 class FreeDeviceFinder {
   constructor(adb, deviceRegistry) {
@@ -10,8 +10,9 @@ class FreeDeviceFinder {
 
   async findFreeDevice(deviceQuery) {
     const { devices } = await this.adb.devices();
+    const takenDevices = this.deviceRegistry.getTakenDevicesSync();
     for (const candidate of devices) {
-      if (await this._isDeviceFreeAndMatching(candidate, deviceQuery)) {
+      if (await this._isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery)) {
         return candidate.adbName;
       }
     }
@@ -19,30 +20,30 @@ class FreeDeviceFinder {
   }
 
   /**
-   * @protected
+   * @private
    */
-  async _isDeviceFreeAndMatching(candidate, deviceQuery) {
+  async _isDeviceFreeAndMatching(takenDevices, candidate, deviceQuery) {
     const { adbName } = candidate;
 
-    const isTaken = this.deviceRegistry.includes(adbName);
+    const isTaken = takenDevices.includes(adbName);
     if (isTaken) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is already taken, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is already taken, skipping...`);
       return false;
     }
 
     const isOffline = candidate.status === 'offline';
     if (isOffline) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} is offline, skipping...`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} is offline, skipping...`);
       return false;
     }
 
     const isMatching = await this._isDeviceMatching(candidate, deviceQuery);
     if (!isMatching) {
-      log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Device ${adbName} does not match "${deviceQuery}"`);
+      log.debug(DEVICE_LOOKUP, `Device ${adbName} does not match "${deviceQuery}"`);
       return false;
     }
 
-    log.debug({ event: DEVICE_LOOKUP_LOG_EVT }, `Found a matching & free device ${candidate.adbName}`);
+    log.debug(DEVICE_LOOKUP, `Found a matching & free device ${candidate.adbName}`);
     return true;
   }