@koenvanbelle/cypress-soft-assertions 2.0.0 → 2.1.0

package/README.md

@@ -158,6 +158,15 @@ SOFT ASSERTION FAILURES (3 failed):
 - **Retriable assertions are retried**: `.should()` and `.and()` assertions are retried by Cypress before being captured as soft failures. Assertions that eventually pass are not reported.
 - **Non-assertion errors still stop execution**: Network errors, visit timeouts, and other command errors are captured as soft failures but may prevent subsequent commands from running.
 - **State resets between tests**: Each `soft_it()` test starts with a clean slate — failures from one test never leak into another.
+- **Timeout-aware retries**: The plugin respects Cypress's `defaultCommandTimeout` and per-command `{ timeout }` overrides. Retriable assertions (`.should()`, `.and()`) are retried for up to 75% of the effective timeout before being captured as soft failures. For slow applications, increase the timeout to give assertions more time to pass:
+  ```typescript
+  // Global: set in cypress.config.ts
+  e2e: { defaultCommandTimeout: 10000 }
+
+  // Per-command: override on individual commands
+  cy.get('.slow-element', { timeout: 15000 }).should('be.visible');
+  ```
+- **Cypress Studio / Command Log**: When a soft assertion fails definitively, the plugin swallows the error so the test can continue. Cypress treats the command as resolved, which means it may not appear as a failed step in the Cypress Studio command log or may look like the assertion was skipped. The assertions **do** execute and failures **are** captured — they just don't show visually in the command log. Check the final `SoftAssertionError` report for the complete list of failures.
 
 ## License
 

package/dist/index.js

@@ -9,15 +9,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 let softAssertionErrors = [];
 let retryAssertionFailures = new Map();
-let retryAttemptCount = new Map();
+let retryFirstSeen = new Map();
 let isInSoftTest = false;
 let activeFailHandler = null;
 let originalChaiAssert = null;
-// After this many consecutive assertion failures on the same token, stop
-// rethrowing (which would cause Cypress to retry) and swallow instead.
-// This gives Cypress enough retry cycles for assertions that will eventually
-// pass, while bounding the time spent on definitively failing assertions.
-const MAX_RETHROWS = 10;
+function getEffectiveTimeout() {
+    var _a;
+    try {
+        const current = cy.state('current');
+        const perCommand = (_a = current === null || current === void 0 ? void 0 : current.get) === null || _a === void 0 ? void 0 : _a.call(current, 'timeout');
+        if (typeof perCommand === 'number')
+            return perCommand;
+    }
+    catch ( /* ignore */_b) { /* ignore */ }
+    try {
+        return Cypress.config('defaultCommandTimeout') || 4000;
+    }
+    catch (_c) {
+        return 4000;
+    }
+}
 function captureSoftAssertion(error) {
     const message = (error === null || error === void 0 ? void 0 : error.message) || String(error);
     const stack = error === null || error === void 0 ? void 0 : error.stack;
@@ -53,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)
@@ -81,7 +115,14 @@ function patchedAssertionAssert(...args) {
             const token = getAssertionToken(this, args);
             if (token) {
                 retryAssertionFailures.delete(token);
-                retryAttemptCount.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;
@@ -97,21 +138,48 @@ 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 attempts = (retryAttemptCount.get(token) || 0) + 1;
-            retryAttemptCount.set(token, attempts);
-            if (attempts <= MAX_RETHROWS) {
-                // Rethrow to let Cypress retry the assertion. This gives retriable
-                // commands (should/and, retried from get/contains/etc.) a window
-                // to eventually pass.
+            const now = Date.now();
+            if (!retryFirstSeen.has(token)) {
+                retryFirstSeen.set(token, 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;
+        }
+        // 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,
+            });
+            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;
             }
-            // Past the retry 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.
+            // Past retry budget — swallow and let Cypress move on.
             return;
         }
-        // No identifiable subject — capture directly (e.g. bare expect() calls
-        // in .then() callbacks).
+        // Bare expect() in .then() callbacks — capture directly.
         captureSoftAssertion(error);
     }
 }
@@ -150,7 +218,7 @@ function buildSoftAssertionError() {
         captureSoftAssertion(entry);
     }
     retryAssertionFailures.clear();
-    retryAttemptCount.clear();
+    retryFirstSeen.clear();
     if (softAssertionErrors.length > 0) {
         const errorMessages = softAssertionErrors
             .map((entry, index) => `  ${index + 1}. ${entry.message}`)
@@ -180,7 +248,7 @@ function abortSoftTest() {
     isInSoftTest = false;
     restoreAssertions();
     retryAssertionFailures.clear();
-    retryAttemptCount.clear();
+    retryFirstSeen.clear();
 }
 function createSoftIt(baseIt) {
     return function (title, fn) {
@@ -188,7 +256,7 @@ function createSoftIt(baseIt) {
             isInSoftTest = true;
             softAssertionErrors = [];
             retryAssertionFailures.clear();
-            retryAttemptCount.clear();
+            retryFirstSeen.clear();
             setupSoftAssertions();
             let result;
             try {

package/package.json

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