Refactor uninstall onto a helper, as well

Author: d4vidi

detox/src/devices/drivers/android/AndroidDriver.js

@@ -9,6 +9,7 @@ const InvocationManager = invoke.InvocationManager;
 const ADB = require('./tools/ADB');
 const AAPT = require('./tools/AAPT');
 const APKPath = require('./tools/APKPath');
+const AppUninstallHelper = require('./tools/AppUninstallHelper');
 const DeviceDriverBase = require('../DeviceDriverBase');
 const DetoxApi = require('../../../android/espressoapi/Detox');
 const EspressoDetoxApi = require('../../../android/espressoapi/EspressoDetox');
@@ -79,15 +80,8 @@ class AndroidDriver extends DeviceDriverBase {
 
   async uninstallApp(deviceId, bundleId) {
     await this.emitter.emit('beforeUninstallApp', { deviceId, bundleId });
-
-    if (await this.adb.isPackageInstalled(deviceId, bundleId)) {
-      await this.adb.uninstall(deviceId, bundleId);
-    }
-
-    const testBundle = `${bundleId}.test`;
-    if (await this.adb.isPackageInstalled(deviceId, testBundle)) {
-      await this.adb.uninstall(deviceId, testBundle);
-    }
+    const uninstallHelper = new AppUninstallHelper(this.adb);
+    await uninstallHelper.uninstall(deviceId, bundleId);
   }
 
   async uninstallAppByApk(deviceId, apkPath) {

detox/src/devices/drivers/android/EmulatorDriver.js

@@ -68,10 +68,10 @@ class EmulatorDriver extends AndroidDriver {
       testBinaryPath,
     } = this._getInstallPaths(_binaryPath, _testBinaryPath);
 
-    await this.uninstallAppByApk(deviceId, binaryPath); // TODO extract this (and all related logic) to a designated helper?
+    await this.uninstallAppByApk(deviceId, binaryPath);
 
-    const installHelper = new AppInstallHelper(this.adb, deviceId);
-    await installHelper.install(binaryPath, testBinaryPath);
+    const installHelper = new AppInstallHelper(this.adb);
+    await installHelper.install(deviceId, binaryPath, testBinaryPath);
   }
 
   async cleanup(adbName, bundleId) {

detox/src/devices/drivers/android/tools/AppInstallHelper.js

@@ -2,30 +2,29 @@ const EMU_TEMP_PATH = '/data/local/tmp';
 const EMU_TEMP_INSTALL_PATH = `${EMU_TEMP_PATH}/detox`;
 
 class AppInstallHelper {
-  constructor(adb, deviceId, tempDir = EMU_TEMP_INSTALL_PATH) {
+  constructor(adb, tempDir = EMU_TEMP_INSTALL_PATH) {
     this._adb = adb;
-    this._deviceId = deviceId;
     this._tempDir = tempDir;
   }
 
-  async install(appBinaryPath, testBinaryPath) {
-    await this._prepareTempDirOnDevice();
+  async install(deviceId, appBinaryPath, testBinaryPath) {
+    await this._prepareTempDirOnDevice(deviceId);
 
     const appBinaryPathOnTarget = this._getTargetBinaryPath(false);
-    await this._pushAndInstallBinary(appBinaryPath, appBinaryPathOnTarget);
+    await this._pushAndInstallBinary(deviceId, appBinaryPath, appBinaryPathOnTarget);
 
     const testBinaryPathOnTarget = this._getTargetBinaryPath(true);
-    await this._pushAndInstallBinary(testBinaryPath, testBinaryPathOnTarget);
+    await this._pushAndInstallBinary(deviceId, testBinaryPath, testBinaryPathOnTarget);
   }
 
-  async _prepareTempDirOnDevice() {
-    await this._adb.shell(this._deviceId, `rm -fr ${this._tempDir}`);
-    await this._adb.shell(this._deviceId, `mkdir -p ${this._tempDir}`);
+  async _prepareTempDirOnDevice(deviceId) {
+    await this._adb.shell(deviceId, `rm -fr ${this._tempDir}`);
+    await this._adb.shell(deviceId, `mkdir -p ${this._tempDir}`);
   }
 
-  async _pushAndInstallBinary(binaryPath, binaryPathOnTarget) {
-    await this._adb.push(this._deviceId, binaryPath, binaryPathOnTarget);
-    await this._adb.remoteInstall(this._deviceId, binaryPathOnTarget);
+  async _pushAndInstallBinary(deviceId, binaryPath, binaryPathOnTarget) {
+    await this._adb.push(deviceId, binaryPath, binaryPathOnTarget);
+    await this._adb.remoteInstall(deviceId, binaryPathOnTarget);
   }
 
   _getTargetBinaryPath(isTestBinary) {

detox/src/devices/drivers/android/tools/AppInstallHelper.test.js

@@ -1,5 +1,5 @@
-const deviceTempDir = '/mock-tmp-dir';
 const deviceId = 'mock-device-id';
+const deviceTempDir = '/mock-tmp-dir';
 const appBinaryPath = '/mock-app-binary-path/binary.apk';
 const testBinaryPath = '/mock-test-binary-path/test/binary.apk';
 
@@ -22,11 +22,11 @@ describe('Android app installation helper', () => {
   let uut;
   beforeEach(() => {
     const AppInstallHelper = require('./AppInstallHelper');
-    uut = new AppInstallHelper(adb, deviceId, deviceTempDir);
+    uut = new AppInstallHelper(adb, deviceTempDir);
   });
 
   it('should recreate a temp dir on the device', async () => {
-    await uut.install(appBinaryPath, testBinaryPath);
+    await uut.install(deviceId, appBinaryPath, testBinaryPath);
 
     expect(adb.shell).toHaveBeenCalledWith(deviceId, `rm -fr ${deviceTempDir}`);
     expect(adb.shell).toHaveBeenCalledWith(deviceId, `mkdir -p ${deviceTempDir}`);
@@ -36,32 +36,32 @@ describe('Android app installation helper', () => {
     adb.shell.mockRejectedValue(new Error('mocked error in adb-shell'));
 
     try {
-      await uut.install(appBinaryPath, testBinaryPath);
+      await uut.install(deviceId, appBinaryPath, testBinaryPath);
       fail('expected to throw');
     } catch (err) {}
   });
 
   it('should push app-binary file to temp dir on device', async () => {
-    await uut.install(appBinaryPath, testBinaryPath);
+    await uut.install(deviceId, appBinaryPath, testBinaryPath);
     expect(adb.push).toHaveBeenCalledWith(deviceId, appBinaryPath, '/mock-tmp-dir/Application.apk');
   });
 
   it('should push test-binary file to temp dir on device', async () => {
-    await uut.install(appBinaryPath, testBinaryPath);
+    await uut.install(deviceId, appBinaryPath, testBinaryPath);
     expect(adb.push).toHaveBeenCalledWith(deviceId, testBinaryPath, '/mock-tmp-dir/Test.apk');
   });
 
   it('should fail if adb-push fails', async () => {
     adb.push.mockRejectedValue(new Error('mocked error in adb-push'));
 
     try {
-      await uut.install(appBinaryPath, testBinaryPath);
+      await uut.install(deviceId, appBinaryPath, testBinaryPath);
       fail('expected to throw');
     } catch(err) {}
   });
 
   it('should remote-install both binaries via shell', async () => {
-    await uut.install(appBinaryPath, testBinaryPath);
+    await uut.install(deviceId, appBinaryPath, testBinaryPath);
     expect(adb.remoteInstall).toHaveBeenCalledWith(deviceId, '/mock-tmp-dir/Application.apk');
     expect(adb.remoteInstall).toHaveBeenCalledWith(deviceId, '/mock-tmp-dir/Test.apk');
   });
@@ -70,16 +70,16 @@ describe('Android app installation helper', () => {
     adb.remoteInstall.mockRejectedValue(new Error('mocked error in remote-install'));
 
     try {
-      await uut.install(appBinaryPath, testBinaryPath);
+      await uut.install(deviceId, appBinaryPath, testBinaryPath);
       fail('expected to throw');
     } catch(err) {}
   });
 
   it('should use a default temp-dir', async () => {
     const AppInstallHelper = require('./AppInstallHelper');
-    uut = new AppInstallHelper(adb, deviceId, undefined);
+    uut = new AppInstallHelper(adb, undefined);
 
-    await uut.install(appBinaryPath, testBinaryPath);
+    await uut.install(deviceId, appBinaryPath, testBinaryPath);
 
     expect(adb.push).toHaveBeenCalledWith(deviceId, appBinaryPath, '/data/local/tmp/detox/Application.apk');
   });

detox/src/devices/drivers/android/tools/AppUninstallHelper.js

@@ -0,0 +1,18 @@
+class AppUninstallHelper {
+  constructor(adb) {
+    this._adb = adb;
+  }
+
+  async uninstall(deviceId, bundleId) {
+    if (await this._adb.isPackageInstalled(deviceId, bundleId)) {
+      await this._adb.uninstall(deviceId, bundleId);
+    }
+
+    const testBundleId = `${bundleId}.test`;
+    if (await this._adb.isPackageInstalled(deviceId, testBundleId)) {
+      await this._adb.uninstall(deviceId, testBundleId);
+    }
+  }
+}
+
+module.exports = AppUninstallHelper;

detox/src/devices/drivers/android/tools/AppUninstallHelper.test.js

@@ -0,0 +1,76 @@
+const deviceId = 'mock-device-id';
+const bundleId = 'mock-bundle-id';
+const testBundleId = 'mock-bundle-id.test';
+
+describe('Android app uninstall helper', () => {
+  let adb;
+  class MockAdbClass {
+    constructor() {
+      this.uninstall = (...args) => adb.uninstall(...args);
+      this.isPackageInstalled = (...args) => adb.isPackageInstalled(...args);
+    }
+  }
+
+  beforeEach(() => {
+    const ADBMock = jest.genMockFromModule('./ADB');
+    adb = new ADBMock();
+    adb.isPackageInstalled.mockResolvedValue(true);
+
+    jest.mock('./ADB', () => MockAdbClass);
+  });
+
+  let uut;
+  beforeEach(() => {
+    const AppUninstallHelper = require('./AppUninstallHelper');
+    uut = new AppUninstallHelper(adb);
+  });
+
+  it('should uninstall the app\'s binary using adb', async () => {
+    await uut.uninstall(deviceId, bundleId);
+    expect(adb.uninstall).toHaveBeenCalledWith(deviceId, bundleId);
+  });
+
+  it('should fail if app uninstall fails', async () => {
+    adb.uninstall.mockRejectedValue(new Error('mocked error in adb.uninstall'));
+    try {
+      await uut.uninstall(deviceId, bundleId);
+      fail('expected an error');
+    } catch (err) {}
+  });
+
+  it('should avoid uninstalling app if not already installed', async () => {
+    adb.isPackageInstalled.mockResolvedValue(false);
+
+    await uut.uninstall(deviceId, bundleId);
+
+    expect(adb.isPackageInstalled).toHaveBeenCalledWith(deviceId, bundleId);
+    expect(adb.uninstall).not.toHaveBeenCalledWith(deviceId, bundleId);
+  });
+
+  it('should uninstall the test binary using adb', async () => {
+    await uut.uninstall(deviceId, bundleId);
+    expect(adb.uninstall).toHaveBeenCalledWith(deviceId, testBundleId);
+  });
+
+  it('should fail if test binary uninstall fails', async () => {
+    adb.uninstall
+      .mockResolvedValueOnce(true)
+      .mockRejectedValueOnce(new Error('mocked error in adb.uninstall'));
+
+    try {
+      await uut.uninstall(deviceId, bundleId);
+      fail('expected an error');
+    } catch (err) {}
+  });
+
+  it('should avoid uninstalling test binary if not already installed', async () => {
+    adb.isPackageInstalled
+      .mockResolvedValueOnce(true)
+      .mockResolvedValueOnce(false);
+
+    await uut.uninstall(deviceId, bundleId);
+
+    expect(adb.isPackageInstalled).toHaveBeenCalledWith(deviceId, testBundleId);
+    expect(adb.uninstall).not.toHaveBeenCalledWith(deviceId, testBundleId);
+  });
+});