appium-ios-simulator 8.0.11 → 8.0.13

package/lib/defaults-utils.ts

@@ -1,8 +1,8 @@
 import _ from 'lodash';
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import { exec } from 'teen_process';
+import {DOMParser, XMLSerializer, type Document, type Element} from '@xmldom/xmldom';
+import {exec} from 'teen_process';
 import B from 'bluebird';
-import { log } from './logger';
+import {log} from './logger';
 
 /**
  * Serializes the given value to plist-compatible
@@ -21,19 +21,21 @@ export function toXmlArg(value: any, serialize: boolean = true): string | Elemen
 
   if (_.isPlainObject(value)) {
     xmlDoc = new DOMParser().parseFromString('<dict></dict>', 'text/xml');
+    const documentElement = requireDocumentElement(xmlDoc);
     for (const [subKey, subValue] of _.toPairs(value)) {
       const keyEl = xmlDoc.createElement('key');
       const keyTextEl = xmlDoc.createTextNode(subKey);
       keyEl.appendChild(keyTextEl);
-      xmlDoc.documentElement.appendChild(keyEl);
+      documentElement.appendChild(keyEl);
       const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false) as Element, true);
-      xmlDoc.documentElement.appendChild(subValueEl);
+      documentElement.appendChild(subValueEl);
     }
   } else if (_.isArray(value)) {
     xmlDoc = new DOMParser().parseFromString('<array></array>', 'text/xml');
+    const documentElement = requireDocumentElement(xmlDoc);
     for (const subValue of value) {
       const subValueEl = xmlDoc.importNode(toXmlArg(subValue, false) as Element, true);
-      xmlDoc.documentElement.appendChild(subValueEl);
+      documentElement.appendChild(subValueEl);
     }
   } else if (_.isBoolean(value)) {
     xmlDoc = new DOMParser().parseFromString(value ? '<true/>' : '<false/>', 'text/xml');
@@ -44,17 +46,18 @@ export function toXmlArg(value: any, serialize: boolean = true): string | Elemen
   } else if (_.isString(value)) {
     xmlDoc = new DOMParser().parseFromString(`<string></string>`, 'text/xml');
     const valueTextEl = xmlDoc.createTextNode(value);
-    xmlDoc.documentElement.appendChild(valueTextEl);
+    requireDocumentElement(xmlDoc).appendChild(valueTextEl);
   }
 
   if (!xmlDoc) {
-    throw new TypeError(`The defaults value ${JSON.stringify(value)} cannot be written, ` +
-      `because it is not known how to handle its type`);
+    throw new TypeError(
+      `The defaults value ${JSON.stringify(value)} cannot be written, ` +
+        `because it is not known how to handle its type`,
+    );
   }
 
-  return serialize
-    ? new XMLSerializer().serializeToString(xmlDoc.documentElement)
-    : xmlDoc.documentElement;
+  const documentElement = requireDocumentElement(xmlDoc);
+  return serialize ? new XMLSerializer().serializeToString(documentElement) : documentElement;
 }
 
 /**
@@ -70,7 +73,10 @@ export function toXmlArg(value: any, serialize: boolean = true): string | Elemen
  * @returns Each item in the array
  * is the `defaults write <plist>` command suffix
  */
-export function generateDefaultsCommandArgs(valuesMap: Record<string, any>, replace: boolean = false): string[][] {
+export function generateDefaultsCommandArgs(
+  valuesMap: Record<string, any>,
+  replace: boolean = false,
+): string[][] {
   const resultArgs: string[][] = [];
   for (const [key, value] of _.toPairs(valuesMap)) {
     try {
@@ -119,7 +125,9 @@ export class NSUserDefaults {
       const {stdout} = await exec('plutil', ['-convert', 'json', '-o', '-', this.plist]);
       return JSON.parse(stdout);
     } catch (e: any) {
-      throw new Error(`'${this.plist}' cannot be converted to JSON. Original error: ${e.stderr || e.message}`);
+      throw new Error(
+        `'${this.plist}' cannot be converted to JSON. Original error: ${e.stderr || e.message}`,
+      );
     }
   }
 
@@ -146,8 +154,17 @@ export class NSUserDefaults {
     try {
       await B.all(commandArgs.map((args) => exec('defaults', ['write', this.plist, ...args])));
     } catch (e: any) {
-      throw new Error(`Could not write defaults into '${this.plist}'. Original error: ${e.stderr || e.message}`);
+      throw new Error(
+        `Could not write defaults into '${this.plist}'. Original error: ${e.stderr || e.message}`,
+      );
     }
   }
 }
 
+function requireDocumentElement(xmlDoc: Document): Element {
+  const {documentElement} = xmlDoc;
+  if (!documentElement) {
+    throw new Error('Cannot parse XML document element');
+  }
+  return documentElement;
+}

package/lib/extensions/applications.ts

@@ -1,9 +1,9 @@
 import _ from 'lodash';
 import path from 'node:path';
-import { fs, plist, util } from '@appium/support';
+import {fs, plist, util} from '@appium/support';
 import B from 'bluebird';
-import { waitForCondition } from 'asyncbox';
-import type { CoreSimulator, InteractsWithApps, LaunchAppOptions } from '../types';
+import {waitForCondition} from 'asyncbox';
+import type {CoreSimulator, InteractsWithApps, LaunchAppOptions} from '../types';
 
 type CoreSimulatorWithApps = CoreSimulator & InteractsWithApps;
 
@@ -24,7 +24,7 @@ export async function installApp(this: CoreSimulatorWithApps, app: string): Prom
  */
 export async function getUserInstalledBundleIdsByBundleName(
   this: CoreSimulatorWithApps,
-  bundleName: string
+  bundleName: string,
 ): Promise<string[]> {
   const appsRoot = path.resolve(this.getDir(), 'Containers', 'Bundle', 'Application');
   // glob all Info.plist from simdir/data/Containers/Bundle/Application
@@ -38,25 +38,27 @@ export async function getUserInstalledBundleIdsByBundleName(
 
   const bundleInfoPromises: Promise<any>[] = [];
   for (const infoPlist of infoPlists) {
-    bundleInfoPromises.push((async () => {
-      try {
-        return await plist.parsePlistFile(infoPlist);
-      } catch {
-        return null;
-      }
-    })());
+    bundleInfoPromises.push(
+      (async () => {
+        try {
+          return await plist.parsePlistFile(infoPlist);
+        } catch {
+          return null;
+        }
+      })(),
+    );
   }
   const bundleInfos = (await B.all(bundleInfoPromises)).filter(_.isPlainObject);
   const bundleIds = bundleInfos
-    .filter(({ CFBundleName }) => CFBundleName === bundleName)
-    .map(({ CFBundleIdentifier }) => CFBundleIdentifier);
+    .filter(({CFBundleName}) => CFBundleName === bundleName)
+    .map(({CFBundleIdentifier}) => CFBundleIdentifier);
   if (_.isEmpty(bundleIds)) {
     return [];
   }
 
   this.log.debug(
     `The simulator has ${util.pluralize('bundle', bundleIds.length, true)} which ` +
-    `have '${bundleName}' as their 'CFBundleName': ${JSON.stringify(bundleIds)}`
+      `have '${bundleName}' as their 'CFBundleName': ${JSON.stringify(bundleIds)}`,
   );
   return bundleIds;
 }
@@ -67,7 +69,10 @@ export async function getUserInstalledBundleIdsByBundleName(
  * @param bundleId The bundle id of the application to be checked.
  * @return True if the given application is installed.
  */
-export async function isAppInstalled(this: CoreSimulatorWithApps, bundleId: string): Promise<boolean> {
+export async function isAppInstalled(
+  this: CoreSimulatorWithApps,
+  bundleId: string,
+): Promise<boolean> {
   try {
     const appContainer = await this.simctl.getAppContainer(bundleId);
     if (!appContainer.endsWith('.app')) {
@@ -105,13 +110,10 @@ export async function removeApp(this: CoreSimulatorWithApps, bundleId: string):
 export async function launchApp(
   this: CoreSimulatorWithApps,
   bundleId: string,
-  opts: LaunchAppOptions = {}
+  opts: LaunchAppOptions = {},
 ): Promise<void> {
   await this.simctl.launchApp(bundleId);
-  const {
-    wait = false,
-    timeoutMs = 10000,
-  } = opts;
+  const {wait = false, timeoutMs = 10000} = opts;
   if (!wait) {
     return;
   }
@@ -119,7 +121,7 @@ export async function launchApp(
   try {
     await waitForCondition(async () => await this.isAppRunning(bundleId), {
       waitMs: timeoutMs,
-      intervalMs: 300
+      intervalMs: 300,
     });
   } catch {
     throw new Error(`App '${bundleId}' is not runnning after ${timeoutMs}ms timeout.`);
@@ -140,7 +142,10 @@ export async function terminateApp(this: CoreSimulatorWithApps, bundleId: string
  *
  * @param bundleId The bundle ID of the application to be checked.
  */
-export async function isAppRunning(this: CoreSimulatorWithApps, bundleId: string): Promise<boolean> {
+export async function isAppRunning(
+  this: CoreSimulatorWithApps,
+  bundleId: string,
+): Promise<boolean> {
   return (await this.ps()).some(({name}) => name === bundleId);
 }
 
@@ -158,7 +163,9 @@ export async function scrubApp(this: CoreSimulatorWithApps, bundleId: string): P
     nodir: true,
     absolute: true,
   });
-  this.log.info(`Found ${appFiles.length} ${bundleId} app ${util.pluralize('file', appFiles.length, false)} to scrub`);
+  this.log.info(
+    `Found ${appFiles.length} ${bundleId} app ${util.pluralize('file', appFiles.length, false)} to scrub`,
+  );
   if (_.isEmpty(appFiles)) {
     return;
   }
@@ -168,4 +175,3 @@ export async function scrubApp(this: CoreSimulatorWithApps, bundleId: string): P
   } catch {}
   await B.all(appFiles.map((p) => fs.rimraf(p)));
 }
-

package/lib/extensions/biometric.ts

@@ -1,5 +1,5 @@
 import _ from 'lodash';
-import type { CoreSimulator, SupportsBiometric } from '../types';
+import type {CoreSimulator, SupportsBiometric} from '../types';
 
 type CoreSimulatorWithBiometric = CoreSimulator & SupportsBiometric;
 
@@ -15,10 +15,12 @@ const BIOMETRICS: Record<string, string> = {
 export async function isBiometricEnrolled(this: CoreSimulatorWithBiometric): Promise<boolean> {
   const {stdout} = await this.simctl.spawnProcess([
     'notifyutil',
-    '-g', ENROLLMENT_NOTIFICATION_RECEIVER
+    '-g',
+    ENROLLMENT_NOTIFICATION_RECEIVER,
   ]);
-  const match = (new RegExp(`${_.escapeRegExp(ENROLLMENT_NOTIFICATION_RECEIVER)}\\s+([01])`))
-    .exec(stdout);
+  const match = new RegExp(`${_.escapeRegExp(ENROLLMENT_NOTIFICATION_RECEIVER)}\\s+([01])`).exec(
+    stdout,
+  );
   if (!match) {
     throw new Error(`Cannot parse biometric enrollment state from '${stdout}'`);
   }
@@ -29,18 +31,24 @@ export async function isBiometricEnrolled(this: CoreSimulatorWithBiometric): Pro
 /**
  * @param isEnabled Whether to enable biometric enrollment
  */
-export async function enrollBiometric(this: CoreSimulatorWithBiometric, isEnabled: boolean = true): Promise<void> {
-  this.log.debug(`Setting biometric enrolled state for ${this.udid} Simulator to '${isEnabled ? 'enabled' : 'disabled'}'`);
-  await this.simctl.spawnProcess([
-    'notifyutil',
-    '-s', ENROLLMENT_NOTIFICATION_RECEIVER, isEnabled ? '1' : '0'
-  ]);
+export async function enrollBiometric(
+  this: CoreSimulatorWithBiometric,
+  isEnabled: boolean = true,
+): Promise<void> {
+  this.log.debug(
+    `Setting biometric enrolled state for ${this.udid} Simulator to '${isEnabled ? 'enabled' : 'disabled'}'`,
+  );
   await this.simctl.spawnProcess([
     'notifyutil',
-    '-p', ENROLLMENT_NOTIFICATION_RECEIVER
+    '-s',
+    ENROLLMENT_NOTIFICATION_RECEIVER,
+    isEnabled ? '1' : '0',
   ]);
-  if (await this.isBiometricEnrolled() !== isEnabled) {
-    throw new Error(`Cannot set biometric enrolled state for ${this.udid} Simulator to '${isEnabled ? 'enabled' : 'disabled'}'`);
+  await this.simctl.spawnProcess(['notifyutil', '-p', ENROLLMENT_NOTIFICATION_RECEIVER]);
+  if ((await this.isBiometricEnrolled()) !== isEnabled) {
+    throw new Error(
+      `Cannot set biometric enrolled state for ${this.udid} Simulator to '${isEnabled ? 'enabled' : 'disabled'}'`,
+    );
   }
 }
 
@@ -54,17 +62,14 @@ export async function enrollBiometric(this: CoreSimulatorWithBiometric, isEnable
 export async function sendBiometricMatch(
   this: CoreSimulatorWithBiometric,
   shouldMatch: boolean = true,
-  biometricName: string = 'touchId'
+  biometricName: string = 'touchId',
 ): Promise<void> {
   const domainComponent = toBiometricDomainComponent(biometricName);
   const domain = `com.apple.BiometricKit_Sim.${domainComponent}.${shouldMatch ? '' : 'no'}match`;
-  await this.simctl.spawnProcess([
-    'notifyutil',
-    '-p', domain
-  ]);
+  await this.simctl.spawnProcess(['notifyutil', '-p', domain]);
   this.log.info(
     `Sent notification ${domain} to ${shouldMatch ? 'match' : 'not match'} ${biometricName} biometric ` +
-    `for ${this.udid} Simulator`
+      `for ${this.udid} Simulator`,
   );
 }
 
@@ -74,8 +79,9 @@ export async function sendBiometricMatch(
  */
 export function toBiometricDomainComponent(name: string): string {
   if (!BIOMETRICS[name]) {
-    throw new Error(`'${name}' is not a valid biometric. Use one of: ${JSON.stringify(_.keys(BIOMETRICS))}`);
+    throw new Error(
+      `'${name}' is not a valid biometric. Use one of: ${JSON.stringify(_.keys(BIOMETRICS))}`,
+    );
   }
   return BIOMETRICS[name];
 }
-

package/lib/extensions/geolocation.ts

@@ -1,4 +1,4 @@
-import type { CoreSimulator, SupportsGeolocation } from '../types';
+import type {CoreSimulator, SupportsGeolocation} from '../types';
 
 type CoreSimulatorWithGeolocation = CoreSimulator & SupportsGeolocation;
 
@@ -9,8 +9,11 @@ type CoreSimulatorWithGeolocation = CoreSimulator & SupportsGeolocation;
  * @param longitude The longitude coordinate.
  * @returns True if the geolocation was set successfully.
  */
-export async function setGeolocation(this: CoreSimulatorWithGeolocation, latitude: string | number, longitude: string | number): Promise<boolean> {
+export async function setGeolocation(
+  this: CoreSimulatorWithGeolocation,
+  latitude: string | number,
+  longitude: string | number,
+): Promise<boolean> {
   await this.simctl.setLocation(latitude, longitude);
   return true;
 }
-

package/lib/extensions/keychain.ts

@@ -1,8 +1,8 @@
 import _ from 'lodash';
 import path from 'node:path';
-import { fs, mkdirp, tempDir, util } from '@appium/support';
-import { exec } from 'teen_process';
-import type { CoreSimulator, InteractsWithKeychain } from '../types';
+import {fs, mkdirp, tempDir, util} from '@appium/support';
+import {exec} from 'teen_process';
+import type {CoreSimulator, InteractsWithKeychain} from '../types';
 
 type CoreSimulatorWithKeychain = CoreSimulator & InteractsWithKeychain;
 
@@ -16,20 +16,22 @@ type CoreSimulatorWithKeychain = CoreSimulator & InteractsWithKeychain;
  */
 export async function backupKeychains(this: CoreSimulatorWithKeychain): Promise<boolean> {
   const resetBackupPath = async (newPath: string | null | undefined) => {
-    if (_.isString(this._keychainsBackupPath) && await fs.exists(this._keychainsBackupPath)) {
+    if (_.isString(this._keychainsBackupPath) && (await fs.exists(this._keychainsBackupPath))) {
       await fs.unlink(this._keychainsBackupPath);
     }
     this._keychainsBackupPath = newPath;
   };
 
-  if (!await fs.exists(this.keychainPath) || _.isEmpty(await fs.readdir(this.keychainPath))) {
+  if (!(await fs.exists(this.keychainPath)) || _.isEmpty(await fs.readdir(this.keychainPath))) {
     this.log.info(`There is nothing to backup from '${this.keychainPath}'`);
     await resetBackupPath(null);
     return false;
   }
 
   const dstPath = await tempDir.path({
-    prefix: `keychains_backup_${Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1)}`,
+    prefix: `keychains_backup_${Math.floor((1 + Math.random()) * 0x10000)
+      .toString(16)
+      .substring(1)}`,
     suffix: '.zip',
   });
   const zipArgs = ['-r', dstPath, `${path.basename(this.keychainPath)}${path.sep}`];
@@ -39,7 +41,7 @@ export async function backupKeychains(this: CoreSimulatorWithKeychain): Promise<
   } catch (err: any) {
     throw new Error(
       `Cannot create keychains backup from '${this.keychainPath}'. ` +
-      `Original error: ${err.stderr || err.stdout || err.message}`
+        `Original error: ${err.stderr || err.stdout || err.message}`,
     );
   }
   await resetBackupPath(dstPath);
@@ -60,11 +62,12 @@ export async function backupKeychains(this: CoreSimulatorWithKeychain): Promise<
  */
 export async function restoreKeychains(
   this: CoreSimulatorWithKeychain,
-  excludePatterns: string[] | string = []
+  excludePatterns: string[] | string = [],
 ): Promise<boolean> {
-  if (!_.isString(this._keychainsBackupPath) || !await fs.exists(this._keychainsBackupPath)) {
-    throw new Error(`The keychains backup archive does not exist. ` +
-                    `Are you sure it was created before?`);
+  if (!_.isString(this._keychainsBackupPath) || !(await fs.exists(this._keychainsBackupPath))) {
+    throw new Error(
+      `The keychains backup archive does not exist. ` + `Are you sure it was created before?`,
+    );
   }
 
   let patterns: string[] = [];
@@ -77,7 +80,7 @@ export async function restoreKeychains(
   let plistPath: string | undefined;
   if (isServerRunning) {
     plistPath = path.resolve(await this.getLaunchDaemonsRoot(), 'com.apple.securityd.plist');
-    if (!await fs.exists(plistPath)) {
+    if (!(await fs.exists(plistPath))) {
       throw new Error(`Cannot clear keychains because '${plistPath}' does not exist`);
     }
     await this.simctl.spawnProcess(['launchctl', 'unload', plistPath]);
@@ -90,9 +93,11 @@ export async function restoreKeychains(
       throw new Error('Backup path is not set');
     }
     const unzipArgs = [
-      '-o', backupPath,
-      ...(_.flatMap(patterns.map((x) => ['-x', x]))),
-      '-d', path.dirname(this.keychainPath),
+      '-o',
+      backupPath,
+      ..._.flatMap(patterns.map((x) => ['-x', x])),
+      '-d',
+      path.dirname(this.keychainPath),
     ];
     this.log.debug(`Restoring keychains with '${util.quote(['unzip', ...unzipArgs])}' command`);
     try {
@@ -100,7 +105,7 @@ export async function restoreKeychains(
     } catch (err: any) {
       throw new Error(
         `Cannot restore keychains from '${backupPath}'. ` +
-        `Original error: ${err.stderr || err.stdout || err.message}`
+          `Original error: ${err.stderr || err.stdout || err.message}`,
       );
     }
     await fs.unlink(backupPath);
@@ -121,7 +126,7 @@ export async function restoreKeychains(
  */
 export async function clearKeychains(this: CoreSimulatorWithKeychain): Promise<void> {
   const plistPath = path.resolve(await this.getLaunchDaemonsRoot(), 'com.apple.securityd.plist');
-  if (!await fs.exists(plistPath)) {
+  if (!(await fs.exists(plistPath))) {
     throw new Error(`Cannot clear keychains because '${plistPath}' does not exist`);
   }
   await this.simctl.spawnProcess(['launchctl', 'unload', plistPath]);
@@ -134,4 +139,3 @@ export async function clearKeychains(this: CoreSimulatorWithKeychain): Promise<v
     await this.simctl.spawnProcess(['launchctl', 'load', plistPath]);
   }
 }
-

package/lib/extensions/misc.ts

@@ -1,5 +1,5 @@
-import type { CoreSimulator, HasMiscFeatures, CertificateOptions } from '../types';
-import type { StringRecord } from '@appium/types';
+import type {CoreSimulator, HasMiscFeatures, CertificateOptions} from '../types';
+import type {StringRecord} from '@appium/types';
 
 type CoreSimulatorWithMiscFeatures = CoreSimulator & HasMiscFeatures;
 
@@ -8,10 +8,7 @@ type CoreSimulatorWithMiscFeatures = CoreSimulator & HasMiscFeatures;
  */
 export async function shake(this: CoreSimulatorWithMiscFeatures): Promise<void> {
   this.log.info(`Performing shake gesture on ${this.udid} Simulator`);
-  await this.simctl.spawnProcess([
-    'notifyutil',
-    '-p', 'com.apple.UIKit.SimulatorShake'
-  ]);
+  await this.simctl.spawnProcess(['notifyutil', '-p', 'com.apple.UIKit.SimulatorShake']);
 }
 
 /**
@@ -25,11 +22,11 @@ export async function shake(this: CoreSimulatorWithMiscFeatures): Promise<void>
  * @returns True if the certificate was added successfully.
  */
 export async function addCertificate(
-  this: CoreSimulatorWithMiscFeatures, payload: string, opts: CertificateOptions = {}
+  this: CoreSimulatorWithMiscFeatures,
+  payload: string,
+  opts: CertificateOptions = {},
 ): Promise<boolean> {
-  const {
-    isRoot = true,
-  } = opts;
+  const {isRoot = true} = opts;
   const methodName = isRoot ? 'addRootCertificate' : 'addCertificate';
   await this.simctl[methodName](payload, {raw: true});
   return true;
@@ -53,8 +50,8 @@ export async function addCertificate(
  * }
  */
 export async function pushNotification(
-  this: CoreSimulatorWithMiscFeatures, payload: StringRecord
+  this: CoreSimulatorWithMiscFeatures,
+  payload: StringRecord,
 ): Promise<void> {
   await this.simctl.pushNotification(payload);
 }
-