appium-xcode 4.0.5 → 5.0.1

package/lib/helpers.js

@@ -0,0 +1,72 @@
+import _ from 'lodash';
+import B from 'bluebird';
+import { exec } from 'teen_process';
+import { fs, plist } from '@appium/support';
+import path from 'path';
+
+export const XCRUN_TIMEOUT = 15000;
+
+/**
+ * Executes 'xcrun' command line utility
+ *
+ * @param {string[]} args xcrun arguments
+ * @param {number} timeout [15000] The maximum number of milliseconds to wait until xcrun exists
+ * @returns {Promise<import("teen_process").ExecResult>} The result of xcrun execution
+ * @throws {Error} If xcrun returned non-zero exit code or timed out
+ */
+export async function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {
+  try {
+    return await exec('xcrun', args, {timeout});
+  } catch (err) {
+    // the true error can be hidden within the stderr
+    if (err.stderr) {
+      err.message = `${err.message}: ${err.stderr}`;
+    }
+
+    throw err;
+  }
+}
+
+/**
+ * Uses macOS Spotlight service to detect where the given app is installed
+ *
+ * @param {string} bundleId Bundle identifier of the target app
+ * @returns {Promise<string[]>} Full paths to where the app with the given bundle id is present.
+ */
+export async function findAppPaths (bundleId) {
+  let stdout;
+  try {
+    ({stdout} = await exec('/usr/bin/mdfind', [
+      `kMDItemCFBundleIdentifier=${bundleId}`
+    ]));
+  } catch (e) {
+    return [];
+  }
+
+  const matchedPaths = _.trim(stdout)
+    .split('\n')
+    .map(_.trim)
+    .filter(Boolean);
+  if (_.isEmpty(matchedPaths)) {
+    return [];
+  }
+  const results = matchedPaths.map((p) => (async () => {
+    if (await fs.exists(p)) {
+      return p;
+    }
+  })());
+  return (await B.all(results)).filter(Boolean);
+}
+
+/**
+ * Finds and retrieves the content of the Xcode's Info.plist file
+ *
+ * @param {string} developerRoot Full path to the Contents/Developer folder under Xcode.app root
+ * @returns {Promise<object>} All plist entries as an object or an empty object if no plist was found
+ */
+export async function readXcodePlist (developerRoot) {
+  const plistPath = path.resolve(developerRoot, '..', 'Info.plist');
+  return await fs.exists(plistPath)
+    ? await plist.parsePlistFile(plistPath)
+    : {};
+}

package/lib/xcode.js

@@ -1,141 +1,133 @@
-import { util, fs, plist, logger } from '@appium/support';
+import { fs, logger } from '@appium/support';
 import path from 'path';
 import { retry } from 'asyncbox';
 import _ from 'lodash';
-import { parse as parsePlistData } from 'plist';
 import { exec } from 'teen_process';
 import semver from 'semver';
+import {
+  runXcrunCommand, findAppPaths, XCRUN_TIMEOUT, readXcodePlist
+} from './helpers';
 
-
-const env = process.env;
-
-const XCRUN_TIMEOUT = 15000;
-const XCODE_SUBDIR = '/Contents/Developer';
-const DEFAULT_NUMBER_OF_RETRIES = 3;
+const DEFAULT_NUMBER_OF_RETRIES = 2;
+const XCODE_BUNDLE_ID = 'com.apple.dt.Xcode';
 
 const log = logger.getLogger('Xcode');
 
+/**
+ * Retrieves the full path to Xcode Developer subfolder via xcode-select
+ *
+ * @param {number} timeout The maximum timeout for xcode-select execution
+ * @returns {Promise<string>} Full path to Xcode Developer subfolder
+ * @throws {Error} If it is not possible to retrieve a proper path
+ */
+async function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {
+  const generateErrorMessage = async (prefix) => {
+    const xcodePaths = await findAppPaths(XCODE_BUNDLE_ID);
+    if (_.isEmpty(xcodePaths)) {
+      return `${prefix}. Consider installing Xcode to address this issue.`;
+    }
 
-function hasExpectedSubDir (path) {
-  return path.substring(path.length - XCODE_SUBDIR.length) === XCODE_SUBDIR;
-}
+    const proposals = xcodePaths.map((p) => `    sudo xcode-select -s "${path.join(p, 'Contents', 'Developer')}"`);
+    return `${prefix}. ` +
+      `Consider running${proposals.length > 1 ? ' any of' : ''}:\n${'\n'.join(proposals)}\nto address this issue.`;
+  };
 
-async function runXcrunCommand (args, timeout = XCRUN_TIMEOUT) {
+  let stdout;
   try {
-    const res = await exec('xcrun', args, {timeout});
-    if (_.isUndefined(res)) {
-      throw new Error(`Nothing returned from trying to run 'xcrun ${args.join(' ')}'`);
-    }
-    return res;
-  } catch (err) {
-    // the true error can be hidden within the stderr
-    if (err.stderr) {
-      err.message = `${err.message}: ${err.stderr}`;
-    }
-
-    throw err;
+    ({stdout} = await exec('xcode-select', ['--print-path'], {timeout}));
+  } catch (e) {
+    log.errorAndThrow(`Cannot determine the path to Xcode by running 'xcode-select -p' command. ` +
+      `Original error: ${e.stderr || e.message}`);
   }
-}
-
-async function getPathFromSymlink (failMessage) {
-  // Node's invocation of xcode-select sometimes flakes and returns an empty string.
-  // Not clear why. As a workaround, Appium can reliably deduce the version in use by checking
-  // the locations xcode-select uses to store the selected version's path. This should be 100%
-  // reliable so long as the link locations remain the same. However, since we're relying on
-  // hardcoded paths, this approach will break the next time Apple changes the symlink location.
-  log.warn(`Finding XcodePath by symlink because ${failMessage}`);
-
-  const symlinkPath = '/var/db/xcode_select_link';
-  const legacySymlinkPath = '/usr/share/xcode-select/xcode_dir_link'; //  Xcode < 5.x
-  let xcodePath = null;
-
-  // xcode-select allows users to override its settings with the DEVELOPER_DIR env var,
-  // so check that first
-  if (util.hasContent(env.DEVELOPER_DIR)) {
-    const customPath = hasExpectedSubDir(env.DEVELOPER_DIR)
-      ? env.DEVELOPER_DIR
-      : env.DEVELOPER_DIR + XCODE_SUBDIR;
-
-    if (await fs.exists(customPath)) {
-      xcodePath = customPath;
-    } else {
-      let mesg = `Could not find path to Xcode, environment variable ` +
-                 `DEVELOPER_DIR set to: ${env.DEVELOPER_DIR} ` +
-                 `but no Xcode found`;
-      log.warn(mesg);
-      throw new Error(mesg);
-    }
-  } else if (await fs.exists(symlinkPath)) {
-    xcodePath = await fs.readlink(symlinkPath);
-  } else if (await fs.exists(legacySymlinkPath)) {
-    xcodePath = await fs.readlink(legacySymlinkPath);
+  // trim and remove trailing slash
+  const developerRoot = stdout.replace(/\/$/, '').trim();
+  if (!developerRoot) {
+    log.errorAndThrow(await generateErrorMessage(`'xcode-select -p' returned an empty string`));
   }
-
-  if (xcodePath) {
-    return xcodePath.replace(new RegExp('/$'), '').trim();
+  // xcode-select might also return a path to command line tools
+  const {CFBundleIdentifier} = await readXcodePlist(developerRoot);
+  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {
+    return developerRoot;
   }
 
-  // We should only get here is we failed to capture xcode-select's stdout and our
-  // other checks failed. Either Apple has moved the symlink to a new location or the user
-  // is not using the default install. 99.999% chance it's the latter, so issue a warning
-  // should we ever hit the edge case.
-  let msg = `Could not find path to Xcode by symlinks located in ${symlinkPath}, or ${legacySymlinkPath}`;
-  log.warn(msg);
-  throw new Error(msg);
+  log.errorAndThrow(await generateErrorMessage(`'${developerRoot}' is not a valid Xcode path`));
 }
 
-async function getPathFromXcodeSelect (timeout = XCRUN_TIMEOUT) {
-  let {stdout} = await exec('xcode-select', ['--print-path'], {timeout});
-
-  // trim and remove trailing slash
-  const xcodeFolderPath = stdout.replace(/\/$/, '').trim();
-
-  if (!util.hasContent(xcodeFolderPath)) {
-    log.errorAndThrow('xcode-select returned an empty string');
+/**
+ * Retrieves the full path to Xcode Developer subfolder via DEVELOPER_DIR environment variable
+ *
+ * @returns {Promise<string>} Full path to Xcode Developer subfolder
+ * @throws {Error} If it is not possible to retrieve a proper path
+ */
+async function getPathFromDeveloperDir () {
+  const developerRoot = process.env.DEVELOPER_DIR;
+  const {CFBundleIdentifier} = await readXcodePlist(developerRoot);
+  if (CFBundleIdentifier === XCODE_BUNDLE_ID) {
+    return developerRoot;
   }
 
-  if (await fs.exists(xcodeFolderPath)) {
-    return xcodeFolderPath;
-  } else {
-    const msg = `xcode-select could not find xcode. Path '${xcodeFolderPath}' does not exist.`;
-    log.errorAndThrow(msg);
-  }
+  log.errorAndThrow(`The path to Xcode Developer dir '${developerRoot}' provided in DEVELOPER_DIR ` +
+    `environment variable is not a valid path`);
 }
 
+/**
+ * Retrieves the full path to Xcode Developer subfolder.
+ * If DEVELOPER_DIR environment variable is provided then its value has a priority.
+ *
+ * @property {number} timeout [15000] The maximum timeout for xcode-select execution
+ * @returns {string} Full path to Xcode Developer subfolder
+ * @throws {Error} If there was an error while retrieving the path.
+ */
 const getPath = _.memoize(function getPath (timeout = XCRUN_TIMEOUT) {
-  // first we try using xcode-select to find the path
-  // then we try using the symlinks that Apple has by default
-  return (async () => {
-    try {
-      return await getPathFromXcodeSelect(timeout);
-    } catch (e) {
-      return await getPathFromSymlink(e.message);
-    }
-  })();
+  return process.env.DEVELOPER_DIR ? getPathFromDeveloperDir() : getPathFromXcodeSelect(timeout);
 });
 
-
+/**
+ * Retrieves Xcode version
+ *
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands.
+ * @returns {Promise<import("semver").SemVer | null>} Xcode version
+ * @throws {Error} If there was a failure while retrieving the version
+ */
 async function getVersionWithoutRetry (timeout = XCRUN_TIMEOUT) {
-  const xcodePath = await getPath(timeout);
-
+  const developerPath = await getPath(timeout);
   // we want to read the CFBundleShortVersionString from Xcode's plist.
-  // It should be in /[root]/XCode.app/Contents/
-  const plistPath = path.resolve(xcodePath, '..', 'Info.plist');
-
-  if (!await fs.exists(plistPath)) {
-    throw new Error(`Could not get Xcode version. ${plistPath} does not exist on disk.`);
-  }
-
-  const version = await plist.parsePlistFile(plistPath);
-  return semver.coerce(version.CFBundleShortVersionString);
+  const {CFBundleShortVersionString} = await readXcodePlist(developerPath);
+  return semver.coerce(CFBundleShortVersionString);
 }
 
+/**
+ * Retrieves Xcode version or the cached one if called more than once
+ *
+ * @param {number} retries [2] How many retries to apply for version retrieval
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @returns {Promise<import("semver").SemVer | null>} Xcode version
+ * @throws {Error} If there was a failure while retrieving the version
+ */
 const getVersionMemoized = _.memoize(
   function getVersionMemoized (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getVersionWithoutRetry, timeout);
   }
 );
 
+/**
+ * @typedef {Object} XcodeVersion
+ * @property {string} versionString Xcode version as a string
+ * @property {number} versionFloat Xcode version as a float number
+ * @property {number} major Major number of Xcode version
+ * @property {number} minor Minor number of Xcode version
+ * @property {number?} patch Patch number of Xcode version (if exists)
+ */
+
+/**
+ * Retrieves Xcode version
+ *
+ * @param {boolean} parse [false] Whether to parse the version to a XcodeVersion version
+ * @param {number} retries [2] How many retries to apply for getting the version number
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @returns {Promise<XcodeVersion | string>} Xcode version depending on the value of `parse` flag
+ * @throws {Error} If there was a failure while retrieving the version
+ */
 async function getVersion (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
   const version = await getVersionMemoized(retries, timeout);
   // xcode version strings are not exactly semver string: patch versions of 0
@@ -157,37 +149,11 @@ async function getVersion (parse = false, retries = DEFAULT_NUMBER_OF_RETRIES, t
   };
 }
 
-async function getCommandLineToolsVersion () {
-  // there are a number of different ways that the CLI tools version has been
-  // represented. Try them from most reliable to least, falling down the chain
-  const getVersionFunctions = [
-    async () => {
-      let pkg = (await exec('pkgutil', ['--pkgs=com.apple.pkg.DevSDK_.*'])).stdout;
-      return (await exec('pkgutil', [`--pkg-info=${pkg.trim()}`])).stdout;
-    },
-    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.CLTools_Executables`])).stdout,
-    async () => (await exec('pkgutil', [`--pkg-info=com.apple.pkg.DeveloperToolsCLI`])).stdout,
-  ];
-  let stdout;
-  for (let getVersion of getVersionFunctions) {
-    try {
-      stdout = await getVersion();
-      break;
-    } catch (ign) {
-      stdout = '';
-    }
-  }
-
-  // stdout should have a line like `version: 8.0.0.0.1.1472435881`
-  let match = /^version: (.+)$/m.exec(stdout); // https://regex101.com/r/HV3x4d/1
-  return match ? match[1] : undefined;
-}
-
 /**
  * Check https://trac.macports.org/wiki/XcodeVersionInfo
  * to see the actual mapping between clang and other components.
  *
- * @returns {?string} The actual Clang version in x.x.x.x or x.x.x format,
+ * @returns {Promise<string?>} The actual Clang version in x.x.x.x or x.x.x format,
  * which is supplied with Command Line Tools. `null` is returned
  * if CLT are not installed.
  */
@@ -208,170 +174,71 @@ async function getClangVersion () {
   return match[1];
 }
 
-async function getAutomationTraceTemplatePathWithoutRetry (timeout = XCRUN_TIMEOUT) {
-  const xcodePath = await getPath(timeout);
-
-  // for ios 8 and up, the file extension for AutiomationInstrument changed.
-  // rather than waste time getting the iOSSDKVersion, just get both paths and see which one exists
-  const extensions = ['xrplugin', 'bundle'];
-  const pathPrefix = path.resolve(xcodePath, '../Applications/Instruments.app/Contents/PlugIns');
-  const pathSuffix = 'Contents/Resources/Automation.tracetemplate';
-  let automationTraceTemplatePaths = [
-    path.resolve(pathPrefix, `AutomationInstrument.${extensions[0]}`, pathSuffix),
-    path.resolve(pathPrefix, `AutomationInstrument.${extensions[1]}`, pathSuffix)
-  ];
-
-  if (await fs.exists(automationTraceTemplatePaths[0])) {
-    return automationTraceTemplatePaths[0];
-  }
-
-  if (await fs.exists(automationTraceTemplatePaths[1])) {
-    return automationTraceTemplatePaths[1];
-  }
-
-  const msg = 'Could not find Automation.tracetemplate in any of the following' +
-              `locations ${automationTraceTemplatePaths.toString()}`;
-  log.error(msg);
-  throw new Error(msg);
-
-}
-
-const getAutomationTraceTemplatePath = _.memoize(
-  function getAutomationTraceTemplatePath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-    return retry(retries, getAutomationTraceTemplatePathWithoutRetry, timeout);
-  }
-);
-
+/**
+ * Retrieves the maximum version of iOS SDK supported by the installed Xcode
+ *
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @returns {string} The SDK version
+ * @throws {Error} If the SDK version number cannot be determined
+ */
 async function getMaxIOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {
-  const version = await getVersion(false, DEFAULT_NUMBER_OF_RETRIES, timeout);
-  if (version[0] === '4') {
-    return '6.1';
-  }
-
   const args = ['--sdk', 'iphonesimulator', '--show-sdk-version'];
   const {stdout} = await runXcrunCommand(args, timeout);
-
   const sdkVersion = stdout.trim();
   const match = /\d.\d/.exec(stdout);
-
   if (!match) {
     throw new Error(`xcrun returned a non-numeric iOS SDK version: '${sdkVersion}'`);
   }
-
   return sdkVersion;
 }
 
-async function getMaxIOSSDKFromXcodeVersion (timeout = XCRUN_TIMEOUT) {
-  const version = await getVersion(true, DEFAULT_NUMBER_OF_RETRIES, timeout);
-  // as of now, the iOS version associated with an Xcode version is
-  // just the Xcode version + 2
-  return `${version.major + 2}.${version.minor}`;
-}
-
+/**
+ * Retrieves the maximum version of iOS SDK supported by the installed Xcode
+ *
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @param {number} retries [2] The maximum number of retries
+ * @returns {string} The SDK version
+ * @throws {Error} If the SDK version number cannot be determined
+ */
 const getMaxIOSSDK = _.memoize(
   function getMaxIOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-    try {
-      return retry(retries, getMaxIOSSDKWithoutRetry, timeout);
-    } catch (err) {
-      log.warn(`Unable to retrieve maximum iOS version: ${err.message}`);
-      log.warn('Guessing from Xcode version');
-      return getMaxIOSSDKFromXcodeVersion(timeout);
-    }
+    return retry(retries, getMaxIOSSDKWithoutRetry, timeout);
   }
 );
 
+/**
+ * Retrieves the maximum version of tvOS SDK supported by the installed Xcode
+ *
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @returns {string} The SDK version
+ * @throws {Error} If the SDK version number cannot be determined
+ */
 async function getMaxTVOSSDKWithoutRetry (timeout = XCRUN_TIMEOUT) {
   const args = ['--sdk', 'appletvsimulator', '--show-sdk-version'];
   const {stdout} = await runXcrunCommand(args, timeout);
-
   const sdkVersion = stdout.trim();
-
   if (isNaN(parseFloat(sdkVersion))) {
     throw new Error(`xcrun returned a non-numeric tvOS SDK version: '${sdkVersion}'`);
   }
-
   return sdkVersion;
 }
 
+/**
+ * Retrieves the maximum version of tvOS SDK supported by the installed Xcode
+ *
+ * @param {number} timeout [15000] Timeout of milliseconds to wait for terminal commands
+ * @param {number} retries [2] The maximum number of retries
+ * @returns {string} The SDK version
+ * @throws {Error} If the SDK version number cannot be determined
+ */
 const getMaxTVOSSDK = _.memoize(
   function getMaxTVOSSDK (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
     return retry(retries, getMaxTVOSSDKWithoutRetry, timeout);
   }
 );
 
-async function getConnectedDevices (timeout = XCRUN_TIMEOUT) {
-  const cmd = '/usr/sbin/system_profiler';
-  const args = ['-xml', 'SPUSBDataType'];
-  let {stdout} = await exec(cmd, args, {timeout});
-  let plistContent = parsePlistData(stdout);
-
-  let devicesFound = [];
-  let entriesToSearch = [plistContent[0]];
-  while (entriesToSearch.length > 0) {
-    let currentEntry = entriesToSearch.pop();
-    if (currentEntry instanceof Array) {
-      entriesToSearch = entriesToSearch.concat(currentEntry);
-    } else if ((currentEntry._name &&
-                currentEntry._name.substring(0, 4) === 'iPad') ||
-               (currentEntry._name &&
-                currentEntry._name.substring(0, 6) === 'iPhone') ||
-               (currentEntry._name && _.includes(currentEntry._name, 'Apple TV'))) {
-      let deviceInfo = {
-        name: currentEntry._name,
-        udid: currentEntry.serial_num,
-        productId: currentEntry.product_id,
-        deviceVersion: currentEntry.bcd_device
-      };
-      devicesFound.push(deviceInfo);
-    } else if (currentEntry._items) {
-      entriesToSearch = entriesToSearch.concat(currentEntry._items);
-    }
-  }
-  return devicesFound;
-}
-
-async function getInstrumentsPathWithoutRetry (timeout = XCRUN_TIMEOUT) {
-  const args = ['-find', 'instruments'];
-  let {stdout} = await runXcrunCommand(args, timeout);
-
-  if (!stdout) {
-    stdout = '';
-  }
-
-  let instrumentsPath = stdout.trim();
-
-  if (!instrumentsPath) {
-    throw new Error(`Could not find path to instruments binary using 'xcrun ${args.join(' ')}'`);
-  }
-
-  return instrumentsPath;
-}
-
-const getInstrumentsPath = _.memoize(
-  function getInstrumentsPath (retries = DEFAULT_NUMBER_OF_RETRIES, timeout = XCRUN_TIMEOUT) {
-    return retry(retries, getInstrumentsPathWithoutRetry, timeout);
-  }
-);
-
-function clearInternalCache () {
-
-  // memoized functions
-  const memoized = [
-    getPath, getVersionMemoized, getAutomationTraceTemplatePath, getMaxIOSSDK,
-    getMaxTVOSSDK, getInstrumentsPath,
-  ];
-
-  memoized.forEach((f) => {
-    if (f.cache) {
-      f.cache = new _.memoize.Cache();
-    }
-  });
-}
-
 export {
-  getPath, getVersion, getAutomationTraceTemplatePath, getMaxIOSSDK,
-  getAutomationTraceTemplatePathWithoutRetry, getMaxIOSSDKWithoutRetry,
-  getConnectedDevices, clearInternalCache, getInstrumentsPath,
-  getCommandLineToolsVersion, getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry,
-  getClangVersion,
+  getPath, getVersion, getMaxIOSSDK, getMaxIOSSDKWithoutRetry,
+  getMaxTVOSSDK, getMaxTVOSSDKWithoutRetry, getClangVersion,
+  getPathFromDeveloperDir, getPathFromXcodeSelect,
 };

package/package.json

@@ -6,7 +6,7 @@
     "ios",
     "xcode"
   ],
-  "version": "4.0.5",
+  "version": "5.0.1",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -90,6 +90,6 @@
     "mocha": "^10.0.0",
     "pre-commit": "^1.1.3",
     "prettier": "^2.7.1",
-    "semantic-release": "^19.0.2"
+    "semantic-release": "^20.0.2"
   }
 }