@koenvanbelle/cypress-soft-assertions 2.4.2 → 2.4.4

package/dist/index.js

@@ -81,7 +81,13 @@ function patchChaiAssertions() {
     assertionProto.assert = patchedAssertionAssert;
 }
 function resolveStableToken(assertionContext, args) {
-    return (0, utils_1.resolveToken)((0, utils_1.getAssertionToken)(assertionContext, args), getRetryableCommandId(), args);
+    const assertionToken = (0, utils_1.getAssertionToken)(assertionContext, args);
+    if (assertionToken)
+        return assertionToken;
+    const commandId = getRetryableCommandId();
+    if (commandId)
+        return (0, utils_1.resolveToken)('', commandId, args);
+    return '';
 }
 function isRunningHookContext() {
     var _a;
@@ -95,23 +101,24 @@ function isRunningHookContext() {
     }
 }
 function patchedAssertionAssert(...args) {
+    var _a;
     if (!originalChaiAssert)
         return;
+    // Fast path for non-soft tests: avoid try/catch and token logic entirely.
+    if (!isInSoftTest) {
+        return originalChaiAssert.apply(this, args);
+    }
     try {
         const result = originalChaiAssert.apply(this, args);
         // Assertion passed — clear any staged failure for this token.
-        if (isInSoftTest) {
-            const token = resolveStableToken(this, args);
-            if (token) {
-                retryAssertionFailures.delete(token);
-                retryFirstSeen.delete(token);
-            }
+        const token = resolveStableToken(this, args);
+        if (token) {
+            retryAssertionFailures.delete(token);
+            retryFirstSeen.delete(token);
         }
         return result;
     }
     catch (error) {
-        if (!isInSoftTest)
-            throw error;
         if (isRunningHookContext())
             throw error;
         const errorEntry = {
@@ -120,22 +127,30 @@ function patchedAssertionAssert(...args) {
         };
         const token = resolveStableToken(this, args);
         if (token) {
-            // Track when we first saw this failure.
-            if (!retryFirstSeen.has(token)) {
-                retryFirstSeen.set(token, Date.now());
-            }
             // Stage the failure so it can be cleared if a later retry succeeds.
             retryAssertionFailures.set(token, errorEntry);
-            // Check if the retry window has expired. Swallow slightly before
-            // Cypress's own timeout to prevent it from firing the fail event.
-            // Cypress retries every ~50ms, so subtracting 100ms ensures we
-            // catch at least 1-2 more retries before the deadline.
-            const elapsed = Date.now() - retryFirstSeen.get(token);
+            const current = cy.state('current');
+            const wallClockStartedAt = (_a = current === null || current === void 0 ? void 0 : current.get) === null || _a === void 0 ? void 0 : _a.call(current, 'wallClockStartedAt');
             const timeout = getEffectiveTimeout();
-            const swallowAt = Math.max(timeout - 100, timeout * 0.9);
-            if (elapsed < swallowAt) {
-                // Still within the retry window — rethrow so Cypress retries.
-                throw error;
+            if (typeof wallClockStartedAt === 'number') {
+                const totalElapsed = Date.now() - wallClockStartedAt;
+                // Swallow only when very close to the actual command timeout.
+                // A 20ms buffer maximizes retry attempts while still preventing
+                // Cypress's global fail handler from aborting the test queue.
+                if (totalElapsed < timeout - 20) {
+                    throw error;
+                }
+            }
+            else {
+                // Fallback for cases where wallClockStartedAt is missing.
+                if (!retryFirstSeen.has(token)) {
+                    retryFirstSeen.set(token, Date.now());
+                }
+                const elapsed = Date.now() - retryFirstSeen.get(token);
+                const swallowAt = Math.max(timeout - 100, timeout * 0.9);
+                if (elapsed < swallowAt) {
+                    throw error;
+                }
             }
             // Retry window expired. Swallow the error: Cypress considers the
             // assertion "passed", the command resolves, and the queue continues.
@@ -161,6 +176,12 @@ function setupSoftAssertions() {
             // Final aggregated error must propagate to fail the test.
             if (String((error === null || error === void 0 ? void 0 : error.name) || '') === 'SoftAssertionError')
                 throw error;
+            const runnable = cy.state('runnable');
+            const retryStatusInfo = getRetryStatusInfo(runnable);
+            if (retryStatusInfo.shouldAttemptsContinue) {
+                abortSoftTest();
+                throw error;
+            }
             // Check if this is an assertion error that was already handled by
             // patchedAssertionAssert (swallowed after timeout). In that case
             // the fail handler should NOT fire. But for non-assertion command
@@ -220,6 +241,41 @@ function abortSoftTest() {
     retryAssertionFailures.clear();
     retryFirstSeen.clear();
 }
+function getRetryStatusInfo(test) {
+    var _a;
+    const currentRetry = typeof (test === null || test === void 0 ? void 0 : test.currentRetry) === 'function'
+        ? test.currentRetry()
+        : typeof Cypress.currentRetry === 'number'
+            ? Cypress.currentRetry
+            : 0;
+    const maxRetries = typeof (test === null || test === void 0 ? void 0 : test.retries) === 'function'
+        ? test.retries()
+        : typeof (test === null || test === void 0 ? void 0 : test._retries) === 'number'
+            ? test._retries
+            : typeof Cypress.getTestRetries === 'function'
+                ? (_a = Cypress.getTestRetries()) !== null && _a !== void 0 ? _a : 0
+                : 0;
+    return {
+        attempts: currentRetry + 1,
+        shouldAttemptsContinue: currentRetry < maxRetries,
+    };
+}
+function finalizeSoftTestInQueue(expectsSoftFailure) {
+    return cy.then(() => {
+        if (!isInSoftTest)
+            return;
+        const finalError = finalizeSoftTest();
+        if (expectsSoftFailure) {
+            if (!finalError) {
+                throw new Error('Expected SoftAssertionError but soft_it.expectFailure test completed without one.');
+            }
+            return;
+        }
+        if (finalError) {
+            throw finalError;
+        }
+    });
+}
 function createSoftIt(baseIt, options) {
     return function (title, fn) {
         return baseIt(title, function () {
@@ -230,7 +286,14 @@ function createSoftIt(baseIt, options) {
             retryFirstSeen.clear();
             setupSoftAssertions();
             try {
-                return fn.call(this);
+                const result = fn.call(this);
+                if (result && typeof result.then === 'function' && !Cypress.isCy(result)) {
+                    return Cypress.Promise.resolve(result).then(() => {
+                        finalizeSoftTestInQueue(expectSoftFailureCurrentSoftTest);
+                    });
+                }
+                finalizeSoftTestInQueue(expectSoftFailureCurrentSoftTest);
+                return result;
             }
             catch (error) {
                 abortSoftTest();
@@ -291,11 +354,15 @@ afterEach(function () {
     if (finalError) {
         const test = this.currentTest;
         if (test) {
+            const retryStatusInfo = getRetryStatusInfo(test);
+            if (retryStatusInfo.shouldAttemptsContinue) {
+                throw finalError;
+            }
             test.err = finalError;
             test._cypressTestStatusInfo = {
                 outerStatus: 'failed',
-                shouldAttemptsContinue: false,
-                attempts: typeof test.currentRetry === 'function' ? test.currentRetry() + 1 : 1,
+                shouldAttemptsContinue: retryStatusInfo.shouldAttemptsContinue,
+                attempts: retryStatusInfo.attempts,
                 strategy: 'detect-flake-and-pass-on-threshold',
             };
             const prevAttempts = Array.isArray(test.prevAttempts) ? test.prevAttempts : [];

package/dist/utils.js

@@ -84,10 +84,11 @@ function appendUniqueError(errors, message, stack) {
  */
 function mergeRetryFailures(softErrors, retryFailures) {
     const result = [...softErrors];
+    const seenMessages = new Set(result.map(e => e.message));
     for (const entry of retryFailures.values()) {
-        const isDuplicate = result.some(e => e.message === entry.message);
-        if (!isDuplicate) {
+        if (!seenMessages.has(entry.message)) {
             result.push(entry);
+            seenMessages.add(entry.message);
         }
     }
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koenvanbelle/cypress-soft-assertions",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "A Cypress plugin that provides soft_it() for soft assertions - all assertions continue on failure and are reported together",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",