@koenvanbelle/cypress-soft-assertions 2.0.0 → 2.0.1

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;
@@ -81,7 +92,7 @@ function patchedAssertionAssert(...args) {
             const token = getAssertionToken(this, args);
             if (token) {
                 retryAssertionFailures.delete(token);
-                retryAttemptCount.delete(token);
+                retryFirstSeen.delete(token);
             }
         }
         return result;
@@ -97,17 +108,23 @@ 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 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 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 — capture directly (e.g. bare expect() calls
@@ -150,7 +167,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 +197,7 @@ function abortSoftTest() {
     isInSoftTest = false;
     restoreAssertions();
     retryAssertionFailures.clear();
-    retryAttemptCount.clear();
+    retryFirstSeen.clear();
 }
 function createSoftIt(baseIt) {
     return function (title, fn) {
@@ -188,7 +205,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.0.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",