detox 20.21.0 → 20.21.1-smoke.0

package/scripts/build_local_framework.ios.sh

@@ -0,0 +1,62 @@
+#!/bin/bash -e
+
+# Ensure Xcode is installed or print a warning message and return.
+xcodebuild -version &>/dev/null || { echo "WARNING: Xcode is not installed on this machine. Skipping iOS framework build phase"; exit 0; }
+
+detoxRootPath="$(dirname "$(dirname "$0")")"
+detoxVersion=`node -p "require('${detoxRootPath}/package.json').version"`
+
+sha1=`(echo "${detoxVersion}" && xcodebuild -version) | shasum | awk '{print $1}' #"${2}"`
+detoxFrameworkDirPath="$HOME/Library/Detox/ios/framework/${sha1}"
+detoxFrameworkPath="${detoxFrameworkDirPath}/Detox.framework"
+
+
+function prepareAndBuildFramework () {
+  if [ -d "$detoxRootPath"/ios ]; then
+    detoxSourcePath="${detoxRootPath}"/ios
+    echo "Dev mode, building from ${detoxSourcePath}"
+    buildFramework "${detoxSourcePath}"
+  else
+    extractFramework
+  fi
+}
+
+function extractFramework () {
+  echo "Extracting Detox framework..."
+  mkdir -p "${detoxFrameworkDirPath}"
+  tar -xjf "${detoxRootPath}"/Detox-ios-framework.tbz -C "${detoxFrameworkDirPath}"
+}
+
+function buildFramework () {
+  detoxSourcePath="${1}"
+  echo "Building Detox.framework from ${detoxSourcePath} into ${detoxFrameworkDirPath}"
+  mkdir -p "${detoxFrameworkDirPath}"
+  logPath="${detoxFrameworkDirPath}"/detox_ios.log
+  echo "Build log: ${logPath}"
+  echo -n "" > "${logPath}"
+  "${detoxRootPath}"/scripts/build_framework.ios.sh "${detoxSourcePath}"/Detox.xcodeproj "${detoxFrameworkDirPath}" &> "${logPath}" || {
+    echo -e "#################################\nError building Detox.framework:\n----------------------------------\n"
+    cat "${logPath}"
+    echo "#################################"
+    exit 1
+  }
+}
+
+function main () {
+  if [ -d "${detoxFrameworkDirPath}" ]; then
+    if [ ! -d "${detoxFrameworkPath}" ]; then
+      echo "${detoxFrameworkDirPath} was found, but could not find Detox.framework inside it. This means that the Detox framework build process was interrupted.
+         deleting ${detoxFrameworkDirPath} and trying to rebuild."
+      rm -rf "${detoxFrameworkDirPath}"
+      prepareAndBuildFramework
+    else
+      echo "Detox.framework exists, skipping..."
+    fi
+  else
+    prepareAndBuildFramework
+  fi
+
+  echo "Done"
+}
+
+main

package/scripts/build_local_xcuitest.ios.sh

@@ -0,0 +1,53 @@
+#!/bin/bash -e
+
+# Ensure Xcode is installed or print a warning message and return.
+xcodebuild -version &>/dev/null || { echo "WARNING: Xcode is not installed on this machine. Skipping iOS xctest runner build phase"; exit 0; }
+
+detoxRootPath="$(dirname "$(dirname "$0")")"
+detoxVersion=`node -p "require('${detoxRootPath}/package.json').version"`
+
+sha1=`(echo "${detoxVersion}" && xcodebuild -version) | shasum | awk '{print $1}' #"${2}"`
+detoxXctestRunnerDirPath="$HOME/Library/Detox/ios/xcuitest-runner/${sha1}"
+
+function prepareAndBuildXctestRunner () {
+  if [ -d "$detoxRootPath"/ios ]; then
+    detoxSourcePath="${detoxRootPath}"/ios
+    echo "Dev mode, building XCUITest runner from ${detoxSourcePath}"
+    buildXctestRunner "${detoxSourcePath}"
+  else
+    extractXctestRunner
+  fi
+}
+
+function extractXctestRunner () {
+  echo "Extracting Detox XCUITest runner..."
+  mkdir -p "${detoxXctestRunnerDirPath}"
+  tar -xjf "${detoxRootPath}"/Detox-ios-xcuitest.tbz -C "${detoxXctestRunnerDirPath}"
+}
+
+function buildXctestRunner () {
+  detoxSourcePath="${1}"
+  echo "Building XCUITest runner from ${detoxSourcePath} into ${detoxXctestRunnerDirPath}"
+  mkdir -p "${detoxXctestRunnerDirPath}"
+  logPath="${detoxXctestRunnerDirPath}"/detox_ios_xcuitest.log
+  echo "Build log: ${logPath}"
+  echo -n "" > "${logPath}"
+  "${detoxRootPath}"/scripts/build_xcuitest.ios.sh "${detoxSourcePath}"/DetoxXCUITestRunner/DetoxXCUITestRunner.xcodeproj "${detoxXctestRunnerDirPath}" &> "${logPath}" || {
+    echo -e "#################################\nError building DetoxXCUITestRunner.xctestrun:\n----------------------------------\n"
+    cat "${logPath}"
+    echo "#################################"
+    exit 1
+  }
+}
+
+function main () {
+  if [ ! -d "${detoxXctestRunnerDirPath}" ]; then
+    prepareAndBuildXctestRunner
+  else
+    echo "XCUITest-runner exists, skipping..."
+  fi
+
+  echo "Done"
+}
+
+main

package/scripts/build_xcuitest.ios.sh

@@ -0,0 +1,18 @@
+#!/bin/bash -e
+
+XCODEPROJ=$1
+XCUITEST_OUTPUT_DIR=$2
+CONFIGURATION=Release
+PROJECT_NAME=DetoxXCUITestRunner
+
+# Clean up the output directory
+
+rm -fr "${XCUITEST_OUTPUT_DIR}"
+
+# Make sure the output directory exists
+
+mkdir -p "${XCUITEST_OUTPUT_DIR}"
+
+# Build Simulator version
+
+xcodebuild -project "${XCODEPROJ}" -scheme "${PROJECT_NAME}" -UseNewBuildSystem="YES" -configuration "${CONFIGURATION}" -sdk iphonesimulator -destination 'generic/platform=iOS Simulator' -derivedDataPath "${XCUITEST_OUTPUT_DIR}" build-for-testing -quiet

package/scripts/pack_ios.sh

@@ -1,23 +1,32 @@
 #!/bin/bash -e
 
 rm -rf Detox-ios-src.tbz
-rm -rf Detox-ios.tbz
+rm -rf Detox-ios-framework.tbz
+rm -rf Detox-ios-xcuitest.tbz
 rm -rf build_temp
 
 find ./ios -name Build -type d -exec rm -rf {} \;
 
-#Package sources
-pushd . &> /dev/null
+# Package sources
 cd ios
 tar --exclude-from=.tbzignore -cjf ../Detox-ios-src.tbz .
-popd &> /dev/null
+cd ..
 
-#Package prebuilt framework
+echo "Packaging iOS sources and prebuilt frameworks"
+
+# Create temp build directory
 mkdir build_temp
-scripts/build_universal_framework.sh "ios/Detox.xcodeproj" "build_temp" &> build_temp/detox_ios.log
-pushd . &> /dev/null
+
+# Package prebuilt framework
+scripts/build_framework.ios.sh "ios/Detox.xcodeproj" "build_temp"
+
+# Package prebuilt XCUITest runner
+scripts/build_xcuitest.ios.sh "ios/DetoxXCUITestRunner/DetoxXCUITestRunner.xcodeproj" "build_temp"
+
 cd build_temp
-tar --exclude-from=../ios/.tbzignore -cjf ../Detox-ios.tbz .
-popd &> /dev/null
+tar --exclude-from=../ios/.tbzignore -cjf ../Detox-ios-xcuitest.tbz .
+tar --exclude-from=../ios/.tbzignore -cjf ../Detox-ios-framework.tbz .
+cd ..
 
+# Cleanup
 rm -fr build_temp

package/scripts/postinstall.js

@@ -1,8 +1,15 @@
+const { platform, env } = process;
+
 const { setGradleVersionByRNVersion } = require('./updateGradle');
-if (process.platform === 'darwin' && !process.env.DETOX_DISABLE_POSTINSTALL) {
-	require('child_process').execFileSync(`${__dirname}/build_framework.ios.sh`, {
-		stdio: 'inherit'
-	});
 
+const isDarwin = platform === 'darwin';
+const shouldInstallDetox = !env.DETOX_DISABLE_POSTINSTALL;
+
+if (isDarwin && shouldInstallDetox) {
+  const execFileSync = require('child_process').execFileSync;
+
+  execFileSync(`${__dirname}/build_local_framework.ios.sh`, { stdio: 'inherit' });
+  execFileSync(`${__dirname}/build_local_xcuitest.ios.sh`, { stdio: 'inherit' });
 }
+
 setGradleVersionByRNVersion();

package/src/android/AndroidExpect.js

@@ -21,6 +21,7 @@ class AndroidExpect {
     this.waitFor = this.waitFor.bind(this);
     this.web = this.web.bind(this);
     this.web.element = (...args) => this.web().element(...args);
+    this.system = { element: (...args) => this.systemElement(...args) };
   }
 
   element(matcher) {
@@ -45,6 +46,10 @@ class AndroidExpect {
     throw new DetoxRuntimeError(`web() argument is invalid, expected a native matcher, but got ${typeof element}`);
   }
 
+  systemElement(_matcher) {
+    throw new DetoxRuntimeError('System interactions are not supported on Android, use UiDevice APIs directly instead');
+  }
+
   expect(element) {
     if (element instanceof WebElement) return new WebExpectElement(this._invocationManager, element);
     if (element instanceof NativeElement) return new NativeExpectElement(this._invocationManager, element);

package/src/android/matchers/index.js

@@ -1,3 +1,5 @@
+const { DetoxRuntimeError } = require('../../errors');
+
 const native = require('./native');
 const web = require('./web');
 
@@ -20,4 +22,9 @@ module.exports = {
     href: (value) => new web.LinkTextMatcher(value),
     hrefContains: (value) => new web.PartialLinkTextMatcher(value),
   },
+
+  system: {
+    label: (_value) => { throw new DetoxRuntimeError('System interactions are not supported on Android, use UiDevice APIs directly instead'); },
+    type: (_value) => { throw new DetoxRuntimeError('System interactions are not supported on Android, use UiDevice APIs directly instead'); },
+  }
 };

package/src/ios/XCUITestRunner.js

@@ -0,0 +1,52 @@
+const { exec } = require('child-process-promise');
+
+const DetoxRuntimeError = require('../errors/DetoxRuntimeError');
+const environment = require('../utils/environment');
+const log = require('../utils/logger').child({ cat: 'xcuitest-runner' });
+
+class XCUITestRunner {
+    constructor({ simulatorId }) {
+        this.simulatorId = simulatorId;
+    }
+
+    async execute(invocationParams) {
+        log.trace(
+          { event: 'XCUITEST_RUNNER' },
+          'invocation params: %j, simulator id: %s', invocationParams, this.simulatorId
+        );
+
+        const base64InvocationParams = Buffer.from(JSON.stringify(invocationParams)).toString('base64');
+
+        const runnerPath = await environment.getXCUITestRunnerPath();
+        if (!runnerPath) {
+            throw new DetoxRuntimeError({
+                message: 'XCUITest runner path could not be found',
+                hint: DetoxRuntimeError.reportIssue,
+            });
+        }
+
+        const flags = [
+            '-xctestrun', runnerPath,
+            '-sdk', 'iphonesimulator',
+            '-destination', `"platform=iOS Simulator,id=${this.simulatorId}"`,
+            'test-without-building',
+        ];
+
+        try {
+            return await exec(`TEST_RUNNER_PARAMS="${base64InvocationParams}" xcodebuild ${flags.join(' ')}`);
+        } catch (e) {
+            const stdout = e.stdout.toString();
+            const innerError = this.findInnerError(stdout);
+            throw new DetoxRuntimeError(innerError);
+        }
+    }
+
+    findInnerError(stdout) {
+        const match = stdout.match(/DTXError: .*/);
+        return match ?
+            match[0].split('DTXError: ')[1] :
+            `XCUITest runner failed with no error message. Runner stdout: ${stdout}`;
+    }
+}
+
+module.exports = XCUITestRunner;

package/src/ios/expectTwo.js

@@ -1,13 +1,11 @@
 // @ts-nocheck
-const assert = require('assert');
 const path = require('path');
 
 const fs = require('fs-extra');
 const _ = require('lodash');
 const tempfile = require('tempfile');
 
-
-const { assertEnum, assertNormalized } = require('../utils/assertArgument');
+const { assertTraceDescription, assertEnum, assertNormalized } = require('../utils/assertArgument');
 const { removeMilliseconds } = require('../utils/dateUtils');
 const { actionDescription, expectDescription } = require('../utils/invocationTraceDescriptions');
 const { isRegExp } = require('../utils/isRegExp');
@@ -15,8 +13,10 @@ const log = require('../utils/logger').child({ cat: 'ws-client, ws' });
 const mapLongPressArguments = require('../utils/mapLongPressArguments');
 const traceInvocationCall = require('../utils/traceInvocationCall').bind(null, log);
 
+const { systemElement, systemMatcher, systemExpect, isSystemElement } = require('./system');
 const { webElement, webMatcher, webExpect, isWebElement } = require('./web');
 
+
 const assertDirection = assertEnum(['left', 'right', 'up', 'down']);
 const assertSpeed = assertEnum(['fast', 'slow']);
 
@@ -27,6 +27,11 @@ class Expect {
     this.modifiers = [];
   }
 
+  get not() {
+    this.modifiers.push('not');
+    return this;
+  }
+
   toBeVisible(percent) {
     if (percent !== undefined && (!Number.isSafeInteger(percent) || percent < 1 || percent > 100)) {
       throw new Error('`percent` must be an integer between 1 and 100, but got '
@@ -104,11 +109,6 @@ class Expect {
     return this.toHaveValue(`${Number(value)}`);
   }
 
-  get not() {
-    this.modifiers.push('not');
-    return this;
-  }
-
   createInvocation(expectation, ...params) {
     const definedParams = _.without(params, undefined);
     return {
@@ -122,7 +122,7 @@ class Expect {
   }
 
   expect(expectation, traceDescription, ...params) {
-    assert(traceDescription, `must provide trace description for expectation: \n ${JSON.stringify(expectation)}`);
+    assertTraceDescription(traceDescription);
 
     const invocation = this.createInvocation(expectation, ...params);
     traceDescription = expectDescription.full(traceDescription, this.modifiers.includes('not'));
@@ -374,6 +374,14 @@ class InternalElement extends Element {
 }
 
 class By {
+  get web() {
+    return webMatcher();
+  }
+
+  get system() {
+    return systemMatcher();
+  }
+
   id(id) {
     return new Matcher().id(id);
   }
@@ -401,13 +409,18 @@ class By {
   value(value) {
     return new Matcher().value(value);
   }
-
-  get web() {
-    return webMatcher();
-  }
 }
 
 class Matcher {
+  /** @private */
+  static *predicates(matcher) {
+    if (matcher.predicate.type === 'and') {
+      yield* matcher.predicate.predicates;
+    } else {
+      yield matcher.predicate;
+    }
+  }
+
   accessibilityLabel(label) {
     return this.label(label);
   }
@@ -477,15 +490,6 @@ class Matcher {
 
     return result;
   }
-
-  /** @private */
-  static *predicates(matcher) {
-    if (matcher.predicate.type === 'and') {
-      yield* matcher.predicate.predicates;
-    } else {
-      yield matcher.predicate;
-    }
-  }
 }
 
 class WaitFor {
@@ -496,6 +500,11 @@ class WaitFor {
     this._emitter = emitter;
   }
 
+  get not() {
+    this.expectation.not;
+    return this;
+  }
+
   toBeVisible(percent) {
     this.expectation = this.expectation.toBeVisible(percent);
     return this;
@@ -566,11 +575,6 @@ class WaitFor {
     return this;
   }
 
-  get not() {
-    this.expectation.not;
-    return this;
-  }
-
   withTimeout(timeout) {
     if (typeof timeout !== 'number') throw new Error('text should be a number, but got ' + (timeout + (' (' + (typeof timeout + ')'))));
     if (timeout < 0) throw new Error('timeout must be larger than 0');
@@ -735,6 +739,7 @@ function element(invocationManager, emitter, matcher) {
   if (!(matcher instanceof Matcher)) {
     throwMatcherError(matcher);
   }
+
   return new Element(invocationManager, emitter, matcher);
 }
 
@@ -742,6 +747,7 @@ function expect(invocationManager, element) {
   if (!(element instanceof Element)) {
     throwMatcherError(element);
   }
+
   return new Expect(invocationManager, element);
 }
 
@@ -753,8 +759,9 @@ function waitFor(invocationManager, emitter, element) {
 }
 
 class IosExpect {
-  constructor({ invocationManager, emitter }) {
+  constructor({ invocationManager, xcuitestRunner, emitter }) {
     this._invocationManager = invocationManager;
+    this._xcuitestRunner = xcuitestRunner;
     this._emitter = emitter;
     this.element = this.element.bind(this);
     this.expect = this.expect.bind(this);
@@ -762,6 +769,8 @@ class IosExpect {
     this.by = new By();
     this.web = this.web.bind(this);
     this.web.element = this.web().element;
+    this.system = this.system.bind(this);
+    this.system.element = this.system().element;
   }
 
   element(matcher) {
@@ -769,6 +778,10 @@ class IosExpect {
   }
 
   expect(element) {
+    if (isSystemElement(element)) {
+      return systemExpect(this._xcuitestRunner, element);
+    }
+
     if (isWebElement(element)) {
       return webExpect(this._invocationManager, element);
     }
@@ -798,6 +811,14 @@ class IosExpect {
       }
     };
   }
+
+  system() {
+    return {
+      element: systemMatcher => {
+        return systemElement(this._xcuitestRunner, systemMatcher);
+      }
+    };
+  }
 }
 
 function _assertValidPoint(point) {

package/src/ios/system.js

@@ -0,0 +1,124 @@
+const { DetoxRuntimeError } = require('../errors');
+const { assertTraceDescription } = require('../utils/assertArgument');
+const { systemActionDescription, expectDescription } = require('../utils/invocationTraceDescriptions');
+const log = require('../utils/logger').child({ cat: 'ws-client, ws' });
+const traceInvocationCall = require('../utils/traceInvocationCall').bind(null, log);
+
+
+class SystemExpect {
+  constructor(xcuitestRunner, element) {
+    this._xcuitestRunner = xcuitestRunner;
+    this.element = element;
+    this.modifiers = [];
+  }
+
+  toExist() {
+    const traceDescription = expectDescription.toExist();
+    return this.expect('toExist', traceDescription);
+  }
+
+  get not() {
+    this.modifiers.push('not');
+    return this;
+  }
+
+  createInvocation(systemExpectation) {
+    return {
+      type: 'systemExpectation',
+      systemPredicate: this.element.matcher.predicate,
+      ...(this.element.index !== undefined && { systemAtIndex: this.element.index }),
+      ...(this.modifiers.length !== 0 && { systemModifiers: this.modifiers }),
+      systemExpectation
+    };
+  }
+
+  expect(expectation, traceDescription) {
+    assertTraceDescription(traceDescription);
+
+    const invocation = this.createInvocation(expectation);
+    traceDescription = expectDescription.full(traceDescription, this.modifiers.includes('not'));
+    return _executeInvocation(this._xcuitestRunner, invocation, traceDescription);
+  }
+}
+
+class SystemElement {
+  constructor(xcuitestRunner, matcher, index) {
+    this._xcuitestRunner = xcuitestRunner;
+    this.matcher = matcher;
+    this.index = index;
+  }
+
+  atIndex(index) {
+    if (typeof index !== 'number' || index < 0) throw new DetoxRuntimeError(`index should be an integer, got ${index} (${typeof index})`);
+    this.index = index;
+    return this;
+  }
+
+  tap() {
+    const traceDescription = systemActionDescription.tap();
+    return this.withAction('tap', traceDescription);
+  }
+
+  withAction(action, traceDescription) {
+    assertTraceDescription(traceDescription);
+
+    const invocation = {
+      type: 'systemAction',
+      systemPredicate: this.matcher.predicate,
+      ...(this.index !== undefined && { systemAtIndex: this.index }),
+      systemAction: action
+    };
+    traceDescription = systemActionDescription.full(traceDescription);
+    return _executeInvocation(this._xcuitestRunner, invocation, traceDescription);
+  }
+}
+
+class SystemElementMatcher {
+  label(label) {
+    if (typeof label !== 'string') throw new DetoxRuntimeError('label should be a string, but got ' + (label + (' (' + typeof label + ')')));
+    this.predicate = { type: 'label', value: label.toString() };
+    return this;
+  }
+
+  type(type) {
+    if (typeof type !== 'string') throw new DetoxRuntimeError('type should be a string, but got ' + (type + (' (' + typeof type + ')')));
+    this.predicate = { type: 'type', value: type.toString() };
+    return this;
+  }
+}
+
+function systemMatcher() {
+  return new SystemElementMatcher();
+}
+
+function systemElement(xcuitestRunner, matcher) {
+  if (!(matcher instanceof SystemElementMatcher)) {
+    throwSystemMatcherError(matcher);
+  }
+
+  return new SystemElement(xcuitestRunner, matcher);
+}
+
+function throwSystemMatcherError(param) {
+  const paramDescription = JSON.stringify(param);
+  throw new DetoxRuntimeError(`${paramDescription} is not a Detox system matcher. More about system matchers here: https://wix.github.io/Detox/docs/api/system`);
+}
+
+function systemExpect(xcuitestRunner, element) {
+  return new SystemExpect(xcuitestRunner, element);
+}
+
+function _executeInvocation(xcuitestRunner, invocation, traceDescription) {
+  return traceInvocationCall(traceDescription, invocation, xcuitestRunner.execute(invocation));
+}
+
+function isSystemElement(element) {
+  return element instanceof SystemElement;
+}
+
+module.exports = {
+  systemMatcher,
+  systemElement,
+  systemExpect,
+  isSystemElement
+};

package/src/ios/web.js

@@ -1,8 +1,7 @@
-const assert = require('assert');
-
 const _ = require('lodash');
 
 const { DetoxRuntimeError } = require('../errors');
+const { assertTraceDescription } = require('../utils/assertArgument');
 const { webViewActionDescription, expectDescription } = require('../utils/invocationTraceDescriptions');
 const log = require('../utils/logger').child({ cat: 'ws-client, ws' });
 const traceInvocationCall = require('../utils/traceInvocationCall').bind(null, log);
@@ -48,7 +47,7 @@ class WebExpect {
   }
 
   expect(expectation, traceDescription, ...params) {
-    assert(traceDescription, `must provide trace description for expectation: \n ${JSON.stringify(expectation)}`);
+    assertTraceDescription(traceDescription);
 
     const invocation = this.createInvocation(expectation, ...params);
     traceDescription = expectDescription.full(traceDescription, this.modifiers.includes('not'));
@@ -170,7 +169,7 @@ class WebElement {
   }
 
   withAction(action, traceDescription, ...params) {
-    assert(traceDescription, `must provide trace description for action: \n ${JSON.stringify(action)}`);
+    assertTraceDescription(traceDescription);
 
     const invocation = {
       type: 'webAction',

package/src/matchers/factories/index.js

@@ -12,19 +12,20 @@ class Android extends MatchersFactory {
 }
 
 class Ios extends MatchersFactory {
-  createMatchers({ invocationManager, eventEmitter }) {
+  createMatchers({ invocationManager, runtimeDevice, eventEmitter }) {
     const IosExpect = require('../../ios/expectTwo');
-    return new IosExpect({ invocationManager, emitter: eventEmitter });
+    const XCUITestRunner = require('../../ios/XCUITestRunner');
+    const xcuitestRunner = new XCUITestRunner({ simulatorId: runtimeDevice.id });
+
+    return new IosExpect({
+      invocationManager,
+      xcuitestRunner,
+      emitter: eventEmitter
+    });
   }
 }
 
 class External extends MatchersFactory {
-  static validateModule(module, path) {
-    if (!module.ExpectClass) {
-      throw new DetoxRuntimeError(`The custom driver at '${path}' does not export the ExpectClass property`);
-    }
-  }
-
   constructor(module, path) {
     super();
     External.validateModule(module, path);
@@ -32,6 +33,12 @@ class External extends MatchersFactory {
     this._module = module;
   }
 
+  static validateModule(module, path) {
+    if (!module.ExpectClass) {
+      throw new DetoxRuntimeError(`The custom driver at '${path}' does not export the ExpectClass property`);
+    }
+  }
+
   createMatchers(deps) {
     return new this._module.ExpectClass(deps);
   }