@koenvanbelle/cypress-soft-assertions 2.0.1 → 2.1.1

package/dist/index.js

@@ -64,6 +64,29 @@ function toTokenPart(value) {
         return String(value);
     }
 }
+function getRetryableCommandId() {
+    var _a, _b, _c, _d, _e, _f, _g;
+    try {
+        const current = cy.state('current');
+        if (!current)
+            return '';
+        // In Cypress 15, inside a .should()/.and() callback, cy.state('current')
+        // points to the parent command (e.g. 'wrap', 'window', 'get'). The
+        // 'followedByShouldCallback' attribute is set to true, and
+        // 'currentAssertionCommand' points to the should/and command object.
+        const assertionCmd = (_a = current.get) === null || _a === void 0 ? void 0 : _a.call(current, 'currentAssertionCommand');
+        if (assertionCmd) {
+            const id = (_d = (_c = (_b = assertionCmd.get) === null || _b === void 0 ? void 0 : _b.call(assertionCmd, 'id')) !== null && _c !== void 0 ? _c : assertionCmd.id) !== null && _d !== void 0 ? _d : '';
+            return id ? String(id) : '';
+        }
+        if ((_e = current.get) === null || _e === void 0 ? void 0 : _e.call(current, 'followedByShouldCallback')) {
+            const id = (_g = (_f = current.get) === null || _f === void 0 ? void 0 : _f.call(current, 'id')) !== null && _g !== void 0 ? _g : '';
+            return id ? String(id) : '';
+        }
+    }
+    catch ( /* ignore */_h) { /* ignore */ }
+    return '';
+}
 function getAssertionToken(assertionContext, args) {
     const subjectKey = getSubjectKey(assertionContext);
     if (!subjectKey)
@@ -94,6 +117,13 @@ function patchedAssertionAssert(...args) {
                 retryAssertionFailures.delete(token);
                 retryFirstSeen.delete(token);
             }
+            // Also clear command-based fallback tokens for this command
+            const retryableCid = getRetryableCommandId();
+            if (retryableCid) {
+                const fallbackToken = `__cmd__|${retryableCid}|${toTokenPart(args === null || args === void 0 ? void 0 : args[3])}`;
+                retryAssertionFailures.delete(fallbackToken);
+                retryFirstSeen.delete(fallbackToken);
+            }
         }
         return result;
     }
@@ -108,27 +138,31 @@ function patchedAssertionAssert(...args) {
                 message: String((error === null || error === void 0 ? void 0 : error.message) || error),
                 stack: error === null || error === void 0 ? void 0 : error.stack,
             });
-            const now = Date.now();
             if (!retryFirstSeen.has(token)) {
-                retryFirstSeen.set(token, now);
+                retryFirstSeen.set(token, Date.now());
             }
-            const elapsed = now - retryFirstSeen.get(token);
-            const timeout = getEffectiveTimeout();
-            // Use 75% of the timeout as the retry window. This ensures the plugin
-            // swallows the error before Cypress's own timeout fires (which would
-            // route through the fail handler and prevent finalization).
-            if (elapsed < timeout * 0.75) {
-                // Still within the command timeout window — rethrow to let Cypress
-                // retry the assertion. If it eventually passes, the token is cleared.
-                throw error;
+            // Always rethrow to let Cypress use its full retry/timeout window.
+            // When the timeout expires, Cypress fires the fail event; our fail
+            // handler captures it and clears the staged entry to avoid duplicates.
+            throw error;
+        }
+        // No identifiable subject from the DOM. If we're inside a retryable
+        // command (.should() / .and()), derive a token from the command ID so the
+        // retry-window logic still applies (e.g. window property assertions).
+        const retryableCid = getRetryableCommandId();
+        if (retryableCid) {
+            const fallbackToken = `__cmd__|${retryableCid}|${toTokenPart(args === null || args === void 0 ? void 0 : args[3])}`;
+            retryAssertionFailures.set(fallbackToken, {
+                message: String((error === null || error === void 0 ? void 0 : error.message) || error),
+                stack: error === null || error === void 0 ? void 0 : error.stack,
+            });
+            if (!retryFirstSeen.has(fallbackToken)) {
+                retryFirstSeen.set(fallbackToken, Date.now());
             }
-            // Past the timeout budget — swallow so the command "succeeds" and
-            // Cypress moves on to the next queued command. The token stays in the
-            // Map and will be promoted to softAssertionErrors at finalization.
-            return;
+            // Always rethrow to let Cypress use its full retry/timeout window.
+            throw error;
         }
-        // No identifiable subject — capture directly (e.g. bare expect() calls
-        // in .then() callbacks).
+        // Bare expect() in .then() callbacks — capture directly.
         captureSoftAssertion(error);
     }
 }
@@ -144,6 +178,16 @@ function setupSoftAssertions() {
             // Non-assertion command failures (e.g. element not found timeouts)
             // are captured as soft failures.
             captureSoftAssertion(error);
+            // Clear any matching retry-tracked entry to prevent double-counting
+            // at finalization (the fail handler is now the authoritative capture).
+            const errorMsg = (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            for (const [token, entry] of retryAssertionFailures.entries()) {
+                if (entry.message === errorMsg) {
+                    retryAssertionFailures.delete(token);
+                    retryFirstSeen.delete(token);
+                    break;
+                }
+            }
             return false;
         };
         Cypress.on('fail', activeFailHandler);
@@ -162,9 +206,13 @@ function restoreAssertions() {
     }
 }
 function buildSoftAssertionError() {
-    // Promote any remaining retry-tracked failures.
+    // Promote any remaining retry-tracked failures that weren't already
+    // captured by the fail handler (dedup by message).
     for (const entry of retryAssertionFailures.values()) {
-        captureSoftAssertion(entry);
+        const isDuplicate = softAssertionErrors.some(e => e.message === entry.message);
+        if (!isDuplicate) {
+            softAssertionErrors.push(entry);
+        }
     }
     retryAssertionFailures.clear();
     retryFirstSeen.clear();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koenvanbelle/cypress-soft-assertions",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "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",