@koenvanbelle/cypress-soft-assertions 1.0.7 → 1.0.9

package/dist/index.js

@@ -9,8 +9,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 let softAssertionErrors = [];
 let isInSoftTest = false;
-let originalAssert = null;
-const retryWindows = new Map();
+let activeFailHandler = null;
+let activeSoftTestTitle = null;
+let finalizerInstalled = false;
 /**
  * Track a soft assertion failure so it can be reported at test end.
  */
@@ -26,98 +27,89 @@ function captureSoftAssertion(error) {
         stack
     });
 }
-/**
- * Read command metadata from Cypress internals in a defensive way.
- */
-function getCurrentCommand() {
+function getCurrentCommandName() {
+    var _a;
     const state = cy === null || cy === void 0 ? void 0 : cy.state;
     if (typeof state !== 'function') {
-        return null;
+        return '';
     }
-    return state('current') || null;
-}
-function getCommandProp(command, prop) {
-    if (!command) {
-        return undefined;
+    const current = state('current');
+    if (!current) {
+        return '';
     }
-    if (typeof command.get === 'function') {
-        return command.get(prop);
+    if (typeof current.get === 'function') {
+        return String(current.get('name') || '');
     }
-    if (command.attributes && prop in command.attributes) {
-        return command.attributes[prop];
-    }
-    return command[prop];
+    return String(current.name || ((_a = current.attributes) === null || _a === void 0 ? void 0 : _a.name) || '');
 }
-/**
- * Build retry context for the currently running Cypress command.
- */
-function getAssertionContext() {
-    const command = getCurrentCommand();
-    const commandId = String(getCommandProp(command, 'id') || getCommandProp(command, 'chainerId') || '');
-    const commandName = String(getCommandProp(command, 'name') || '');
-    const timeout = Number(getCommandProp(command, 'timeout')) || Number(Cypress.config('defaultCommandTimeout'));
-    const isRetriable = commandName === 'should' || commandName === 'and';
-    return {
-        commandId,
-        timeout,
-        isRetriable,
-    };
+function isRetryTimeoutError(error) {
+    const message = String((error === null || error === void 0 ? void 0 : error.message) || '');
+    return /Timed out retrying after/i.test(message);
 }
-function formatSoftAssertionError(error, timeout, isRetriable) {
-    const message = String((error === null || error === void 0 ? void 0 : error.message) || error);
-    if (isRetriable && !/Timed out retrying after/i.test(message)) {
-        return {
-            ...error,
-            message: `Timed out retrying after ${timeout}ms: ${message}`,
-        };
-    }
-    return error;
+function isRetriableAssertionCommand(commandName) {
+    return commandName === 'should' || commandName === 'and';
 }
 /**
- * Intercept Chai assertions and make them soft in soft_it() tests.
+ * Intercept Cypress failures and make assertion failures soft in soft_it() tests.
  */
 function setupSoftAssertions() {
-    if (!originalAssert) {
-        originalAssert = chai.Assertion.prototype.assert;
+    if (!activeFailHandler) {
+        activeFailHandler = (error) => {
+            if (!isInSoftTest) {
+                throw error;
+            }
+            const commandName = getCurrentCommandName();
+            if (isRetriableAssertionCommand(commandName) && !isRetryTimeoutError(error)) {
+                // Let Cypress continue polling/retrying for retriable assertions.
+                throw error;
+            }
+            captureSoftAssertion(error);
+            return false;
+        };
+        Cypress.on('fail', activeFailHandler);
+    }
+}
+function getTestTitle(test) {
+    if (test && typeof test.fullTitle === 'function') {
+        return test.fullTitle();
     }
-    chai.Assertion.prototype.assert = function (...args) {
+    return String((test === null || test === void 0 ? void 0 : test.title) || '');
+}
+function installFinalizer() {
+    if (finalizerInstalled) {
+        return;
+    }
+    afterEach(function () {
+        var _a, _b;
         if (!isInSoftTest) {
-            return originalAssert.apply(this, args);
+            return;
         }
-        const context = getAssertionContext();
-        try {
-            const result = originalAssert.apply(this, args);
-            if (context.commandId) {
-                retryWindows.delete(context.commandId);
-            }
-            return result;
+        const currentTest = (this.currentTest || this.test);
+        if (!currentTest || getTestTitle(currentTest) !== activeSoftTestTitle) {
+            return;
         }
-        catch (rawError) {
-            const error = formatSoftAssertionError(rawError, context.timeout, context.isRetriable);
-            if (context.isRetriable && context.commandId) {
-                const currentWindow = retryWindows.get(context.commandId) || {
-                    startedAt: Date.now(),
-                    timeout: context.timeout,
-                };
-                retryWindows.set(context.commandId, currentWindow);
-                const elapsed = Date.now() - currentWindow.startedAt;
-                if (elapsed < currentWindow.timeout) {
-                    throw rawError;
-                }
-                retryWindows.delete(context.commandId);
-            }
-            captureSoftAssertion(error);
+        const finalError = finalizeSoftTest();
+        if (!finalError) {
             return;
         }
-    };
+        currentTest.err = finalError;
+        currentTest.state = 'failed';
+        const runner = (_b = (_a = Cypress === null || Cypress === void 0 ? void 0 : Cypress.mocha) === null || _a === void 0 ? void 0 : _a.getRunner) === null || _b === void 0 ? void 0 : _b.call(_a);
+        if (runner && typeof runner.fail === 'function') {
+            runner.fail(currentTest, finalError);
+            return;
+        }
+        throw finalError;
+    });
+    finalizerInstalled = true;
 }
 /**
  * Restore original Chai assertion behavior.
  */
 function restoreAssertions() {
-    retryWindows.clear();
-    if (originalAssert) {
-        chai.Assertion.prototype.assert = originalAssert;
+    if (activeFailHandler) {
+        Cypress.off('fail', activeFailHandler);
+        activeFailHandler = null;
     }
 }
 /**
@@ -151,6 +143,7 @@ function buildSoftAssertionError() {
 function finalizeSoftTest() {
     isInSoftTest = false;
     restoreAssertions();
+    activeSoftTestTitle = null;
     return buildSoftAssertionError();
 }
 /**
@@ -159,52 +152,31 @@ function finalizeSoftTest() {
 function abortSoftTest() {
     isInSoftTest = false;
     restoreAssertions();
+    activeSoftTestTitle = null;
 }
 /**
  * Create a soft_it variant from a Mocha it function.
  */
 function createSoftIt(baseIt) {
+    installFinalizer();
     return function (title, fn) {
         return baseIt(title, function () {
             isInSoftTest = true;
             softAssertionErrors = [];
+            activeSoftTestTitle = getTestTitle(this.currentTest || this.test);
             setupSoftAssertions();
             try {
                 const result = fn.call(this);
                 if (result && typeof result.then === 'function') {
                     return result
                         .catch((error) => {
-                        if ((error === null || error === void 0 ? void 0 : error.name) === 'AssertionError') {
-                            captureSoftAssertion(error);
-                            return;
-                        }
                         abortSoftTest();
                         throw error;
-                    })
-                        .then(() => cy.wrap(null).then(() => {
-                        const finalError = finalizeSoftTest();
-                        if (finalError) {
-                            throw finalError;
-                        }
-                    }));
+                    });
                 }
-                return cy.wrap(null).then(() => {
-                    const finalError = finalizeSoftTest();
-                    if (finalError) {
-                        throw finalError;
-                    }
-                });
+                return result;
             }
             catch (error) {
-                if ((error === null || error === void 0 ? void 0 : error.name) === 'AssertionError') {
-                    captureSoftAssertion(error);
-                    return cy.wrap(null).then(() => {
-                        const finalError = finalizeSoftTest();
-                        if (finalError) {
-                            throw finalError;
-                        }
-                    });
-                }
                 abortSoftTest();
                 throw error;
             }

package/package.json

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