appium-xcuitest-driver 7.20.2 → 7.21.1

package/lib/device-log/ios-log.js

@@ -1,14 +1,22 @@
 import {EventEmitter} from 'events';
+import { LRUCache } from 'lru-cache';
+import { toLogEntry } from './helpers';
 
 // We keep only the most recent log entries to avoid out of memory error
 const MAX_LOG_ENTRIES_COUNT = 10000;
 
-class IOSLog extends EventEmitter {
-  constructor() {
+// TODO: Rewrite this class to typescript for better generic typing
+
+export class IOSLog extends EventEmitter {
+  constructor(maxBufferSize = MAX_LOG_ENTRIES_COUNT) {
     super();
-    this.logs = [];
-    this.logIdxSinceLastRequest = -1;
-    this.maxBufferSize = MAX_LOG_ENTRIES_COUNT;
+    this.maxBufferSize = maxBufferSize;
+    /** @type {LRUCache<number, any>} */
+    this.logs = new LRUCache({
+      max: this.maxBufferSize,
+    });
+    /** @type {number?} */
+    this.logIndexSinceLastRequest = null;
   }
 
   /** @returns {Promise<void>} */
@@ -28,38 +36,81 @@ class IOSLog extends EventEmitter {
     throw new Error(`Sub-classes need to implement a 'isCapturing' function`);
   }
 
-  broadcast(logLine) {
-    const logObj = {
-      timestamp: Date.now(),
-      level: 'ALL',
-      message: logLine,
-    };
-    this.logs.push(logObj);
-    this.emit('output', logObj);
-    if (this.logs.length > this.maxBufferSize) {
-      this.logs.shift();
-      if (this.logIdxSinceLastRequest > 0) {
-        --this.logIdxSinceLastRequest;
-      }
+  /**
+   *
+   * @param {any} entry
+   * @returns {void}
+   */
+  broadcast(entry) {
+    let recentIndex = -1;
+    for (const key of this.logs.rkeys()) {
+      recentIndex = key;
+      break;
+    }
+    const serializedEntry = this._serializeEntry(entry);
+    this.logs.set(++recentIndex, serializedEntry);
+    if (this.listenerCount('output')) {
+      this.emit('output', this._deserializeEntry(serializedEntry));
     }
   }
 
+  /**
+   *
+   * @returns {import('../commands/types').LogEntry[]}
+   */
   getLogs() {
-    if (this.logs.length && this.logIdxSinceLastRequest < this.logs.length) {
-      let result = this.logs;
-      if (this.logIdxSinceLastRequest > 0) {
-        result = result.slice(this.logIdxSinceLastRequest);
+    /** @type {import('../commands/types').LogEntry[]} */
+    const result = [];
+    /** @type {number?} */
+    let recentLogIndex = null;
+    for (const [index, value] of this.logs.entries()) {
+      if (this.logIndexSinceLastRequest && index > this.logIndexSinceLastRequest
+          || !this.logIndexSinceLastRequest) {
+        recentLogIndex = index;
+        result.push(this._deserializeEntry(value));
       }
-      this.logIdxSinceLastRequest = this.logs.length;
-      return result;
     }
-    return [];
+    if (recentLogIndex !== null) {
+      this.logIndexSinceLastRequest = recentLogIndex;
+    }
+    return result;
   }
 
+  /**
+   *
+   * @returns {import('../commands/types').LogEntry[]}
+   */
   getAllLogs() {
-    return this.logs;
+    /** @type {import('../commands/types').LogEntry[]} */
+    const result = [];
+    for (const value of this.logs.values()) {
+      result.push(this._deserializeEntry(value));
+    }
+    return result;
+  }
+
+  /**
+   *
+   * @param {any} value
+   * @returns {any}
+   */
+  _serializeEntry(value) {
+    return [value, Date.now()];
+  }
+
+  /**
+   *
+   * @param {any} value
+   * @returns {any}
+   */
+  _deserializeEntry(value) {
+    const [message, timestamp] = value;
+    return toLogEntry(message, timestamp);
+  }
+
+  _clearEntries() {
+    this.logs.clear();
   }
 }
 
-export {IOSLog};
 export default IOSLog;

package/lib/device-log/ios-performance-log.js

@@ -1,57 +1,68 @@
 import {logger} from 'appium/support';
 import _ from 'lodash';
+import { IOSLog } from './ios-log';
 
 const log = logger.getLogger('IOSPerformanceLog');
 const MAX_EVENTS = 5000;
 
-class IOSPerformanceLog {
+export class IOSPerformanceLog extends IOSLog {
   constructor(remoteDebugger, maxEvents = MAX_EVENTS) {
+    super(maxEvents);
     this.remoteDebugger = remoteDebugger;
     this.maxEvents = parseInt(String(maxEvents), 10);
-
-    this.timelineEvents = [];
+    this._started = false;
   }
 
+  /**
+   * @override
+   */
   async startCapture() {
     log.debug('Starting performance (Timeline) log capture');
-    this.timelineEvents = [];
-    return await this.remoteDebugger.startTimeline(this.onTimelineEvent.bind(this));
+    this._clearEntries();
+    const result = await this.remoteDebugger.startTimeline(this.onTimelineEvent.bind(this));
+    this._started = true;
+    return result;
   }
 
+  /**
+   * @override
+   */
   async stopCapture() {
     log.debug('Stopping performance (Timeline) log capture');
-    return await this.remoteDebugger.stopTimeline();
+    const result = await this.remoteDebugger.stopTimeline();
+    this._started = false;
+    return result;
   }
 
-  onTimelineEvent(event) {
-    log.debug(`Received Timeline event: ${_.truncate(JSON.stringify(event))}`);
-    this.timelineEvents.push(event);
-
-    // if we have too many, get rid of the oldest log line
-    if (this.timelineEvents.length > this.maxEvents) {
-      let removedEvent = this.timelineEvents.shift();
-      log.warn(
-        `Too many Timeline events, removing earliest: ${_.truncate(JSON.stringify(removedEvent))}`,
-      );
-    }
+  /**
+   * @override
+   */
+  get isCapturing() {
+    return this._started;
   }
 
-  // eslint-disable-next-line require-await
-  async getLogs() {
-    let events = this.timelineEvents;
-
-    // flush events
-    log.debug('Flushing Timeline events');
-    this.timelineEvents = [];
+  /**
+   * @override
+   */
+  _serializeEntry(value) {
+    return value;
+  }
 
-    return events;
+  /**
+   * @override
+   */
+  _deserializeEntry(value) {
+    return value;
   }
 
-  // eslint-disable-next-line require-await
-  async getAllLogs() {
-    return this.getLogs();
+  /**
+   *
+   * @param {import('../commands/types').LogEntry} event
+   */
+  onTimelineEvent(event) {
+    log.debug(`Received Timeline event: ${_.truncate(JSON.stringify(event))}`);
+    this.broadcast(event);
   }
 }
 
-export {IOSPerformanceLog};
 export default IOSPerformanceLog;

package/lib/device-log/ios-simulator-log.js

@@ -4,10 +4,11 @@ import {logger} from 'appium/support';
 import {exec} from 'teen_process';
 
 const log = logger.getLogger('IOSSimulatorLog');
+const EXECVP_ERROR_PATTERN = /execvp\(\)/;
 
 const START_TIMEOUT = 10000;
 
-class IOSSimulatorLog extends IOSLog {
+export class IOSSimulatorLog extends IOSLog {
   constructor({sim, showLogs, xcodeVersion, iosSimulatorLogsPredicate}) {
     super();
     this.sim = sim;
@@ -17,6 +18,9 @@ class IOSSimulatorLog extends IOSLog {
     this.proc = null;
   }
 
+  /**
+   * @override
+   */
   async startCapture() {
     if (_.isUndefined(this.sim.udid)) {
       throw new Error(`Log capture requires a sim udid`);
@@ -44,41 +48,9 @@ class IOSSimulatorLog extends IOSLog {
     }
   }
 
-  async finishStartingLogCapture() {
-    if (!this.proc) {
-      log.errorAndThrow('Could not capture simulator log');
-    }
-    let firstLine = true;
-    let logRow = '';
-    this.proc.on('output', (stdout, stderr) => {
-      if (stdout) {
-        if (firstLine) {
-          if (stdout.endsWith('\n')) {
-            // don't store the first line of the log because it came before the sim was launched
-            firstLine = false;
-          }
-        } else {
-          logRow += stdout;
-          if (stdout.endsWith('\n')) {
-            this.onOutput(logRow);
-            logRow = '';
-          }
-        }
-      }
-      if (stderr) {
-        this.onOutput(logRow, 'STDERR');
-      }
-    });
-
-    let sd = (stdout, stderr) => {
-      if (/execvp\(\)/.test(stderr)) {
-        throw new Error('iOS log capture process failed to start');
-      }
-      return stdout || stderr;
-    };
-    await this.proc.start(sd, START_TIMEOUT);
-  }
-
+  /**
+   * @override
+   */
   async stopCapture() {
     if (!this.proc) {
       return;
@@ -87,6 +59,25 @@ class IOSSimulatorLog extends IOSLog {
     this.proc = null;
   }
 
+  /**
+   * @override
+   */
+  get isCapturing() {
+    return this.proc && this.proc.isRunning;
+  }
+
+  /**
+   * @param {string} logRow
+   * @param {string} [prefix='']
+   */
+  onOutput(logRow, prefix = '') {
+    this.broadcast(logRow);
+    if (this.showLogs) {
+      const space = prefix.length > 0 ? ' ' : '';
+      log.info(`[IOS_SYSLOG_ROW${space}${prefix}] ${logRow}`);
+    }
+  }
+
   async killLogSubProcess() {
     if (!this.proc.isRunning) {
       return;
@@ -103,22 +94,27 @@ class IOSSimulatorLog extends IOSLog {
     }
   }
 
-  get isCapturing() {
-    return this.proc && this.proc.isRunning;
-  }
+  async finishStartingLogCapture() {
+    if (!this.proc) {
+      log.errorAndThrow('Could not capture simulator log');
+    }
 
-  onOutput(logRow, prefix = '') {
-    const logs = _.cloneDeep(logRow.split('\n'));
-    for (const logLine of logs) {
-      if (!logLine) continue; // eslint-disable-line curly
-      this.broadcast(logLine);
-      if (this.showLogs) {
-        const space = prefix.length > 0 ? ' ' : '';
-        log.info(`[IOS_SYSLOG_ROW${space}${prefix}] ${logLine}`);
-      }
+    for (const streamName of ['stdout', 'stderr']) {
+      this.proc.on(`lines-${streamName}`, (/** @type {string[]} */ lines) => {
+        for (const line of lines) {
+          this.onOutput(line, ...(streamName === 'stderr' ? ['STDERR'] : []));
+        }
+      });
     }
+
+    const startDetector = (/** @type {string} */ stdout, /** @type {string} */ stderr) => {
+      if (EXECVP_ERROR_PATTERN.test(stderr)) {
+        throw new Error('iOS log capture process failed to start');
+      }
+      return stdout || stderr;
+    };
+    await this.proc.start(startDetector, START_TIMEOUT);
   }
 }
 
-export {IOSSimulatorLog};
 export default IOSSimulatorLog;

package/lib/execute-method-map.ts

@@ -333,6 +333,19 @@ export const executeMethodMap = {
       required: ['style'],
     },
   },
+  'mobile: getClipboard': {
+    command: 'getClipboard',
+    params: {
+      optional: ['contentType'],
+    },
+  },
+  'mobile: setClipboard': {
+    command: 'setClipboard',
+    params: {
+      required: ['content'],
+      optional: ['contentType'],
+    },
+  },
   'mobile: siriCommand': {
     command: 'mobileSiriCommand',
     params: {