appium-xcuitest-driver 3.59.1 → 3.59.2

package/README.md

@@ -28,12 +28,11 @@ On top of standard Appium requirements XCUITest driver also expects the followin
 - Web views must be debuggable in order to test them. If it is not possible to connect to your web view(s) using [Safari remote debugger](https://appletoolbox.com/use-web-inspector-debug-mobile-safari/) then XCUITest won't be able to connect to them as well.
 - Since version 3.33.0 (included into Appium 1.20.0+) of XCUITest driver the [Carthage](https://github.com/Carthage/Carthage) dependency *is not needed anymore*. Prior to that version it was required and could be installed using [brew](https://brew.sh/): `brew install carthage`.
 
-
 ## Optional dependencies
 
 - [xcpretty](https://github.com/supermarin/xcpretty) tool could be used to make Xcode output easier to read. It could be installed using `gem install xcpretty` command.
 - For test video recording we use [ffmpeg](https://ffmpeg.org/). It could be installed using [brew](https://brew.sh/): `brew install ffmpeg`
-- Facebook's [IDB](https://github.com/facebook/idb) tool could be used to improve some real device/Simulator interactions
+- [IDB](https://github.com/facebook/idb), [go-ios](https://github.com/danielpaulus/go-ios) and [tidevice](https://github.com/alibaba/taobao-iphone-device) could be used to improve some real device/Simulator interactions
 - [WIX AppleSimulatorUtils](https://github.com/wix/AppleSimulatorUtils) could be used to improve some Simulator interactions
 
 
@@ -53,7 +52,9 @@ See [real device configuration documentation](docs/real-device-config.md).
 
 ### Known problems
 
-After many failures on real devices it could transition to a state where connections are no longer being accepted. To possibly remedy this issue reboot the device. Read https://github.com/facebook/WebDriverAgent/issues/507 for more details.
+- After many failures on real devices it could transition to a state where connections are no longer being accepted. To possibly remedy this issue reboot the device. Read https://github.com/facebook/WebDriverAgent/issues/507 for more details.
+- iPhone/iPad real devices show overlay, which has `Automation Running Hold both volume buttons to stop` text, since iOS/iPadOS 15. This is a known limitation of XCTest framework. This limitation does not affect screenshooting APIs though (e.g. the overlay is not visible on taken screenshots).
+- iPhone/iPad real devices [require passcode or touch id](https://github.com/appium/appium/issues/15898#issuecomment-927340411) when they start a XCTest session since iOS/iPadOS 15. Disabling passcode/touch id in the device preference allows to workaround the behaviour above.
 
 #### Weird state
 

package/build/lib/ios-fs-helpers.js

@@ -39,33 +39,62 @@ async function pullFile(afcService, remotePath) {
   return Buffer.concat(buffers);
 }
 
+async function folderExists(folderPath) {
+  try {
+    return (await _appiumSupport.fs.stat(folderPath)).isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
 async function pullFolder(afcService, remoteRootPath) {
   const tmpFolder = await _appiumSupport.tempDir.openDir();
 
   try {
+    let localTopItem = null;
+    let countFilesSuccess = 0;
+    let countFilesFail = 0;
+    let countFolders = 0;
     const pullPromises = [];
-    await afcService.walkDir(remoteRootPath, true, async (itemPath, isDir) => {
-      const pathOnServer = _path.default.join(tmpFolder, itemPath);
+    await afcService.walkDir(remoteRootPath, true, async (remotePath, isDir) => {
+      const localPath = _path.default.join(tmpFolder, remotePath);
+
+      const dirname = isDir ? localPath : _path.default.dirname(localPath);
+
+      if (!(await folderExists(dirname))) {
+        await (0, _appiumSupport.mkdirp)(dirname);
+      }
+
+      if (!localTopItem || localPath.split(_path.default.sep).length < localTopItem.split(_path.default.sep).length) {
+        localTopItem = localPath;
+      }
 
       if (isDir) {
-        await (0, _appiumSupport.mkdirp)(pathOnServer);
+        ++countFolders;
         return;
       }
 
-      const readStream = await afcService.createReadStream(itemPath, {
+      const readStream = await afcService.createReadStream(remotePath, {
         autoDestroy: true
       });
 
-      const writeStream = _appiumSupport.fs.createWriteStream(pathOnServer, {
+      const writeStream = _appiumSupport.fs.createWriteStream(localPath, {
         autoClose: true
       });
 
-      pullPromises.push(new _bluebird.default((resolve, reject) => {
-        writeStream.on('close', resolve);
+      pullPromises.push(new _bluebird.default(resolve => {
+        writeStream.on('close', () => {
+          ++countFilesSuccess;
+          resolve();
+        });
 
         const onStreamingError = e => {
           readStream.unpipe(writeStream);
-          reject(e);
+
+          _logger.default.warn(`Cannot pull '${remotePath}' to '${localPath}'. ` + `The file will be skipped. Original error: ${e.message}`);
+
+          ++countFilesFail;
+          resolve();
         };
 
         writeStream.on('error', onStreamingError);
@@ -79,8 +108,14 @@ async function pullFolder(afcService, remoteRootPath) {
 
       _lodash.default.remove(pullPromises, p => p.isFulfilled());
     });
-    await _bluebird.default.all(pullPromises);
-    return await _appiumSupport.zip.toInMemoryZip(tmpFolder, {
+
+    if (!_lodash.default.isEmpty(pullPromises)) {
+      await _bluebird.default.all(pullPromises);
+    }
+
+    _logger.default.info(`Pulled ${_appiumSupport.util.pluralize('file', countFilesSuccess, true)} out of ` + `${countFilesSuccess + countFilesFail} and ${_appiumSupport.util.pluralize('folder', countFolders, true)} ` + `from '${remoteRootPath}'`);
+
+    return await _appiumSupport.zip.toInMemoryZip(localTopItem ? _path.default.dirname(localTopItem) : tmpFolder, {
       encodeToBase64: true
     });
   } finally {
@@ -232,4 +267,4 @@ async function pushFolder(afcService, srcRootPath, dstRootPath, opts = {}) {
 }require('source-map-support').install();
 
 
-//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/ios-fs-helpers.js"],"names":["IO_TIMEOUT_MS","MAX_IO_CHUNK_SIZE","pullFile","afcService","remotePath","stream","createReadStream","autoDestroy","pullPromise","B","resolve","reject","on","timeout","buffers","data","push","Buffer","concat","pullFolder","remoteRootPath","tmpFolder","tempDir","openDir","pullPromises","walkDir","itemPath","isDir","pathOnServer","path","join","readStream","writeStream","fs","createWriteStream","autoClose","onStreamingError","e","unpipe","pipe","length","any","_","remove","p","isFulfilled","all","zip","toInMemoryZip","encodeToBase64","rimraf","remoteMkdirp","remoteRoot","listDirectory","dirname","createDirectory","pushFile","base64Data","pushError","pushPromise","write","from","end","pushFolder","srcRootPath","dstRootPath","opts","timeoutMs","enableParallelPush","timer","timing","Timer","start","itemsToPush","glob","cwd","nosort","mark","log","debug","foldersToPush","filesToPush","reduce","acc","x","endsWith","sep","util","pluralize","deleteDirectory","ign","foldersToPushByHierarchy","sort","a","b","split","relativeFolderPath","absoluteFolderPath","trimEnd","relativePath","absoluteSourcePath","absoluteDestinationPath","destroy","filePushPromise","onStreamError","pushPromises","relativeFilePath","shuffle","isEmpty","getDuration","asMilliSeconds","toFixed"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport B from 'bluebird';\nimport { fs, tempDir, mkdirp, zip, util, timing } from 'appium-support';\nimport path from 'path';\nimport log from './logger';\n\nconst IO_TIMEOUT_MS = 4 * 60 * 1000;\n// Mobile devices use NAND memory modules for the storage,\n// and the parallelism there is not as performant as on regular SSDs\nconst MAX_IO_CHUNK_SIZE = 8;\n\n/**\n * Retrieve a file from a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remotePath Relative path to the file on the device\n * @returns {Buffer} The file content as a buffer\n */\nasync function pullFile (afcService, remotePath) {\n  const stream = await afcService.createReadStream(remotePath, { autoDestroy: true });\n  const pullPromise = new B((resolve, reject) => {\n    stream.on('close', resolve);\n    stream.on('error', reject);\n  }).timeout(IO_TIMEOUT_MS);\n  const buffers = [];\n  stream.on('data', (data) => buffers.push(data));\n  await pullPromise;\n  return Buffer.concat(buffers);\n}\n\n/**\n * Retrieve a folder from a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remoteRootPath Relative path to the folder on the device\n * @returns {Buffer} The folder content as a zipped base64-encoded buffer\n */\nasync function pullFolder (afcService, remoteRootPath) {\n  const tmpFolder = await tempDir.openDir();\n  try {\n    const pullPromises = [];\n    await afcService.walkDir(remoteRootPath, true, async (itemPath, isDir) => {\n      const pathOnServer = path.join(tmpFolder, itemPath);\n      if (isDir) {\n        await mkdirp(pathOnServer);\n        return;\n      }\n\n      const readStream = await afcService.createReadStream(itemPath, {autoDestroy: true});\n      const writeStream = fs.createWriteStream(pathOnServer, {autoClose: true});\n      pullPromises.push(new B((resolve, reject) => {\n        writeStream.on('close', resolve);\n        const onStreamingError = (e) => {\n          readStream.unpipe(writeStream);\n          reject(e);\n        };\n        writeStream.on('error', onStreamingError);\n        readStream.on('error', onStreamingError);\n      }).timeout(IO_TIMEOUT_MS));\n      readStream.pipe(writeStream);\n      if (pullPromises.length >= MAX_IO_CHUNK_SIZE) {\n        await B.any(pullPromises);\n      }\n      _.remove(pullPromises, (p) => p.isFulfilled());\n    });\n    // Wait for the rest of the chunks\n    await B.all(pullPromises);\n    return await zip.toInMemoryZip(tmpFolder, {\n      encodeToBase64: true,\n    });\n  } finally {\n    await fs.rimraf(tmpFolder);\n  }\n}\n\n/**\n * Creates remote folder path recursively. Noop if the given path\n * already exists\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remoteRoot The relative path to the remote folder structure\n * to be created\n */\nasync function remoteMkdirp (afcService, remoteRoot) {\n  if (remoteRoot === '.' || remoteRoot === '/') {\n    return;\n  }\n  try {\n    await afcService.listDirectory(remoteRoot);\n    return;\n  } catch (e) {\n    // This means that the directory is missing and we got an object not found error.\n    // Therefore, we are going to the parent\n    await remoteMkdirp(afcService, path.dirname(remoteRoot));\n  }\n  await afcService.createDirectory(remoteRoot);\n}\n\n/**\n * Pushes a file to a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remotePath Relative path to the file on the device. The remote\n * folder structure is created automatically if necessary.\n * @param {string} base64Data Base64-encoded content of the file to be written\n */\nasync function pushFile (afcService, remotePath, base64Data) {\n  await remoteMkdirp(afcService, path.dirname(remotePath));\n  const stream = await afcService.createWriteStream(remotePath, {autoDestroy: true});\n  let pushError = null;\n  const pushPromise = new B((resolve, reject) => {\n    stream.on('error', (e) => {\n      pushError = e;\n    });\n    stream.on('close', () => {\n      if (pushError) {\n        reject(pushError);\n      } else {\n        resolve();\n      }\n    });\n  }).timeout(IO_TIMEOUT_MS);\n  stream.write(Buffer.from(base64Data, 'base64'));\n  stream.end();\n  await pushPromise;\n}\n\n/**\n * @typedef {Object} PushFolderOptions\n *\n * @property {number} timeoutMs [240000] The maximum timeout to wait until a\n * single file is copied\n * @param {boolean} enableParallelPush [false] Whether to push files in parallel.\n * This usually gives better performance, but might sometimes be less stable.\n */\n\n/**\n * Pushes a folder to a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} srcRootPath The full path to the source folder\n * @param {string} dstRootPath The relative path to the destination folder. The folder\n * will be deleted if already exists.\n * @param {PushFolderOptions} opts\n */\nasync function pushFolder (afcService, srcRootPath, dstRootPath, opts = {}) {\n  const {\n    timeoutMs = IO_TIMEOUT_MS,\n    enableParallelPush = false,\n  } = opts;\n\n  const timer = new timing.Timer().start();\n  const itemsToPush = await fs.glob('**', {\n    cwd: srcRootPath,\n    nosort: true,\n    mark: true,\n  });\n  log.debug(`Successfully scanned the tree structure of '${srcRootPath}'`);\n  const [foldersToPush, filesToPush] = itemsToPush.reduce((acc, x) => {\n    acc[_.endsWith(x, path.sep) ? 0 : 1].push(x);\n    return acc;\n  }, [[], []]);\n  log.debug(`Got ${util.pluralize('folder', foldersToPush.length, true)} and ` +\n    `${util.pluralize('file', filesToPush.length, true)} to push`);\n  // create the folder structure first\n  try {\n    await afcService.deleteDirectory(dstRootPath);\n  } catch (ign) {}\n  await afcService.createDirectory(dstRootPath);\n  // top-level folders must go first\n  const foldersToPushByHierarchy = foldersToPush\n    .sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);\n  for (const relativeFolderPath of foldersToPushByHierarchy) {\n    // createDirectory does not accept folder names ending with a path separator\n    const absoluteFolderPath = _.trimEnd(\n      path.join(dstRootPath, relativeFolderPath), path.sep\n    );\n    if (absoluteFolderPath) {\n      await afcService.createDirectory(absoluteFolderPath);\n    }\n  }\n  // do not forget about the root folder\n  log.debug(`Successfully created the remote folder structure ` +\n    `(${util.pluralize('item', foldersToPush.length + 1, true)})`);\n\n  const pushFile = async (relativePath) => {\n    const absoluteSourcePath = path.join(srcRootPath, relativePath);\n    const readStream = fs.createReadStream(absoluteSourcePath, {autoClose: true});\n    const absoluteDestinationPath = path.join(dstRootPath, relativePath);\n    const writeStream = await afcService.createWriteStream(absoluteDestinationPath, {\n      autoDestroy: true\n    });\n    writeStream.on('finish', writeStream.destroy);\n    let pushError = null;\n    const filePushPromise = new B((resolve, reject) => {\n      writeStream.on('close', () => {\n        if (pushError) {\n          reject(pushError);\n        } else {\n          resolve();\n        }\n      });\n      const onStreamError = (e) => {\n        readStream.unpipe(writeStream);\n        log.debug(e);\n        pushError = e;\n      };\n      writeStream.on('error', onStreamError);\n      readStream.on('error', onStreamError);\n    });\n    readStream.pipe(writeStream);\n    await filePushPromise.timeout(timeoutMs);\n  };\n\n  if (enableParallelPush) {\n    log.debug(`Proceeding to parallel files push (max ${MAX_IO_CHUNK_SIZE} writers)`);\n    const pushPromises = [];\n    for (const relativeFilePath of _.shuffle(filesToPush)) {\n      pushPromises.push(B.resolve(pushFile(relativeFilePath)));\n      // keep the push queue filled\n      if (pushPromises.length >= MAX_IO_CHUNK_SIZE) {\n        await B.any(pushPromises);\n      }\n      _.remove(pushPromises, (p) => p.isFulfilled());\n    }\n    if (!_.isEmpty(pushPromises)) {\n      // handle the rest of push promises\n      await B.all(pushPromises);\n    }\n  } else {\n    log.debug(`Proceeding to serial files push`);\n    for (const relativeFilePath of filesToPush) {\n      await pushFile(relativeFilePath);\n    }\n  }\n\n  log.debug(`Successfully pushed ${util.pluralize('folder', foldersToPush.length, true)} ` +\n    `and ${util.pluralize('file', filesToPush.length, true)} ` +\n    `within ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);\n}\n\n\nexport { pullFile, pullFolder, pushFile, pushFolder };"],"file":"lib/ios-fs-helpers.js","sourceRoot":"../.."}
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lib/ios-fs-helpers.js"],"names":["IO_TIMEOUT_MS","MAX_IO_CHUNK_SIZE","pullFile","afcService","remotePath","stream","createReadStream","autoDestroy","pullPromise","B","resolve","reject","on","timeout","buffers","data","push","Buffer","concat","folderExists","folderPath","fs","stat","isDirectory","e","pullFolder","remoteRootPath","tmpFolder","tempDir","openDir","localTopItem","countFilesSuccess","countFilesFail","countFolders","pullPromises","walkDir","isDir","localPath","path","join","dirname","split","sep","length","readStream","writeStream","createWriteStream","autoClose","onStreamingError","unpipe","log","warn","message","pipe","any","_","remove","p","isFulfilled","isEmpty","all","info","util","pluralize","zip","toInMemoryZip","encodeToBase64","rimraf","remoteMkdirp","remoteRoot","listDirectory","createDirectory","pushFile","base64Data","pushError","pushPromise","write","from","end","pushFolder","srcRootPath","dstRootPath","opts","timeoutMs","enableParallelPush","timer","timing","Timer","start","itemsToPush","glob","cwd","nosort","mark","debug","foldersToPush","filesToPush","reduce","acc","x","endsWith","deleteDirectory","ign","foldersToPushByHierarchy","sort","a","b","relativeFolderPath","absoluteFolderPath","trimEnd","relativePath","absoluteSourcePath","absoluteDestinationPath","destroy","filePushPromise","onStreamError","pushPromises","relativeFilePath","shuffle","getDuration","asMilliSeconds","toFixed"],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport B from 'bluebird';\nimport { fs, tempDir, mkdirp, zip, util, timing } from 'appium-support';\nimport path from 'path';\nimport log from './logger';\n\nconst IO_TIMEOUT_MS = 4 * 60 * 1000;\n// Mobile devices use NAND memory modules for the storage,\n// and the parallelism there is not as performant as on regular SSDs\nconst MAX_IO_CHUNK_SIZE = 8;\n\n/**\n * Retrieve a file from a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remotePath Relative path to the file on the device\n * @returns {Buffer} The file content as a buffer\n */\nasync function pullFile (afcService, remotePath) {\n  const stream = await afcService.createReadStream(remotePath, { autoDestroy: true });\n  const pullPromise = new B((resolve, reject) => {\n    stream.on('close', resolve);\n    stream.on('error', reject);\n  }).timeout(IO_TIMEOUT_MS);\n  const buffers = [];\n  stream.on('data', (data) => buffers.push(data));\n  await pullPromise;\n  return Buffer.concat(buffers);\n}\n\n/**\n * Checks a presence of a local folder.\n *\n * @param {string} folderPath Full path to the local folder\n * @returns {boolean} True if the folder exists and is actually a folder\n */\nasync function folderExists (folderPath) {\n  try {\n    return (await fs.stat(folderPath)).isDirectory();\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Retrieve a folder from a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remoteRootPath Relative path to the folder on the device\n * @returns {Buffer} The folder content as a zipped base64-encoded buffer\n */\nasync function pullFolder (afcService, remoteRootPath) {\n  const tmpFolder = await tempDir.openDir();\n  try {\n    let localTopItem = null;\n    let countFilesSuccess = 0;\n    let countFilesFail = 0;\n    let countFolders = 0;\n    const pullPromises = [];\n    await afcService.walkDir(remoteRootPath, true, async (remotePath, isDir) => {\n      const localPath = path.join(tmpFolder, remotePath);\n      const dirname = isDir ? localPath : path.dirname(localPath);\n      if (!await folderExists(dirname)) {\n        await mkdirp(dirname);\n      }\n      if (!localTopItem\n          || localPath.split(path.sep).length < localTopItem.split(path.sep).length) {\n        localTopItem = localPath;\n      }\n      if (isDir) {\n        ++countFolders;\n        return;\n      }\n\n      const readStream = await afcService.createReadStream(remotePath, {autoDestroy: true});\n      const writeStream = fs.createWriteStream(localPath, {autoClose: true});\n      pullPromises.push(\n        new B((resolve) => {\n          writeStream.on('close', () => {\n            ++countFilesSuccess;\n            resolve();\n          });\n          const onStreamingError = (e) => {\n            readStream.unpipe(writeStream);\n            log.warn(`Cannot pull '${remotePath}' to '${localPath}'. ` +\n              `The file will be skipped. Original error: ${e.message}`);\n            ++countFilesFail;\n            resolve();\n          };\n          writeStream.on('error', onStreamingError);\n          readStream.on('error', onStreamingError);\n        }).timeout(IO_TIMEOUT_MS)\n      );\n      readStream.pipe(writeStream);\n      if (pullPromises.length >= MAX_IO_CHUNK_SIZE) {\n        await B.any(pullPromises);\n      }\n      _.remove(pullPromises, (p) => p.isFulfilled());\n    });\n    // Wait for the rest of files to be pulled\n    if (!_.isEmpty(pullPromises)) {\n      await B.all(pullPromises);\n    }\n    log.info(`Pulled ${util.pluralize('file', countFilesSuccess, true)} out of ` +\n      `${countFilesSuccess + countFilesFail} and ${util.pluralize('folder', countFolders, true)} ` +\n      `from '${remoteRootPath}'`);\n    return await zip.toInMemoryZip(localTopItem ? path.dirname(localTopItem) : tmpFolder, {\n      encodeToBase64: true,\n    });\n  } finally {\n    await fs.rimraf(tmpFolder);\n  }\n}\n\n/**\n * Creates remote folder path recursively. Noop if the given path\n * already exists\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remoteRoot The relative path to the remote folder structure\n * to be created\n */\nasync function remoteMkdirp (afcService, remoteRoot) {\n  if (remoteRoot === '.' || remoteRoot === '/') {\n    return;\n  }\n  try {\n    await afcService.listDirectory(remoteRoot);\n    return;\n  } catch (e) {\n    // This means that the directory is missing and we got an object not found error.\n    // Therefore, we are going to the parent\n    await remoteMkdirp(afcService, path.dirname(remoteRoot));\n  }\n  await afcService.createDirectory(remoteRoot);\n}\n\n/**\n * Pushes a file to a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} remotePath Relative path to the file on the device. The remote\n * folder structure is created automatically if necessary.\n * @param {string} base64Data Base64-encoded content of the file to be written\n */\nasync function pushFile (afcService, remotePath, base64Data) {\n  await remoteMkdirp(afcService, path.dirname(remotePath));\n  const stream = await afcService.createWriteStream(remotePath, {autoDestroy: true});\n  let pushError = null;\n  const pushPromise = new B((resolve, reject) => {\n    stream.on('error', (e) => {\n      pushError = e;\n    });\n    stream.on('close', () => {\n      if (pushError) {\n        reject(pushError);\n      } else {\n        resolve();\n      }\n    });\n  }).timeout(IO_TIMEOUT_MS);\n  stream.write(Buffer.from(base64Data, 'base64'));\n  stream.end();\n  await pushPromise;\n}\n\n/**\n * @typedef {Object} PushFolderOptions\n *\n * @property {number} timeoutMs [240000] The maximum timeout to wait until a\n * single file is copied\n * @param {boolean} enableParallelPush [false] Whether to push files in parallel.\n * This usually gives better performance, but might sometimes be less stable.\n */\n\n/**\n * Pushes a folder to a real device\n *\n * @param {AfcService} afcService Apple File Client service instance from\n * 'appium-ios-device' module\n * @param {string} srcRootPath The full path to the source folder\n * @param {string} dstRootPath The relative path to the destination folder. The folder\n * will be deleted if already exists.\n * @param {PushFolderOptions} opts\n */\nasync function pushFolder (afcService, srcRootPath, dstRootPath, opts = {}) {\n  const {\n    timeoutMs = IO_TIMEOUT_MS,\n    enableParallelPush = false,\n  } = opts;\n\n  const timer = new timing.Timer().start();\n  const itemsToPush = await fs.glob('**', {\n    cwd: srcRootPath,\n    nosort: true,\n    mark: true,\n  });\n  log.debug(`Successfully scanned the tree structure of '${srcRootPath}'`);\n  const [foldersToPush, filesToPush] = itemsToPush.reduce((acc, x) => {\n    acc[_.endsWith(x, path.sep) ? 0 : 1].push(x);\n    return acc;\n  }, [[], []]);\n  log.debug(`Got ${util.pluralize('folder', foldersToPush.length, true)} and ` +\n    `${util.pluralize('file', filesToPush.length, true)} to push`);\n  // create the folder structure first\n  try {\n    await afcService.deleteDirectory(dstRootPath);\n  } catch (ign) {}\n  await afcService.createDirectory(dstRootPath);\n  // top-level folders must go first\n  const foldersToPushByHierarchy = foldersToPush\n    .sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);\n  for (const relativeFolderPath of foldersToPushByHierarchy) {\n    // createDirectory does not accept folder names ending with a path separator\n    const absoluteFolderPath = _.trimEnd(\n      path.join(dstRootPath, relativeFolderPath), path.sep\n    );\n    if (absoluteFolderPath) {\n      await afcService.createDirectory(absoluteFolderPath);\n    }\n  }\n  // do not forget about the root folder\n  log.debug(`Successfully created the remote folder structure ` +\n    `(${util.pluralize('item', foldersToPush.length + 1, true)})`);\n\n  const pushFile = async (relativePath) => {\n    const absoluteSourcePath = path.join(srcRootPath, relativePath);\n    const readStream = fs.createReadStream(absoluteSourcePath, {autoClose: true});\n    const absoluteDestinationPath = path.join(dstRootPath, relativePath);\n    const writeStream = await afcService.createWriteStream(absoluteDestinationPath, {\n      autoDestroy: true\n    });\n    writeStream.on('finish', writeStream.destroy);\n    let pushError = null;\n    const filePushPromise = new B((resolve, reject) => {\n      writeStream.on('close', () => {\n        if (pushError) {\n          reject(pushError);\n        } else {\n          resolve();\n        }\n      });\n      const onStreamError = (e) => {\n        readStream.unpipe(writeStream);\n        log.debug(e);\n        pushError = e;\n      };\n      writeStream.on('error', onStreamError);\n      readStream.on('error', onStreamError);\n    });\n    readStream.pipe(writeStream);\n    await filePushPromise.timeout(timeoutMs);\n  };\n\n  if (enableParallelPush) {\n    log.debug(`Proceeding to parallel files push (max ${MAX_IO_CHUNK_SIZE} writers)`);\n    const pushPromises = [];\n    for (const relativeFilePath of _.shuffle(filesToPush)) {\n      pushPromises.push(B.resolve(pushFile(relativeFilePath)));\n      // keep the push queue filled\n      if (pushPromises.length >= MAX_IO_CHUNK_SIZE) {\n        await B.any(pushPromises);\n      }\n      _.remove(pushPromises, (p) => p.isFulfilled());\n    }\n    if (!_.isEmpty(pushPromises)) {\n      // handle the rest of push promises\n      await B.all(pushPromises);\n    }\n  } else {\n    log.debug(`Proceeding to serial files push`);\n    for (const relativeFilePath of filesToPush) {\n      await pushFile(relativeFilePath);\n    }\n  }\n\n  log.debug(`Successfully pushed ${util.pluralize('folder', foldersToPush.length, true)} ` +\n    `and ${util.pluralize('file', filesToPush.length, true)} ` +\n    `within ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);\n}\n\n\nexport { pullFile, pullFolder, pushFile, pushFolder };"],"file":"lib/ios-fs-helpers.js","sourceRoot":"../.."}

package/lib/ios-fs-helpers.js

@@ -29,6 +29,20 @@ async function pullFile (afcService, remotePath) {
   return Buffer.concat(buffers);
 }
 
+/**
+ * Checks a presence of a local folder.
+ *
+ * @param {string} folderPath Full path to the local folder
+ * @returns {boolean} True if the folder exists and is actually a folder
+ */
+async function folderExists (folderPath) {
+  try {
+    return (await fs.stat(folderPath)).isDirectory();
+  } catch (e) {
+    return false;
+  }
+}
+
 /**
  * Retrieve a folder from a real device
  *
@@ -40,34 +54,59 @@ async function pullFile (afcService, remotePath) {
 async function pullFolder (afcService, remoteRootPath) {
   const tmpFolder = await tempDir.openDir();
   try {
+    let localTopItem = null;
+    let countFilesSuccess = 0;
+    let countFilesFail = 0;
+    let countFolders = 0;
     const pullPromises = [];
-    await afcService.walkDir(remoteRootPath, true, async (itemPath, isDir) => {
-      const pathOnServer = path.join(tmpFolder, itemPath);
+    await afcService.walkDir(remoteRootPath, true, async (remotePath, isDir) => {
+      const localPath = path.join(tmpFolder, remotePath);
+      const dirname = isDir ? localPath : path.dirname(localPath);
+      if (!await folderExists(dirname)) {
+        await mkdirp(dirname);
+      }
+      if (!localTopItem
+          || localPath.split(path.sep).length < localTopItem.split(path.sep).length) {
+        localTopItem = localPath;
+      }
       if (isDir) {
-        await mkdirp(pathOnServer);
+        ++countFolders;
         return;
       }
 
-      const readStream = await afcService.createReadStream(itemPath, {autoDestroy: true});
-      const writeStream = fs.createWriteStream(pathOnServer, {autoClose: true});
-      pullPromises.push(new B((resolve, reject) => {
-        writeStream.on('close', resolve);
-        const onStreamingError = (e) => {
-          readStream.unpipe(writeStream);
-          reject(e);
-        };
-        writeStream.on('error', onStreamingError);
-        readStream.on('error', onStreamingError);
-      }).timeout(IO_TIMEOUT_MS));
+      const readStream = await afcService.createReadStream(remotePath, {autoDestroy: true});
+      const writeStream = fs.createWriteStream(localPath, {autoClose: true});
+      pullPromises.push(
+        new B((resolve) => {
+          writeStream.on('close', () => {
+            ++countFilesSuccess;
+            resolve();
+          });
+          const onStreamingError = (e) => {
+            readStream.unpipe(writeStream);
+            log.warn(`Cannot pull '${remotePath}' to '${localPath}'. ` +
+              `The file will be skipped. Original error: ${e.message}`);
+            ++countFilesFail;
+            resolve();
+          };
+          writeStream.on('error', onStreamingError);
+          readStream.on('error', onStreamingError);
+        }).timeout(IO_TIMEOUT_MS)
+      );
       readStream.pipe(writeStream);
       if (pullPromises.length >= MAX_IO_CHUNK_SIZE) {
         await B.any(pullPromises);
       }
       _.remove(pullPromises, (p) => p.isFulfilled());
     });
-    // Wait for the rest of the chunks
-    await B.all(pullPromises);
-    return await zip.toInMemoryZip(tmpFolder, {
+    // Wait for the rest of files to be pulled
+    if (!_.isEmpty(pullPromises)) {
+      await B.all(pullPromises);
+    }
+    log.info(`Pulled ${util.pluralize('file', countFilesSuccess, true)} out of ` +
+      `${countFilesSuccess + countFilesFail} and ${util.pluralize('folder', countFolders, true)} ` +
+      `from '${remoteRootPath}'`);
+    return await zip.toInMemoryZip(localTopItem ? path.dirname(localTopItem) : tmpFolder, {
       encodeToBase64: true,
     });
   } finally {

package/package.json

@@ -8,7 +8,7 @@
     "xcuitest",
     "xctest"
   ],
-  "version": "3.59.1",
+  "version": "3.59.2",
   "author": "appium",
   "license": "Apache-2.0",
   "repository": {