@koenvanbelle/cypress-soft-assertions 2.1.0 → 2.2.1

package/dist/index.d.ts

@@ -4,6 +4,14 @@
  * Provides soft_it() function that wraps Cypress tests to make all assertions soft.
  * Assertions don't stop execution on failure - they continue and all failures are
  * aggregated and reported at the end of the test.
+ *
+ * Architecture:
+ * - Chai's Assertion.prototype.assert is patched to intercept assertion failures.
+ * - During retries, failures are rethrown so Cypress can retry.
+ * - Once the retry window expires, the error is swallowed (not rethrown).
+ *   This lets Cypress consider the command "passed" and continue the queue.
+ * - A fail handler catches non-assertion errors (e.g. element-not-found timeouts).
+ * - An afterEach hook finalizes: aggregates all failures and reports them.
  */
 declare global {
     /**

package/dist/index.js

@@ -5,6 +5,14 @@
  * Provides soft_it() function that wraps Cypress tests to make all assertions soft.
  * Assertions don't stop execution on failure - they continue and all failures are
  * aggregated and reported at the end of the test.
+ *
+ * Architecture:
+ * - Chai's Assertion.prototype.assert is patched to intercept assertion failures.
+ * - During retries, failures are rethrown so Cypress can retry.
+ * - Once the retry window expires, the error is swallowed (not rethrown).
+ *   This lets Cypress consider the command "passed" and continue the queue.
+ * - A fail handler catches non-assertion errors (e.g. element-not-found timeouts).
+ * - An afterEach hook finalizes: aggregates all failures and reports them.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 let softAssertionErrors = [];
@@ -70,10 +78,6 @@ function getRetryableCommandId() {
         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 : '';
@@ -105,6 +109,15 @@ function patchChaiAssertions() {
         return;
     assertionProto.assert = patchedAssertionAssert;
 }
+function resolveStableToken(assertionContext, args) {
+    const token = getAssertionToken(assertionContext, args);
+    if (token)
+        return token;
+    const retryableCid = getRetryableCommandId();
+    if (retryableCid)
+        return `__cmd__|${retryableCid}|${toTokenPart(args === null || args === void 0 ? void 0 : args[3])}`;
+    return '';
+}
 function patchedAssertionAssert(...args) {
     if (!originalChaiAssert)
         return;
@@ -112,79 +125,55 @@ function patchedAssertionAssert(...args) {
         const result = originalChaiAssert.apply(this, args);
         // Assertion passed — clear any staged failure for this token.
         if (isInSoftTest) {
-            const token = getAssertionToken(this, args);
+            const token = resolveStableToken(this, args);
             if (token) {
                 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;
     }
     catch (error) {
         if (!isInSoftTest)
             throw error;
-        const token = getAssertionToken(this, args);
+        const errorEntry = {
+            message: String((error === null || error === void 0 ? void 0 : error.message) || error),
+            stack: error === null || error === void 0 ? void 0 : error.stack,
+        };
+        const token = resolveStableToken(this, args);
         if (token) {
-            // Stage the failure under a stable token so it can be cleared if
-            // a later retry succeeds.
-            retryAssertionFailures.set(token, {
-                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();
+            // Track when we first saw this failure.
             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);
+                retryFirstSeen.set(token, Date.now());
             }
-            const elapsed = now - retryFirstSeen.get(fallbackToken);
+            // 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 timeout = getEffectiveTimeout();
-            if (elapsed < timeout * 0.75) {
+            const swallowAt = Math.max(timeout - 100, timeout * 0.9);
+            if (elapsed < swallowAt) {
+                // Still within the retry window — rethrow so Cypress retries.
                 throw error;
             }
-            // Past retry budget — swallow and let Cypress move on.
+            // Retry window expired. Swallow the error: Cypress considers the
+            // assertion "passed", the command resolves, and the queue continues.
+            // The failure is already staged in retryAssertionFailures and will
+            // be promoted to softAssertionErrors during finalization.
             return;
         }
-        // Bare expect() in .then() callbacks — capture directly.
+        // No stable token (e.g. bare expect() in .then() callbacks).
+        // Capture directly and swallow so the queue continues.
         captureSoftAssertion(error);
     }
 }
 function setupSoftAssertions() {
     patchChaiAssertions();
+    // Fail handler for non-assertion errors (e.g. element-not-found after
+    // cy.get timeout). These don't go through Chai's assert at all.
     if (!activeFailHandler) {
         activeFailHandler = (error) => {
             if (!isInSoftTest)
@@ -192,9 +181,20 @@ 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;
-            // Non-assertion command failures (e.g. element not found timeouts)
-            // are captured as soft failures.
+            // 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
+            // failures (e.g. cy.get can't find element), capture as soft failure.
             captureSoftAssertion(error);
+            // Clear any matching retry-tracked entry to prevent double-counting.
+            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 +213,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();
@@ -258,31 +262,13 @@ function createSoftIt(baseIt) {
             retryAssertionFailures.clear();
             retryFirstSeen.clear();
             setupSoftAssertions();
-            let result;
             try {
-                result = fn.call(this);
+                return fn.call(this);
             }
             catch (error) {
                 abortSoftTest();
                 throw error;
             }
-            // Finalize from inside the test chain (not from hooks) so Cypress counts
-            // the failure on the test itself.
-            return cy.then(() => {
-                return Cypress.Promise.resolve(result)
-                    .catch((error) => {
-                    if (isInSoftTest) {
-                        abortSoftTest();
-                    }
-                    throw error;
-                })
-                    .then(() => {
-                    const finalError = finalizeSoftTest();
-                    if (finalError) {
-                        throw finalError;
-                    }
-                });
-            });
         });
     };
 }
@@ -312,3 +298,24 @@ globalThis.soft_it.only = createSoftIt(it.only);
  * soft_it.skip - Skip this soft test
  */
 globalThis.soft_it.skip = it.skip;
+// Global afterEach hook: finalize soft assertions after each test.
+// Registered at the root level so it applies to all suites.
+// For non-soft tests (isInSoftTest === false), this is a no-op.
+afterEach(function () {
+    var _a;
+    if (!isInSoftTest)
+        return;
+    const finalError = finalizeSoftTest();
+    if (finalError) {
+        // Use runner.fail() to mark the TEST as failed rather than the hook.
+        // Throwing from afterEach would skip remaining tests in the suite.
+        const runner = (_a = Cypress.mocha) === null || _a === void 0 ? void 0 : _a.getRunner();
+        const test = this.currentTest;
+        if (runner && test) {
+            runner.fail(test, finalError);
+        }
+        else {
+            throw finalError;
+        }
+    }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koenvanbelle/cypress-soft-assertions",
-  "version": "2.1.0",
+  "version": "2.2.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",
@@ -9,7 +9,8 @@
     "prepublishOnly": "npm run build",
     "cy:open": "cypress open",
     "cy:run": "cypress run",
-    "test": "npm run build && cypress run"
+    "test": "npm run build && cypress run && npm run test:runner",
+    "test:runner": "node --test test/runner.test.mjs"
   },
   "keywords": [
     "cypress",