@koenvanbelle/cypress-soft-assertions 2.1.0 → 2.1.1

package/dist/index.js

@@ -138,24 +138,13 @@ 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;
-            }
-            // 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.
+            // 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
@@ -167,17 +156,11 @@ 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(fallbackToken)) {
-                retryFirstSeen.set(fallbackToken, now);
-            }
-            const elapsed = now - retryFirstSeen.get(fallbackToken);
-            const timeout = getEffectiveTimeout();
-            if (elapsed < timeout * 0.75) {
-                throw error;
+                retryFirstSeen.set(fallbackToken, Date.now());
             }
-            // Past retry budget — swallow and let Cypress move on.
-            return;
+            // Always rethrow to let Cypress use its full retry/timeout window.
+            throw error;
         }
         // Bare expect() in .then() callbacks — capture directly.
         captureSoftAssertion(error);
@@ -195,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);
@@ -213,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.1.0",
+  "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",