detox 20.0.6-breaking.new-global-lifecycle.0 → 20.0.7-prerelease.0

package/src/android/core/NativeExpect.js

@@ -1,3 +1,4 @@
+const { expectDescription } = require('../../utils/invocationTraceDescriptions');
 const { MatcherAssertionInteraction } = require('../interactions/native');
 const matchers = require('../matchers/native');
 
@@ -19,7 +20,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toBeVisible(pct) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.VisibleMatcher(pct).not : new matchers.VisibleMatcher(pct)).execute();
+    const matcher = new matchers.VisibleMatcher(pct);
+    const traceDescription = expectDescription.toBeVisible(pct);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeNotVisible() {
@@ -27,7 +30,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toExist() {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ExistsMatcher().not : new matchers.ExistsMatcher()).execute();
+    const matcher = new matchers.ExistsMatcher();
+    const traceDescription = expectDescription.toExist();
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotExist() {
@@ -35,7 +40,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveText(text) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.TextMatcher(text).not : new matchers.TextMatcher(text)).execute();
+    const matcher = new matchers.TextMatcher(text);
+    const traceDescription = expectDescription.toHaveText(text);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveText(text) {
@@ -43,7 +50,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveLabel(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.LabelMatcher(value).not : new matchers.LabelMatcher(value)).execute();
+    const matcher = new matchers.LabelMatcher(value);
+    const traceDescription = expectDescription.toHaveLabel(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveLabel(value) {
@@ -51,7 +60,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveId(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.IdMatcher(value).not : new matchers.IdMatcher(value)).execute();
+    const matcher = new matchers.IdMatcher(value);
+    const traceDescription = expectDescription.toHaveId(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveId(value) {
@@ -59,7 +70,9 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveValue(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ValueMatcher(value).not : new matchers.ValueMatcher(value)).execute();
+    const matcher = new matchers.ValueMatcher(value);
+    const traceDescription = expectDescription.toHaveValue(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toNotHaveValue(value) {
@@ -67,15 +80,21 @@ class NativeExpectElement extends NativeExpect {
   }
 
   async toHaveToggleValue(value) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.ToggleMatcher(value).not : new matchers.ToggleMatcher(value)).execute();
+    const matcher = new matchers.ToggleMatcher(value);
+    const traceDescription = expectDescription.toHaveToggleValue(value);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toHaveSliderPosition(value, tolerance = 0) {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.SliderPositionMatcher(value, tolerance).not : new matchers.SliderPositionMatcher(value, tolerance)).execute();
+    const matcher = new matchers.SliderPositionMatcher(value, tolerance);
+    const traceDescription = expectDescription.toHaveSliderPosition(value, tolerance);
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeFocused() {
-    return await new MatcherAssertionInteraction(this._invocationManager, this._element, this._notCondition ? new matchers.FocusMatcher().not : new matchers.FocusMatcher()).execute();
+    const matcher = new matchers.FocusMatcher();
+    const traceDescription = expectDescription.toBeFocused();
+    return await new MatcherAssertionInteraction(this._invocationManager, this._element, matcher, this._notCondition, traceDescription).execute();
   }
 
   async toBeNotFocused() {

package/src/android/interactions/native.js

@@ -1,4 +1,6 @@
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
+const { expectDescription, actionDescription } = require('../../utils/invocationTraceDescriptions');
+const { trace } = require('../../utils/trace');
 const { ScrollAmountStopAtEdgeAction } = require('../actions/native');
 const { NativeMatcher } = require('../core/NativeMatcher');
 const DetoxAssertionApi = require('../espressoapi/DetoxAssertion');
@@ -9,45 +11,50 @@ function call(maybeAFunction) {
 }
 
 class Interaction {
-  constructor(invocationManager) {
+  constructor(invocationManager, traceDescription) {
     this._call = undefined;
+    this._traceDescription = traceDescription;
     this._invocationManager = invocationManager;
   }
 
   async execute() {
-    const resultObj = await this._invocationManager.execute(this._call);
-    return resultObj ? resultObj.result : undefined;
+    return trace.invocationCall(this._traceDescription, this._call,
+      this._invocationManager.execute(this._call).then((resultObj) => resultObj ? resultObj.result : undefined));
   }
 }
 
 class ActionInteraction extends Interaction {
-  constructor(invocationManager, element, action) {
-    super(invocationManager);
+  constructor(invocationManager, element, action, traceDescription) {
+    super(invocationManager, traceDescription);
     this._call = EspressoDetoxApi.perform(call(element._call), action._call);
     // TODO: move this.execute() here from the caller
   }
 }
 
 class MatcherAssertionInteraction extends Interaction {
-  constructor(invocationManager, element, matcher) {
-    super(invocationManager);
+  constructor(invocationManager, element, matcher, notCondition, traceDescription) {
+    traceDescription = expectDescription.full(traceDescription, notCondition);
+    super(invocationManager, traceDescription);
+
+    matcher = notCondition ? matcher.not : matcher;
     this._call = DetoxAssertionApi.assertMatcher(call(element._call), matcher._call.value);
     // TODO: move this.execute() here from the caller
   }
 }
 
 class WaitForInteraction extends Interaction {
-  constructor(invocationManager, element, assertionMatcher) {
-    super(invocationManager);
+  constructor(invocationManager, element, assertionMatcher, expectTraceDescription) {
+    super(invocationManager, expectTraceDescription);
     this._element = element;
     this._assertionMatcher = assertionMatcher;
     this._element._selectElementWithMatcher(this._element._originalMatcher);
   }
 
   async withTimeout(timeout) {
-    if (typeof timeout !== 'number') throw new DetoxRuntimeError(`WaitForInteraction withTimeout argument must be a number, got ${typeof timeout}`);
-    if (timeout < 0) throw new DetoxRuntimeError('timeout must be larger than 0');
+    if (typeof timeout !== 'number') throw new DetoxRuntimeError({ message: `WaitForInteraction withTimeout argument must be a number, got ${typeof timeout}` });
+    if (timeout < 0) throw new DetoxRuntimeError({ message: 'timeout must be larger than 0' });
 
+    this._traceDescription = expectDescription.waitForWithTimeout(this._traceDescription, timeout);
     this._call = DetoxAssertionApi.waitForAssertMatcher(call(this._element._call), this._assertionMatcher._call.value, timeout / 1000);
     await this.execute();
   }
@@ -58,20 +65,18 @@ class WaitForInteraction extends Interaction {
 }
 
 class WaitForActionInteractionBase extends Interaction {
-  constructor(invocationManager, element, matcher, searchMatcher) {
-    super(invocationManager);
-    //if (!(element instanceof NativeElement)) throw new DetoxRuntimeError(`WaitForActionInteraction ctor 1st argument must be a valid NativeElement, got ${typeof element}`);
-    //if (!(matcher instanceof NativeMatcher)) throw new DetoxRuntimeError(`WaitForActionInteraction ctor 2nd argument must be a valid NativeMatcher, got ${typeof matcher}`);
+  constructor(invocationManager, element, matcher, searchMatcher, traceDescription) {
+    super(invocationManager, traceDescription);
+
     if (!(searchMatcher instanceof NativeMatcher))
-      throw new DetoxRuntimeError(`WaitForActionInteraction ctor 3rd argument must be a valid NativeMatcher, got ${typeof searchMatcher}`);
+      throw new DetoxRuntimeError({ message: `WaitForActionInteraction ctor 3rd argument must be a valid NativeMatcher, got ${typeof searchMatcher}` });
+
     this._element = element;
     this._originalMatcher = matcher;
     this._searchMatcher = searchMatcher;
   }
 
   _prepare(searchAction) {
-    //if (!searchAction instanceof Action) throw new DetoxRuntimeError(`WaitForActionInteraction _execute argument must be a valid Action, got ${typeof searchAction}`);
-
     this._call = DetoxAssertionApi.waitForAssertMatcherWithSearchAction(
       call(this._element._call),
       call(this._originalMatcher._call).value,
@@ -83,6 +88,7 @@ class WaitForActionInteractionBase extends Interaction {
 
 class WaitForActionInteraction extends WaitForActionInteractionBase {
   async scroll(amount, direction = 'down', scrollPositionX, scrollPositionY) {
+    this._traceDescription = expectDescription.waitFor(actionDescription.scroll(amount, direction, scrollPositionX, scrollPositionY));
     this._prepare(new ScrollAmountStopAtEdgeAction(direction, amount, scrollPositionX, scrollPositionY));
     await this.execute();
   }

package/src/artifacts/timeline/TimelineContextTypes.js

@@ -0,0 +1,7 @@
+const TIMELINE_CONTEXT_TYPES = {
+  TEST: 'test',
+  DESCRIBE: 'describe',
+  INVOCATION: 'invocation'
+};
+
+module.exports = TIMELINE_CONTEXT_TYPES;

package/src/client/Client.js

@@ -34,6 +34,7 @@ class Client {
     this._slowInvocationStatusHandle = null;
     this._whenAppIsConnected = this._invalidState('before connecting to the app');
     this._whenAppIsReady = this._whenAppIsConnected;
+    this._whenAppDisconnected = Deferred.resolved();
     this._isCleaningUp = false;
     this._pendingAppCrash = null;
     this._appTerminationHandle = null;
@@ -201,6 +202,11 @@ class Client {
     }
   }
 
+  /** @async */
+  waitUntilDisconnected() {
+    return this._whenAppDisconnected.promise;
+  }
+
   async waitForBackground() {
     await this.sendAction(new actions.WaitForBackground());
   }
@@ -301,6 +307,8 @@ class Client {
     } else {
       this._whenAppIsConnected = Deferred.resolved();
     }
+
+    this._whenAppDisconnected = new Deferred();
   }
 
   _onAppReady() {
@@ -320,6 +328,10 @@ class Client {
   }
 
   _onBeforeAppCrash({ params }) {
+    if (this._pendingAppCrash) {
+      return;
+    }
+
     this._pendingAppCrash = new DetoxRuntimeError({
       message: 'The app has crashed, see the details below:',
       debugInfo: params.errorDetails,
@@ -338,10 +350,15 @@ class Client {
     this._whenAppIsReady = this._whenAppIsConnected;
 
     if (this._pendingAppCrash) {
+      this._whenAppDisconnected.reject(this._pendingAppCrash);
       this._asyncWebSocket.rejectAll(this._pendingAppCrash);
       this._pendingAppCrash = null;
     } else if (this._asyncWebSocket.hasPendingActions()) {
-      this._asyncWebSocket.rejectAll(new DetoxRuntimeError('The app has unexpectedly disconnected from Detox server.'));
+      const error = new DetoxRuntimeError('The app has unexpectedly disconnected from Detox server.');
+      this._asyncWebSocket.rejectAll(error);
+      this._whenAppDisconnected.resolve();
+    } else {
+      this._whenAppDisconnected.resolve();
     }
   }
 

package/src/devices/common/drivers/android/tools/MonitoredInstrumentation.js

@@ -77,7 +77,7 @@ class MonitoredInstrumentation {
         'while it was waiting for "ready" message (over WebSocket) ' +
         'from the instrumentation process.',
       debugInfo: this.instrumentationStackTrace
-        ? `Native stacktrace dump: ${this.instrumentationStackTrace}`
+        ? `Native stacktrace dump:\n${this.instrumentationStackTrace}`
         : '',
     });
   }

package/src/devices/common/drivers/ios/tools/AppleSimUtils.js

@@ -271,7 +271,9 @@ class AppleSimUtils {
       // ```
       // This workaround is done to ignore the error above, as we do not care if the app was running before, we just
       // want to make sure it isn't now.
-      if (err.code === 3 && err.stderr.includes(`the app is not currently running`)) {
+      if (err.code === 3 && 
+          (err.stderr.includes(`the app is not currently running`) ||
+           err.stderr.includes(`The operation couldn’t be completed. found nothing to terminate`))) {
         return;
       }
 

package/src/devices/runtime/RuntimeDevice.js

@@ -248,14 +248,12 @@ class RuntimeDevice {
   async installUtilBinaries() {
     const paths = this._deviceConfig.utilBinaryPaths;
     if (paths) {
-      await traceCall('installUtilBinaries', () =>
-        this.deviceDriver.installUtilBinaries(paths));
+      await traceCall('installUtilBinaries', this.deviceDriver.installUtilBinaries(paths));
     }
   }
 
   async reloadReactNative() {
-    await traceCall('reloadRN', () =>
-      this.deviceDriver.reloadReactNative());
+    await traceCall('reload React Native', this.deviceDriver.reloadReactNative());
   }
 
   async openURL(params) {

package/src/devices/runtime/drivers/android/AndroidDriver.js

@@ -148,7 +148,15 @@ class AndroidDriver extends DeviceDriverBase {
 
   async waitUntilReady() {
       try {
-        await Promise.race([super.waitUntilReady(), this.instrumentation.waitForCrash()]);
+        await Promise.race([
+          super.waitUntilReady(),
+          this.instrumentation.waitForCrash()
+        ]);
+      } catch (e) {
+        log.warn({ error: e }, 'An error occurred while waiting for the app to become ready. Waiting for disconnection...');
+        await this.client.waitUntilDisconnected();
+        log.warn('The app disconnected.');
+        throw e;
       } finally {
         this.instrumentation.abortWaitForCrash();
       }