detox 21.0.0-breaking.new-global-lifecycle.0 → 21.0.1-rc.0

package/src/DetoxWorker.js

@@ -1,17 +1,18 @@
+const CAF = require('caf');
 const _ = require('lodash');
 
 const Client = require('./client/Client');
 const environmentFactory = require('./environmentFactory');
 const { DetoxRuntimeErrorComposer } = require('./errors');
 const { InvocationManager } = require('./invoke');
-const symbols = require('./symbols');
+const symbols = require('./realms/symbols');
 const AsyncEmitter = require('./utils/AsyncEmitter');
 const uuid = require('./utils/uuid');
 
 class DetoxWorker {
   constructor(context) {
     this._context = context;
-    this._isCleaningUp = false;
+    this._injectedGlobalProperties = [];
     this._config = context[symbols.config];
     this._runtimeErrorComposer = new DetoxRuntimeErrorComposer(this._config);
     this._client = null;
@@ -32,6 +33,20 @@ class DetoxWorker {
       onError: this._onEmitError.bind(this),
     });
 
+
+    /** @type {DetoxInternals.RuntimeConfig['apps']} */
+    this._appsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['artifacts']} */
+    this._artifactsConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['behavior']} */
+    this._behaviorConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['device']} */
+    this._deviceConfig = null;
+    /** @type {DetoxInternals.RuntimeConfig['session']} */
+    this._sessionConfig = null;
+
+    /** @type {string} */
+    this.id = 'worker';
     /** @type {Detox.Device} */
     this.device = null;
     /** @type {Detox.ElementFacade} */
@@ -51,20 +66,40 @@ class DetoxWorker {
     this.trace = this._context.trace;
     /** @deprecated */
     this.traceCall = this._context.traceCall;
+
+    this._reinstallAppsOnDevice = CAF(this._reinstallAppsOnDevice.bind(this));
+    this._initToken = new CAF.cancelToken();
+
+    this._cafWrap([
+      'init',
+      'onRunDescribeStart',
+      'onTestStart',
+      'onHookFailure',
+      'onTestFnFailure',
+      'onTestDone',
+      'onRunDescribeFinish',
+    ]);
   }
 
-  async init() {
-    if (this._isCleaningUp) return;
+  /** @this {DetoxWorker} */
+  init = function* (signal) {
+    const {
+      apps: appsConfig,
+      artifacts: artifactsConfig,
+      behavior: behaviorConfig,
+      device: deviceConfig,
+      session: sessionConfig
+    } = this._config;
 
-    const { appsConfig, artifactsConfig, behaviorConfig, deviceConfig, sessionConfig } = this._config;
     this._appsConfig = appsConfig;
     this._artifactsConfig = artifactsConfig;
     this._behaviorConfig = behaviorConfig;
     this._deviceConfig = deviceConfig;
     this._sessionConfig = sessionConfig;
+    // @ts-ignore
+    this._sessionConfig.sessionId = sessionConfig.sessionId || uuid.UUID();
     this._runtimeErrorComposer.appsConfig = this._appsConfig;
 
-    sessionConfig.sessionId = sessionConfig.sessionId || uuid.UUID();
     this._client = new Client(sessionConfig);
     this._client.terminateApp = async () => {
       // @ts-ignore
@@ -73,8 +108,7 @@ class DetoxWorker {
       }
     };
 
-    await this._client.connect();
-    if (this._isCleaningUp) return;
+    yield this._client.connect();
 
     const invocationManager = new InvocationManager(this._client);
 
@@ -91,8 +125,7 @@ class DetoxWorker {
     } = environmentFactory.createFactories(this._deviceConfig);
 
     const envValidator = envValidatorFactory.createValidator();
-    await envValidator.validate();
-    if (this._isCleaningUp) return;
+    yield envValidator.validate();
 
     const commonDeps = {
       invocationManager,
@@ -103,8 +136,9 @@ class DetoxWorker {
 
     this._artifactsManager = artifactsManagerFactory.createArtifactsManager(this._artifactsConfig, commonDeps);
     this._deviceAllocator = deviceAllocatorFactory.createDeviceAllocator(commonDeps);
-    this._deviceCookie = await this._deviceAllocator.allocate(this._deviceConfig);
-    if (this._isCleaningUp) return;
+    this._deviceCookie = yield this._deviceAllocator.allocate(this._deviceConfig);
+
+    yield this._deviceAllocator.postAllocate(this._deviceCookie);
 
     this.device = runtimeDeviceFactory.createRuntimeDevice(
       this._deviceCookie,
@@ -115,7 +149,6 @@ class DetoxWorker {
         deviceConfig: this._deviceConfig,
         sessionConfig,
       });
-    if (this._isCleaningUp) return;
 
     const matchers = matchersFactory.createMatchers({
       invocationManager,
@@ -125,34 +158,37 @@ class DetoxWorker {
     Object.assign(this, matchers);
 
     if (behaviorConfig.init.exposeGlobals) {
-      Object.assign(DetoxWorker.global, {
+      const injectedGlobals = {
         ...matchers,
         device: this.device,
         detox: this,
-      });
+      };
+
+      this._injectedGlobalProperties = Object.keys(injectedGlobals);
+      Object.assign(DetoxWorker.global, injectedGlobals);
     }
 
     // @ts-ignore
-    await this.device.installUtilBinaries();
-    if (this._isCleaningUp) return;
+    yield this.device.installUtilBinaries();
 
     if (behaviorConfig.init.reinstallApp) {
-      await this._reinstallAppsOnDevice();
-      if (this._isCleaningUp) return;
+      yield this._reinstallAppsOnDevice(signal);
     }
 
     const appAliases = Object.keys(this._appsConfig);
     if (appAliases.length === 1) {
-      await this.device.selectApp(appAliases[0]);
+      yield this.device.selectApp(appAliases[0]);
     } else {
-      await this.device.selectApp(null);
+      yield this.device.selectApp(null);
     }
-
-    return this;
-  }
+  };
 
   async cleanup() {
-    this._isCleaningUp = true;
+    this._initToken.abort('CLEANUP');
+
+    for (const key of this._injectedGlobalProperties) {
+      delete DetoxWorker.global[key];
+    }
 
     if (this._artifactsManager) {
       await this._artifactsManager.onBeforeCleanup();
@@ -166,9 +202,12 @@ class DetoxWorker {
     }
 
     if (this.device) {
-      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
       // @ts-ignore
       await this.device._cleanup();
+    }
+
+    if (this._deviceCookie) {
+      const shutdown = this._behaviorConfig ? this._behaviorConfig.cleanup.shutdownDevice : false;
       await this._deviceAllocator.free(this._deviceCookie, { shutdown });
     }
 
@@ -181,46 +220,45 @@ class DetoxWorker {
     return this._context.log;
   }
 
-  onRunStart = async (...args) => this._artifactsManager.onRunStart(...args);
-  onRunDescribeStart = async (...args) => this._artifactsManager.onRunDescribeStart(...args);
-  onTestStart = async (testSummary) => {
-    if (this._isCleaningUp) return;
+  onRunDescribeStart = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeStart(...args);
+  };
+
+  onTestStart = function* (_signal, testSummary) {
     this._validateTestSummary('beforeEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_BEFORE_EACH', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: false,
       testName: testSummary.fullName,
     });
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestStart(testSummary);
+    yield this._artifactsManager.onTestStart(testSummary);
+  };
+
+  onHookFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onHookFailure(...args);
+  };
+
+  onTestFnFailure = function* (_signal, ...args) {
+    yield this._artifactsManager.onTestFnFailure(...args);
   };
-  onHookStart = async (...args) => this._artifactsManager.onHookStart(...args);
-  onHookFailure = async (...args) => this._artifactsManager.onHookFailure(...args);
-  onHookSuccess = async (...args) => this._artifactsManager.onHookSuccess(...args);
-  onTestFnStart = async (...args) => this._artifactsManager.onTestFnStart(...args);
-  onTestFnFailure = async (...args) => this._artifactsManager.onTestFnFailure(...args);
-  onTestFnSuccess = async (...args) => this._artifactsManager.onTestFnSuccess(...args);
-  onTestDone = async (testSummary) => {
-    if (this._isCleaningUp) return;
+
+  onTestDone = function* (_signal, testSummary) {
     this._validateTestSummary('afterEach', testSummary);
-    this._logTestRunCheckpoint('DETOX_AFTER_EACH', testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._artifactsManager.onTestDone(testSummary);
+    yield this._artifactsManager.onTestDone(testSummary);
 
-    if (this._isCleaningUp) return;
-    await this._dumpUnhandledErrorsIfAny({
+    yield this._dumpUnhandledErrorsIfAny({
       pendingRequests: testSummary.timedOut,
       testName: testSummary.fullName,
     });
   };
-  onRunDescribeFinish = async (...args) => this._artifactsManager.onRunDescribeFinish(...args);
-  onRunFinish = async (...args) => this._artifactsManager.onRunFinish(...args);
 
-  async _reinstallAppsOnDevice() {
+  onRunDescribeFinish = function* (_signal, ...args) {
+    yield this._artifactsManager.onRunDescribeFinish(...args);
+  };
+
+  *_reinstallAppsOnDevice(_signal) {
     const appNames = _(this._appsConfig)
       .map((config, key) => [key, `${config.binaryPath}:${config.testBinaryPath}`])
       .uniqBy(1)
@@ -228,24 +266,16 @@ class DetoxWorker {
       .value();
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.uninstallApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.uninstallApp();
     }
 
     for (const appName of appNames) {
-      await this.device.selectApp(appName);
-      if (this._isCleaningUp) return;
-      await this.device.installApp();
-      if (this._isCleaningUp) return;
+      yield this.device.selectApp(appName);
+      yield this.device.installApp();
     }
   }
 
-  _logTestRunCheckpoint(event, { status, fullName }) {
-    this.log.trace({ event, status }, `${status} test: ${JSON.stringify(fullName)}`);
-  }
-
   _validateTestSummary(methodName, testSummary) {
     if (!_.isPlainObject(testSummary)) {
       throw this._runtimeErrorComposer.invalidTestSummary(methodName, testSummary);
@@ -274,10 +304,28 @@ class DetoxWorker {
       error
     );
   }
+
+  _cafWrap(methodNames) {
+    for (const methodName of methodNames) {
+      const cafMethod = CAF(this[methodName].bind(this));
+      this[methodName] = async (...args) => {
+        try {
+          await cafMethod(this._initToken.signal, ...args);
+        } catch (e) {
+          if (e !== 'CLEANUP') {
+            throw e;
+          }
+        }
+
+        return this;
+      };
+    }
+  }
+
 }
 
 /**
- * @type {NodeJS.Global}
+ * @type {NodeJS.Global | {}}
  */
 DetoxWorker.global = global;
 

package/src/android/actions/native.js

@@ -124,6 +124,13 @@ class ScrollToIndex extends Action {
   }
 }
 
+class SetDatePickerDateAction extends Action {
+  constructor(dateString, formatString) {
+    super();
+    this._call = invoke.callDirectly(DetoxActionApi.setDatePickerDate(dateString, formatString));
+  }
+}
+
 class AdjustSliderToPosition extends Action {
   constructor(newPosition) {
     super();
@@ -138,6 +145,13 @@ class TakeElementScreenshot extends Action {
   }
 }
 
+class AccessibilityActionAction extends Action {
+  constructor(actionName) {
+    super();
+    this._call = invoke.callDirectly(DetoxActionApi.accessibilityAction(actionName));
+  }
+}
+
 module.exports = {
   Action,
   TapAction,
@@ -155,5 +169,7 @@ module.exports = {
   SwipeAction,
   TakeElementScreenshot,
   ScrollToIndex,
+  SetDatePickerDateAction,
   AdjustSliderToPosition,
+  AccessibilityActionAction
 };

package/src/android/core/NativeElement.js

@@ -5,6 +5,8 @@ const tempfile = require('tempfile');
 
 const DetoxRuntimeError = require('../../errors/DetoxRuntimeError');
 const invoke = require('../../invoke');
+const { removeMilliseconds } = require('../../utils/dateUtils');
+const { actionDescription } = require('../../utils/invocationTraceDescriptions');
 const actions = require('../actions/native');
 const DetoxMatcherApi = require('../espressoapi/DetoxMatcher');
 const { ActionInteraction } = require('../interactions/native');
@@ -18,12 +20,11 @@ class NativeElement {
   }
 
   _selectElementWithMatcher(matcher) {
-    // if (!(matcher instanceof NativeMatcher)) throw new DetoxRuntimeError(`Element _selectElementWithMatcher argument must be a valid NativeMatcher, got ${typeof matcher}`);
     this._call = invoke.call(invoke.Espresso, 'onView', matcher._call);
   }
 
   atIndex(index) {
-    if (typeof index !== 'number') throw new DetoxRuntimeError(`Element atIndex argument must be a number, got ${typeof index}`);
+    if (typeof index !== 'number') throw new DetoxRuntimeError({ message: `Element atIndex argument must be a number, got ${typeof index}` });
     const matcher = this._originalMatcher;
     this._originalMatcher._call = invoke.callDirectly(DetoxMatcherApi.matcherForAtIndex(index, matcher._call.value));
 
@@ -32,56 +33,94 @@ class NativeElement {
   }
 
   async tap(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TapAction(value)).execute();
+    const action = new actions.TapAction(value);
+    const traceDescription = actionDescription.tapAtPoint(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapAtPoint(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TapAtPointAction(value)).execute();
+    const action = new actions.TapAtPointAction(value);
+    const traceDescription = actionDescription.tapAtPoint(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async longPress() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.LongPressAction()).execute();
+    const action = new actions.LongPressAction();
+    const traceDescription = actionDescription.longPress();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async multiTap(times) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.MultiClickAction(times)).execute();
+    if (typeof times !== 'number') throw new Error('times should be a number, but got ' + (times + (' (' + (typeof times + ')'))));
+    if (times < 1) throw new Error('times should be greater than 0, but got ' + times);
+
+    const action = new actions.MultiClickAction(times);
+    const traceDescription = actionDescription.multiTap(times);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapBackspaceKey() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.PressKeyAction(67)).execute();
+    const action = new actions.PressKeyAction(67);
+    const traceDescription = actionDescription.tapBackspaceKey();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async tapReturnKey() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TypeTextAction('\n')).execute();
+    const action = new actions.TypeTextAction('\n');
+    const traceDescription = actionDescription.tapReturnKey();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async typeText(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.TypeTextAction(value)).execute();
+    const action = new actions.TypeTextAction(value);
+    const traceDescription = actionDescription.typeText(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async replaceText(value) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.ReplaceTextAction(value)).execute();
+    const action = new actions.ReplaceTextAction(value);
+    const traceDescription = actionDescription.replaceText(value);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async clearText() {
-    return await new ActionInteraction(this._invocationManager, this, new actions.ClearTextAction()).execute();
+    const action = new actions.ClearTextAction();
+    const traceDescription = actionDescription.clearText();
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scroll(amount, direction = 'down', startPositionX, startPositionY) {
-    // override the user's element selection with an extended matcher that looks for UIScrollView children
-    // this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY)).execute();
+    const action = new actions.ScrollAmountAction(direction, amount, startPositionX, startPositionY);
+    const traceDescription = actionDescription.scroll(amount, direction, startPositionX, startPositionY);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scrollTo(edge) {
     // override the user's element selection with an extended matcher that looks for UIScrollView children
     this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollEdgeAction(edge)).execute();
+
+    const action = new actions.ScrollEdgeAction(edge);
+    const traceDescription = actionDescription.scrollTo(edge);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async scrollToIndex(index) {
+    // override the user's element selection with an extended matcher that looks for UIScrollView children
     this._selectElementWithMatcher(this._originalMatcher._extendToDescendantScrollViews());
-    return await new ActionInteraction(this._invocationManager, this, new actions.ScrollToIndex(index)).execute();
+
+    const action = new actions.ScrollToIndex(index);
+    const traceDescription = actionDescription.scrollToIndex(index);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+  }
+
+  async setDatePickerDate(rawDateString, formatString) {
+    const dateString = formatString === 'ISO8601'
+      ? removeMilliseconds(rawDateString)
+      : rawDateString;
+
+    const action = new actions.SetDatePickerDateAction(dateString, formatString);
+    const traceDescription = actionDescription.setDatePickerDate(dateString, formatString);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   /**
@@ -96,13 +135,17 @@ class NativeElement {
 
     // override the user's element selection with an extended matcher that avoids RN issues with RCTScrollView
     this._selectElementWithMatcher(this._originalMatcher._avoidProblematicReactNativeElements());
+
     const action = new actions.SwipeAction(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
-    return await new ActionInteraction(this._invocationManager, this, action).execute();
+    const traceDescription = actionDescription.swipe(direction, speed, normalizedSwipeOffset, normalizedStartingPointX, normalizedStartingPointY);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
   }
 
   async takeScreenshot(screenshotName) {
     // TODO this should be moved to a lower-layer handler of this use-case
-    const resultBase64 = await new ActionInteraction(this._invocationManager, this, new actions.TakeElementScreenshot()).execute();
+    const action = new actions.TakeElementScreenshot();
+    const traceDescription = actionDescription.takeScreenshot(screenshotName);
+    const resultBase64 = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
     const filePath = tempfile('detox.element-screenshot.png');
     await fs.writeFile(filePath, resultBase64, 'base64');
 
@@ -115,12 +158,21 @@ class NativeElement {
   }
 
   async getAttributes() {
-    const result = await new ActionInteraction(this._invocationManager, this, new actions.GetAttributes()).execute();
+    const action = new actions.GetAttributes();
+    const traceDescription = actionDescription.getAttributes();
+    const result = await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
     return JSON.parse(result);
   }
 
   async adjustSliderToPosition(newPosition) {
-    return await new ActionInteraction(this._invocationManager, this, new actions.AdjustSliderToPosition(newPosition)).execute();
+    const action = new actions.AdjustSliderToPosition(newPosition);
+    const traceDescription = actionDescription.adjustSliderToPosition(newPosition);
+    return await new ActionInteraction(this._invocationManager, this, action, traceDescription).execute();
+  }
+
+  async performAccessibilityAction(actionName) {
+    const traceDescription = actionDescription.performAccessibilityAction(actionName);
+    return await new ActionInteraction(this._invocationManager, this, new actions.AccessibilityActionAction(actionName), traceDescription).execute();
   }
 }
 

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() {