Merge pull request #4543 from wix/device_allocation_retry

fix(Android): Added retry for Genymotion device allocation

detox/src/devices/allocation/DeviceAllocator.js

@@ -92,6 +92,13 @@ class DeviceAllocator {
       this._driver.emergencyCleanup();
     }
   }
+
+  isRecoverableError(error) {
+    if (typeof this._driver.isRecoverableError !== 'function') {
+      return false;
+    }
+    return this._driver.isRecoverableError(error);
+  }
 }
 
 module.exports = DeviceAllocator;

detox/src/devices/allocation/DeviceAllocator.test.js

@@ -110,4 +110,17 @@ describe('Device allocator', () => {
       expect(allocDriver.emergencyCleanup).toHaveBeenCalled();
     });
   });
+
+  describe('#isRecoverableError()', function() {
+    test('should return false if the driver does not implement this function', () => {
+      delete allocDriver.isRecoverableError;
+      expect(deviceAllocator.isRecoverableError(new Error())).toBe(false);
+    });
+
+    test('should return the driver\'s isRecoverableError result', () => {
+      allocDriver.isRecoverableError = jest.fn().mockReturnValue(true);
+      expect(deviceAllocator.isRecoverableError(new Error())).toBe(true);
+      expect(allocDriver.isRecoverableError).toHaveBeenCalled();
+    });
+  });
 });

detox/src/devices/allocation/drivers/AllocationDriverBase.d.ts

@@ -12,4 +12,5 @@ export interface AllocationDriverBase {
   free(cookie: DeviceCookie, options: DeallocOptions): Promise<void>;
   cleanup?(): Promise<void>;
   emergencyCleanup?(): void;
+  isRecoverableError?(error: any): boolean;
 }

detox/src/devices/allocation/drivers/android/genycloud/GenyAllocDriver.js

@@ -125,6 +125,17 @@ class GenyAllocDriver {
     this._reportGlobalCleanupSummary(deletionLeaks);
   }
 
+  /**
+   * The current error we could recover from in the context of Genymotion Cloud is when the device is not found.
+   * The error message will contain the following text adb: device 'localhost:xxxxx' not found
+   * @param error
+   * @returns {boolean}
+   */
+  isRecoverableError(error) {
+    const errorStr = JSON.stringify(error);
+    return errorStr.indexOf('adb: device \'localhost:') !== -1;
+  }
+
   emergencyCleanup() {
     const instances = this._genyRegistry.getInstances();
     this._reportGlobalCleanupSummary(instances);

detox/src/realms/DetoxPrimaryContext.js

@@ -7,6 +7,7 @@ const temporary = require('../artifacts/utils/temporaryPath');
 const { DetoxRuntimeError } = require('../errors');
 const SessionState = require('../ipc/SessionState');
 const { getCurrentCommand } = require('../utils/argparse');
+const retry = require('../utils/retry');
 const uuid = require('../utils/uuid');
 
 const DetoxContext = require('./DetoxContext');
@@ -27,6 +28,7 @@ const _cookieAllocators = Symbol('cookieAllocators');
 const _deviceAllocators = Symbol('deviceAllocators');
 const _createDeviceAllocator = Symbol('createDeviceAllocator');
 const _createDeviceAllocatorInstance = Symbol('createDeviceAllocatorInstance');
+const _allocateDeviceOnce = Symbol('allocateDeviceOnce');
 //#endregion
 
 class DetoxPrimaryContext extends DetoxContext {
@@ -154,6 +156,20 @@ class DetoxPrimaryContext extends DetoxContext {
   /** @override */
   async [symbols.allocateDevice](deviceConfig) {
     const deviceAllocator = await this[_createDeviceAllocator](deviceConfig);
+
+    const retryOptions = {
+      backoff: 'none',
+      retries: 5,
+      interval: 25000,
+      conditionFn: (e) => deviceAllocator.isRecoverableError(e),
+    };
+
+    return await retry(retryOptions, async () => {
+      return await this[_allocateDeviceOnce](deviceAllocator, deviceConfig);
+    });
+  }
+
+  async [_allocateDeviceOnce](deviceAllocator, deviceConfig) {
     const deviceCookie = await deviceAllocator.allocate(deviceConfig);
     this[_cookieAllocators][deviceCookie.id] = deviceAllocator;
 
@@ -163,7 +179,10 @@ class DetoxPrimaryContext extends DetoxContext {
       try {
         await deviceAllocator.free(deviceCookie, { shutdown: true });
       } catch (e2) {
-        this[symbols.logger].error({ cat: 'device', err: e2 }, `Failed to free ${deviceCookie.name || deviceCookie.id} after a failed allocation attempt`);
+        this[symbols.logger].error({
+          cat: 'device',
+          err: e2
+        }, `Failed to free ${deviceCookie.name || deviceCookie.id} after a failed allocation attempt`);
       } finally {
         delete this[_cookieAllocators][deviceCookie.id];
       }

detox/src/realms/DetoxPrimaryContext.test.js

@@ -59,6 +59,8 @@ describe('DetoxPrimaryContext', () => {
   let facade;
   /** @type {import('./symbols')} */
   let symbols;
+  /** @type {jest.Mock<import('../utils/retry')>} */
+  let retry;
 
   const detoxServer = () => latestInstanceOf(DetoxServer);
   const ipcServer = () => latestInstanceOf(IPCServer);
@@ -466,6 +468,7 @@ describe('DetoxPrimaryContext', () => {
       free: jest.fn(),
       cleanup: jest.fn(),
       emergencyCleanup: jest.fn(),
+      isRecoverableError: jest.fn().mockReturnValue(true)
     };
 
     jest.mock('../environmentFactory');
@@ -481,6 +484,10 @@ describe('DetoxPrimaryContext', () => {
 
     jest.mock('../DetoxWorker');
     DetoxWorker = jest.requireMock('../DetoxWorker');
+
+    jest.mock('../utils/retry');
+    retry = jest.requireMock('../utils/retry');
+    retry.mockImplementation((opts, callback) => callback());
   }
 
   async function allocateSomeDevice() {