appium-xcuitest-driver 7.14.0 → 7.15.1

package/lib/commands/app-management.js

@@ -4,7 +4,11 @@ import {errors} from 'appium/driver';
 import {services} from 'appium-ios-device';
 import path from 'node:path';
 import B from 'bluebird';
-import { extractBundleId } from '../app-utils';
+import {
+  SUPPORTED_EXTENSIONS,
+  onPostConfigureApp,
+  onDownloadApp,
+} from '../app-utils';
 
 export default {
   /**
@@ -12,15 +16,20 @@ export default {
    *
    * Please ensure the app is built for a correct architecture and is signed with a proper developer signature (for real devices) prior to calling this.
    * @param {string} app - See docs for `appium:app` capability
-   * @param {import('./types').AppInstallStrategy} [strategy] - One of possible app installation strategies on real devices. This argument is ignored on simulators. If not provided, then the value of `appium:appInstallStrategy` is used. If the latter is also not provided, then `serial` is used. See the description of `appium:appInstallStrategy` capability for more details on allowed values.
-   * @param {number} [timeoutMs] - The maximum time to wait until app install is finished (in ms) on real devices. If not provided, then the value of `appium:appPushTimeout` capability is used. If the capability is not provided then the default is 240000ms (4 minutes).
-   * @param {boolean} [checkVersion] - If the application installation follows currently installed application's version status if provided. No checking occurs if no this option.
+   * @param {number} [timeoutMs] - The maximum time to wait until app install is finished (in ms) on real devices.
+   * If not provided, then the value of `appium:appPushTimeout` capability is used. If the capability is not provided then the default is 240000ms (4 minutes).
+   * @param {boolean} [checkVersion] - If the application installation follows currently installed application's version status if provided.
+   * No checking occurs if no this option.
    * @privateRemarks Link to capability docs
    * @returns {Promise<void>}
    * @this {XCUITestDriver}
    */
-  async mobileInstallApp(app, timeoutMs, strategy, checkVersion) {
-    const srcAppPath = await this.helpers.configureApp(app, '.app');
+  async mobileInstallApp(app, timeoutMs, checkVersion) {
+    const srcAppPath = await this.helpers.configureApp(app, {
+      onPostProcess: onPostConfigureApp.bind(this),
+      onDownload: onDownloadApp.bind(this),
+      supportedExtensions: SUPPORTED_EXTENSIONS,
+    });
     this.log.info(
       `Installing '${srcAppPath}' to the ${this.isRealDevice() ? 'real device' : 'Simulator'} ` +
         `with UDID '${this.device.udid}'`,
@@ -31,8 +40,8 @@ export default {
       );
     }
 
+    const bundleId = await this.appInfosCache.extractBundleId(srcAppPath);
     if (checkVersion) {
-      const bundleId = await extractBundleId(srcAppPath);
       const {install} = await this.checkAutInstallationState({
         enforceAppInstall: false,
         fullReset: false,
@@ -49,8 +58,10 @@ export default {
 
     await this.device.installApp(
       srcAppPath,
-      timeoutMs ?? this.opts.appPushTimeout,
-      strategy ?? this.opts.appInstallStrategy,
+      bundleId,
+      {
+        timeoutMs: timeoutMs ?? this.opts.appPushTimeout
+      },
     );
     this.log.info(`Installation of '${srcAppPath}' succeeded`);
   },

package/lib/commands/app-strings.js

@@ -4,8 +4,11 @@ export default {
   /**
    * Return the language-specific strings for an app
    *
-   * @param {string} language - The language abbreviation to fetch app strings mapping for. If no language is provided then strings for the 'en language would be returned
-   * @param {string|null} [stringFile=null] - Relative path to the corresponding .strings file starting from the corresponding .lproj folder, e.g., `base/main.strings`. If omitted, then Appium will make its best guess where the file is.
+   * @param {string} language - The language abbreviation to fetch app strings mapping for.
+   * If no language is provided then strings for the 'en language would be returned
+   * @param {string|null} [stringFile=null] - Relative path to the corresponding .strings
+   * file starting from the corresponding .lproj folder, e.g., `base/main.strings`. If omitted,
+   * then Appium will make its best guess where the file is.
    *
    * @returns {Promise<import('@appium/types').StringRecord<string>>} A record of localized keys to localized text
    *
@@ -13,7 +16,7 @@ export default {
    */
   async getStrings(language, stringFile = null) {
     this.log.debug(`Gettings strings for language '${language}' and string file '${stringFile}'`);
-    return await parseLocalizableStrings(
+    return await parseLocalizableStrings.bind(this)(
       Object.assign({}, this.opts, {
         language,
         stringFile,

package/lib/commands/file-movement.js

@@ -160,7 +160,7 @@ async function pushFileToSimulator(device, remotePath, base64Data) {
 async function pushFileToRealDevice(device, remotePath, base64Data) {
   const {service, relativePath} = await createService(device.udid, remotePath);
   try {
-    await pushFile(service, relativePath, base64Data);
+    await pushFile(service, Buffer.from(base64Data, 'base64'), relativePath);
   } catch (e) {
     log.debug(e.stack);
     throw new Error(`Could not push the file to '${remotePath}'.  Original error: ${e.message}`);

package/lib/commands/types.ts

@@ -219,6 +219,7 @@ export interface View {
  */
 export type SourceFormat = 'xml' | 'json' | 'description';
 
+/** @deprecated */
 export type AppInstallStrategy = 'serial' | 'parallel' | 'ios-deploy';
 
 export interface ProfileManifest {

package/lib/desired-caps.js

@@ -355,6 +355,7 @@ const desiredCapConstraints = /** @type {const} */ ({
     isBoolean: true,
   },
   appInstallStrategy: {
+    deprecated: true,
     isString: true,
     inclusionCaseInsensitive: ['serial', 'parallel', 'ios-deploy'],
   },

package/lib/driver.js

@@ -14,8 +14,6 @@ import url from 'node:url';
 import {
   SUPPORTED_EXTENSIONS,
   SAFARI_BUNDLE_ID,
-  extractBundleId,
-  extractBundleVersion,
   onPostConfigureApp,
   onDownloadApp,
   verifyApplicationPlatform,
@@ -55,7 +53,6 @@ import {
   getAndCheckXcodeVersion,
   getDriverInfo,
   isLocalHost,
-  isTvOs,
   markSystemFilesForCleanup,
   normalizeCommandTimeouts,
   normalizePlatformVersion,
@@ -63,6 +60,7 @@ import {
   removeAllSessionWebSocketHandlers,
   translateDeviceName,
 } from './utils';
+import { AppInfosCache } from './app-infos-cache';
 
 const SHUTDOWN_OTHER_FEAT_NAME = 'shutdown_other_sims';
 const CUSTOMIZE_RESULT_BUNDLE_PATH = 'customize_result_bundle_path';
@@ -310,6 +308,7 @@ export class XCUITestDriver extends BaseDriver {
     }
     this.lifecycleData = {};
     this._audioRecorder = null;
+    this.appInfosCache = new AppInfosCache(this.log);
   }
 
   async onSettingsUpdate(key, value) {
@@ -548,7 +547,7 @@ export class XCUITestDriver extends BaseDriver {
       await checkAppPresent(this.opts.app);
 
       if (!this.opts.bundleId) {
-        this.opts.bundleId = await extractBundleId(this.opts.app);
+        this.opts.bundleId = await this.appInfosCache.extractBundleId(this.opts.app);
       }
     }
 
@@ -1503,7 +1502,7 @@ export class XCUITestDriver extends BaseDriver {
       };
     }
 
-    const candidateBundleVersion = await extractBundleVersion(app);
+    const candidateBundleVersion = await this.appInfosCache.extractBundleVersion(app);
     this.log.debug(`CFBundleVersion from Info.plist: ${candidateBundleVersion}`);
     if (!candidateBundleVersion) {
       return {
@@ -1560,10 +1559,7 @@ export class XCUITestDriver extends BaseDriver {
       return;
     }
 
-    await verifyApplicationPlatform(this.opts.app, {
-      isSimulator: this.isSimulator(),
-      isTvOS: isTvOs(this.opts.platformName),
-    });
+    await verifyApplicationPlatform.bind(this)();
 
     const {install, skipUninstall} = await this.checkAutInstallationState();
     if (install) {
@@ -1571,7 +1567,6 @@ export class XCUITestDriver extends BaseDriver {
         await installToRealDevice.bind(this)(this.opts.app, this.opts.bundleId, {
           skipUninstall,
           timeout: this.opts.appPushTimeout,
-          strategy: this.opts.appInstallStrategy,
         });
       } else {
         await installToSimulator.bind(this)(this.opts.app, this.opts.bundleId, {
@@ -1607,9 +1602,13 @@ export class XCUITestDriver extends BaseDriver {
     }
 
     /** @type {string[]} */
-    const appPaths = await B.all(appsList.map((app) => this.helpers.configureApp(app, '.app')));
+    const appPaths = await B.all(appsList.map((app) => this.helpers.configureApp(app, {
+      onPostProcess: onPostConfigureApp.bind(this),
+      onDownload: onDownloadApp.bind(this),
+      supportedExtensions: SUPPORTED_EXTENSIONS,
+    })));
     /** @type {string[]} */
-    const appIds = await B.all(appPaths.map((appPath) => extractBundleId(appPath)));
+    const appIds = await B.all(appPaths.map((appPath) => this.appInfosCache.extractBundleId(appPath)));
     for (const [appId, appPath] of _.zip(appIds, appPaths)) {
       if (this.isRealDevice()) {
         await installToRealDevice.bind(this)(
@@ -1618,7 +1617,6 @@ export class XCUITestDriver extends BaseDriver {
           {
             skipUninstall: true, // to make the behavior as same as UIA2
             timeout: this.opts.appPushTimeout,
-            strategy: this.opts.appInstallStrategy,
           },
         );
       } else {
@@ -1689,7 +1687,7 @@ export class XCUITestDriver extends BaseDriver {
       return;
     }
 
-    const candidateBundleId = await extractBundleId(this.opts.prebuiltWDAPath);
+    const candidateBundleId = await this.appInfosCache.extractBundleId(this.opts.prebuiltWDAPath);
     this.wda.updatedWDABundleId = candidateBundleId.replace('.xctrunner', '');
     this.log.info(
       `Installing prebuilt WDA at '${this.opts.prebuiltWDAPath}'. ` +
@@ -1705,7 +1703,6 @@ export class XCUITestDriver extends BaseDriver {
         {
           skipUninstall: true,
           timeout: this.opts.appPushTimeout,
-          strategy: this.opts.appInstallStrategy,
         },
       );
     } else {

package/lib/execute-method-map.ts

@@ -150,7 +150,7 @@ export const executeMethodMap = {
     command: 'mobileInstallApp',
     params: {
       required: ['app'],
-      optional: ['strategy', 'timeoutMs', 'checkVersion'],
+      optional: ['timeoutMs', 'checkVersion'],
     },
   },
   'mobile: isAppInstalled': {

package/lib/ios-fs-helpers.js

@@ -4,7 +4,7 @@ import {fs, tempDir, mkdirp, zip, util, timing} from 'appium/support';
 import path from 'path';
 import log from './logger';
 
-const IO_TIMEOUT_MS = 4 * 60 * 1000;
+export const IO_TIMEOUT_MS = 4 * 60 * 1000;
 // Mobile devices use NAND memory modules for the storage,
 // and the parallelism there is not as performant as on regular SSDs
 const MAX_IO_CHUNK_SIZE = 8;
@@ -17,7 +17,7 @@ const MAX_IO_CHUNK_SIZE = 8;
  * @param {string} remotePath Relative path to the file on the device
  * @returns {Promise<Buffer>} The file content as a buffer
  */
-async function pullFile(afcService, remotePath) {
+export async function pullFile(afcService, remotePath) {
   const stream = await afcService.createReadStream(remotePath, {autoDestroy: true});
   const pullPromise = new B((resolve, reject) => {
     stream.on('close', resolve);
@@ -51,7 +51,7 @@ async function folderExists(folderPath) {
  * @param {string} remoteRootPath Relative path to the folder on the device
  * @returns {Promise<Buffer>} The folder content as a zipped base64-encoded buffer
  */
-async function pullFolder(afcService, remoteRootPath) {
+export async function pullFolder(afcService, remoteRootPath) {
   const tmpFolder = await tempDir.openDir();
   try {
     let localTopItem = null;
@@ -145,35 +145,71 @@ async function remoteMkdirp(afcService, remoteRoot) {
   await afcService.createDirectory(remoteRoot);
 }
 
+/**
+ * @typedef {Object} PushFileOptions
+ * @property {number} [timeoutMs=240000] The maximum count of milliceconds to wait until
+ * file push is completed. Cannot be lower than 60000ms
+ */
+
 /**
  * Pushes a file to a real device
  *
- * @param {any} afcService Apple File Client service instance from
+ * @param {any} afcService afcService Apple File Client service instance from
  * 'appium-ios-device' module
+ * @param {string|Buffer} localPathOrPayload Either full path to the source file
+ * or a buffer payload to be written into the remote destination
  * @param {string} remotePath Relative path to the file on the device. The remote
  * folder structure is created automatically if necessary.
- * @param {string} base64Data Base64-encoded content of the file to be written
+ * @param {PushFileOptions} [opts={}]
  */
-async function pushFile(afcService, remotePath, base64Data) {
+export async function pushFile (afcService, localPathOrPayload, remotePath, opts = {}) {
+  const {
+    timeoutMs = IO_TIMEOUT_MS,
+  } = opts;
+  const timer = new timing.Timer().start();
   await remoteMkdirp(afcService, path.dirname(remotePath));
-  const stream = await afcService.createWriteStream(remotePath, {autoDestroy: true});
+  const source = Buffer.isBuffer(localPathOrPayload)
+    ? localPathOrPayload
+    : fs.createReadStream(localPathOrPayload, {autoClose: true});
+  const writeStream = await afcService.createWriteStream(remotePath, {
+    autoDestroy: true,
+  });
+  writeStream.on('finish', writeStream.destroy);
   let pushError = null;
-  const pushPromise = new B((resolve, reject) => {
-    stream.on('error', (e) => {
-      pushError = e;
-    });
-    stream.on('close', () => {
+  const filePushPromise = new B((resolve, reject) => {
+    writeStream.on('close', () => {
       if (pushError) {
         reject(pushError);
       } else {
         resolve();
       }
     });
-  }).timeout(IO_TIMEOUT_MS);
-  stream.write(Buffer.from(base64Data, 'base64'));
-  stream.end();
-  await pushPromise;
-}
+    const onStreamError = (e) => {
+      if (!Buffer.isBuffer(source)) {
+        source.unpipe(writeStream);
+      }
+      log.debug(e);
+      pushError = e;
+    };
+    writeStream.on('error', onStreamError);
+    if (!Buffer.isBuffer(source)) {
+      source.on('error', onStreamError);
+    }
+  });
+  if (Buffer.isBuffer(source)) {
+    writeStream.write(source);
+  } else {
+    source.pipe(writeStream);
+  }
+  await filePushPromise.timeout(Math.max(timeoutMs, 60000));
+  const fileSize = Buffer.isBuffer(localPathOrPayload)
+    ? localPathOrPayload.length
+    : (await fs.stat(localPathOrPayload)).size;
+  log.debug(
+    `Successfully pushed the file payload (${util.toReadableSizeString(fileSize)}) ` +
+    `to the remote location '${remotePath}' in ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`
+  );
+};
 
 /**
  * @typedef {Object} PushFolderOptions
@@ -194,7 +230,7 @@ async function pushFile(afcService, remotePath, base64Data) {
  * will be deleted if already exists.
  * @param {PushFolderOptions} opts
  */
-async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
+export async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
   const {timeoutMs = IO_TIMEOUT_MS, enableParallelPush = false} = opts;
 
   const timer = new timing.Timer().start();
@@ -239,7 +275,7 @@ async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
       `(${util.pluralize('item', foldersToPush.length + 1, true)})`,
   );
 
-  const pushFile = async (relativePath) => {
+  const _pushFile = async (/** @type {string} */ relativePath) => {
     const absoluteSourcePath = path.join(srcRootPath, relativePath);
     const readStream = fs.createReadStream(absoluteSourcePath, {autoClose: true});
     const absoluteDestinationPath = path.join(dstRootPath, relativePath);
@@ -272,7 +308,7 @@ async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
     log.debug(`Proceeding to parallel files push (max ${MAX_IO_CHUNK_SIZE} writers)`);
     const pushPromises = [];
     for (const relativeFilePath of filesToPush) {
-      pushPromises.push(B.resolve(pushFile(relativeFilePath)));
+      pushPromises.push(B.resolve(_pushFile(relativeFilePath)));
       // keep the push queue filled
       if (pushPromises.length >= MAX_IO_CHUNK_SIZE) {
         await B.any(pushPromises);
@@ -290,7 +326,7 @@ async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
   } else {
     log.debug(`Proceeding to serial files push`);
     for (const relativeFilePath of filesToPush) {
-      await pushFile(relativeFilePath);
+      await _pushFile(relativeFilePath);
       const elapsedMs = timer.getDuration().asMilliSeconds;
       if (elapsedMs > timeoutMs) {
         throw new B.TimeoutError(`Timed out after ${elapsedMs} ms`);
@@ -304,5 +340,3 @@ async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
       `within ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
   );
 }
-
-export {pullFile, pullFolder, pushFile, pushFolder};

package/lib/real-device-management.js

@@ -8,7 +8,6 @@ const DEFAULT_APP_INSTALLATION_TIMEOUT_MS = 8 * 60 * 1000;
  * @typedef {Object} InstallOptions
  *
  * @property {boolean} [skipUninstall] Whether to skip app uninstall before installing it
- * @property {'serial'|'parallel'|'ios-deploy'} [strategy='serial'] One of possible install strategies ('serial', 'parallel', 'ios-deploy')
  * @property {number} [timeout=480000] App install timeout
  * @property {boolean} [shouldEnforceUninstall] Whether to enforce the app uninstallation. e.g. fullReset, or enforceAppInstall is true
  */
@@ -29,7 +28,6 @@ export async function installToRealDevice(app, bundleId, opts = {}) {
 
   const {
     skipUninstall,
-    strategy,
     timeout = DEFAULT_APP_INSTALLATION_TIMEOUT_MS,
   } = opts;
 
@@ -37,10 +35,12 @@ export async function installToRealDevice(app, bundleId, opts = {}) {
     this.log.info(`Reset requested. Removing app with id '${bundleId}' from the device`);
     await device.remove(bundleId);
   }
-  this.log.debug(`Installing '${app}' on the device with UUID '${device.udid}'...`);
+  this.log.debug(`Installing '${app}' on the device with UUID '${device.udid}'`);
 
   try {
-    await device.install(app, timeout, strategy);
+    await device.install(app, bundleId, {
+      timeoutMs: timeout,
+    });
     this.log.debug('The app has been installed successfully.');
   } catch (e) {
     // Want to clarify the device's application installation state in this situation.
@@ -61,7 +61,9 @@ export async function installToRealDevice(app, bundleId, opts = {}) {
       `be already cached on the device, probably with a different signature. ` +
       `Will try to remove it and install a new copy. Original error: ${e.message}`);
     await device.remove(bundleId);
-    await device.install(app, timeout, strategy);
+    await device.install(app, bundleId, {
+      timeoutMs: timeout,
+    });
     this.log.debug('The app has been installed after one retrial.');
   }
 }

package/lib/real-device.js

@@ -1,23 +1,16 @@
-import {fs, timing, util} from 'appium/support';
+import {timing, util, fs} from 'appium/support';
 import path from 'path';
 import {services, utilities, INSTRUMENT_CHANNEL} from 'appium-ios-device';
 import B from 'bluebird';
 import defaultLogger from './logger';
 import _ from 'lodash';
-import {exec} from 'teen_process';
-import {extractBundleId, SAFARI_BUNDLE_ID} from './app-utils';
-import {pushFolder} from './ios-fs-helpers';
+import {SAFARI_BUNDLE_ID} from './app-utils';
+import {pushFile, pushFolder, IO_TIMEOUT_MS} from './ios-fs-helpers';
 import { Devicectl } from './devicectl';
 
 const APPLICATION_INSTALLED_NOTIFICATION = 'com.apple.mobile.application_installed';
-const INSTALLATION_STAGING_DIR = 'PublicStaging';
 const APPLICATION_NOTIFICATION_TIMEOUT_MS = 30 * 1000;
-const IOS_DEPLOY = 'ios-deploy';
-const APP_INSTALL_STRATEGY = Object.freeze({
-  SERIAL: 'serial',
-  PARALLEL: 'parallel',
-  IOS_DEPLOY,
-});
+const INSTALLATION_STAGING_DIR = 'PublicStaging';
 
 /**
  * @returns {Promise<string[]>}
@@ -26,6 +19,11 @@ export async function getConnectedDevices() {
   return await utilities.getConnectedDevices();
 }
 
+/**
+ * @typedef {Object} InstallOptions
+ * @param {number} [timeoutMs=240000] Application installation timeout in milliseconds
+ */
+
 /**
  * @typedef {Object} InstallOrUpgradeOptions
  * @property {number} timeout Install/upgrade timeout in milliseconds
@@ -71,82 +69,52 @@ export class RealDevice {
 
   /**
    *
-   * @param {string} app
-   * @param {number} timeout
-   * @param {'ios-deploy'|'serial'|'parallel'|null} strategy
-   * @privateRemarks This really needs type guards built out
+   * @param {string} appPath
+   * @param {string} bundleId
+   * @param {InstallOptions} [opts={}]
    */
-  async install(app, timeout, strategy = null) {
-    if (
-      strategy &&
-      !_.values(APP_INSTALL_STRATEGY).includes(/** @type {any} */ (_.toLower(strategy)))
-    ) {
-      throw new Error(
-        `App installation strategy '${strategy}' is unknown. ` +
-          `Only the following strategies are supported: ${_.values(APP_INSTALL_STRATEGY)}`,
-      );
-    }
-    this.log.debug(
-      `Using '${strategy ?? APP_INSTALL_STRATEGY.SERIAL}' app deployment strategy. ` +
-        `You could change it by providing another value to the 'appInstallStrategy' capability`,
-    );
-
-    const installWithIosDeploy = async () => {
-      try {
-        await fs.which(IOS_DEPLOY);
-      } catch (err) {
-        throw new Error(`'${IOS_DEPLOY}' utility has not been found in PATH. Is it installed?`);
-      }
-      try {
-        await exec(IOS_DEPLOY, ['--id', this.udid, '--bundle', app], {timeout});
-      } catch (err) {
-        throw new Error(err.stderr || err.stdout || err.message);
-      }
-    };
-
+  async install(appPath, bundleId, opts = {}) {
+    const {
+      timeoutMs = IO_TIMEOUT_MS,
+    } = opts;
     const timer = new timing.Timer().start();
-    if (_.toLower(/** @type {'ios-deploy'} */ (strategy)) === APP_INSTALL_STRATEGY.IOS_DEPLOY) {
-      await installWithIosDeploy();
-    } else {
-      const afcService = await services.startAfcService(this.udid);
-      const enableParallelPush = _.toLower(/** @type {'parallel'} */ (strategy)) === APP_INSTALL_STRATEGY.PARALLEL;
-      try {
-        const bundleId = await extractBundleId(app);
-        const bundlePathOnPhone = path.join(INSTALLATION_STAGING_DIR, bundleId);
-        await pushFolder(afcService, app, bundlePathOnPhone, {
-          enableParallelPush,
-          timeoutMs: timeout,
+    const afcService = await services.startAfcService(this.udid);
+    try {
+      let bundlePathOnPhone;
+      if ((await fs.stat(appPath)).isFile()) {
+        // https://github.com/doronz88/pymobiledevice3/blob/6ff5001f5776e03b610363254e82d7fbcad4ef5f/pymobiledevice3/services/installation_proxy.py#L75
+        bundlePathOnPhone = `/${path.basename(appPath)}`;
+        await pushFile(afcService, appPath, bundlePathOnPhone, {
+          timeoutMs,
         });
-        await this.installOrUpgradeApplication(
-          bundlePathOnPhone,
-          {
-            timeout: Math.max(timeout - timer.getDuration().asMilliSeconds, 60000),
-            isUpgrade: await this.isAppInstalled(bundleId),
-          }
-        );
-      } catch (err) {
-        this.log.warn(`Error installing app '${app}': ${err.message}`);
-        if (err instanceof B.TimeoutError) {
-          this.log.info(
-            `Consider increasing the value of 'appPushTimeout' capability (the current value equals to ${timeout}ms)`
-          );
-          if (!enableParallelPush) {
-            this.log.info(`Consider setting the value of 'appInstallStrategy' capability to 'parallel'`);
-          }
-        }
-        this.log.warn(`Falling back to '${IOS_DEPLOY}' usage`);
-        try {
-          await installWithIosDeploy();
-        } catch (err1) {
-          throw new Error(
-            `Could not install '${app}':\n` + `  - ${err.message}\n` + `  - ${err1.message}`,
-          );
+      } else {
+        bundlePathOnPhone = `${INSTALLATION_STAGING_DIR}/${bundleId}`;
+        await pushFolder(afcService, appPath, bundlePathOnPhone, {
+          enableParallelPush: true,
+          timeoutMs,
+        });
+      }
+      await this.installOrUpgradeApplication(
+        bundlePathOnPhone,
+        {
+          timeout: Math.max(timeoutMs - timer.getDuration().asMilliSeconds, 60000),
+          isUpgrade: await this.isAppInstalled(bundleId),
         }
-      } finally {
-        afcService.close();
+      );
+    } catch (err) {
+      this.log.debug(err.stack);
+      let errMessage = `Cannot install the ${bundleId} application`;
+      if (err instanceof B.TimeoutError) {
+        errMessage += `. Consider increasing the value of 'appPushTimeout' capability (the current value equals to ${timeoutMs}ms)`;
       }
+      errMessage += `. Original error: ${err.message}`;
+      throw new Error(errMessage);
+    } finally {
+      afcService.close();
     }
-    this.log.info(`App installation succeeded after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+    this.log.info(
+      `The installation of '${bundleId}' succeeded after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`
+    );
   }
 
   /**
@@ -164,10 +132,16 @@ export class RealDevice {
     const clientOptions = {PackageType: 'Developer'};
     try {
       if (isUpgrade) {
-        this.log.debug(`An upgrade of the existing application is going to be performed. Will timeout in ${timeout} ms`);
+        this.log.debug(
+          `An upgrade of the existing application is going to be performed. ` +
+          `Will timeout in ${timeout.toFixed(0)} ms`
+        );
         await installationService.upgradeApplication(bundlePathOnPhone, clientOptions, timeout);
       } else {
-        this.log.debug(`A new application installation is going to be performed. Will timeout in ${timeout} ms`);
+        this.log.debug(
+          `A new application installation is going to be performed. ` +
+          `Will timeout in ${timeout.toFixed(0)} ms`
+        );
         await installationService.installApplication(bundlePathOnPhone, clientOptions, timeout);
       }
       try {
@@ -187,12 +161,12 @@ export class RealDevice {
 
   /**
    * Alias for {@linkcode install}
-   * @param {string} app
-   * @param {number} timeout
-   * @param {'ios-deploy'|'serial'|'parallel'|null} strategy
+   * @param {string} appPath
+   * @param {string} bundleId
+   * @param {InstallOptions} [opts={}]
    */
-  async installApp(app, timeout, strategy) {
-    return await this.install(app, timeout, strategy);
+  async installApp(appPath, bundleId, opts = {}) {
+    return await this.install(appPath, bundleId, opts);
   }
 
   /**