@koenvanbelle/cypress-soft-assertions 1.0.6 → 1.0.8

package/dist/index.js

@@ -9,49 +9,86 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 let softAssertionErrors = [];
 let isInSoftTest = false;
-let originalAssert = null;
+let activeFailHandler = null;
+let activeSoftTestTitle = null;
+let finalizerInstalled = false;
 /**
- * Intercept Chai assertions to capture failures instead of throwing
+ * Track a soft assertion failure so it can be reported at test end.
  */
-function setupSoftAssertions() {
-    if (!originalAssert) {
-        // Store the original assert function
-        originalAssert = chai.Assertion.prototype.assert;
+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;
+    const lastEntry = softAssertionErrors[softAssertionErrors.length - 1];
+    if (lastEntry && lastEntry.message === message && lastEntry.stack === stack) {
+        return;
     }
-    // Override the assert function to capture errors
-    chai.Assertion.prototype.assert = function (...args) {
-        if (isInSoftTest) {
-            try {
-                // Call the original assert
-                originalAssert.apply(this, args);
-            }
-            catch (error) {
-                // Capture the error instead of throwing
-                softAssertionErrors.push({
-                    message: error.message,
-                    stack: error.stack
-                });
-                // Don't throw - let the test continue
+    softAssertionErrors.push({
+        message,
+        stack
+    });
+}
+/**
+ * Intercept Cypress failures and make assertion failures soft in soft_it() tests.
+ */
+function setupSoftAssertions() {
+    if (!activeFailHandler) {
+        activeFailHandler = (error) => {
+            if (!isInSoftTest) {
+                throw error;
             }
+            captureSoftAssertion(error);
+            return false;
+        };
+        Cypress.on('fail', activeFailHandler);
+    }
+}
+function getTestTitle(test) {
+    if (test && typeof test.fullTitle === 'function') {
+        return test.fullTitle();
+    }
+    return String((test === null || test === void 0 ? void 0 : test.title) || '');
+}
+function installFinalizer() {
+    if (finalizerInstalled) {
+        return;
+    }
+    afterEach(function () {
+        var _a, _b;
+        if (!isInSoftTest) {
+            return;
         }
-        else {
-            // Normal behavior for regular tests
-            originalAssert.apply(this, args);
+        const currentTest = (this.currentTest || this.test);
+        if (!currentTest || getTestTitle(currentTest) !== activeSoftTestTitle) {
+            return;
         }
-    };
+        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
+ * Restore original Chai assertion behavior.
  */
 function restoreAssertions() {
-    if (originalAssert) {
-        chai.Assertion.prototype.assert = originalAssert;
+    if (activeFailHandler) {
+        Cypress.off('fail', activeFailHandler);
+        activeFailHandler = null;
     }
 }
 /**
  * Report all collected soft assertion failures
  */
-function reportSoftAssertionFailures() {
+function buildSoftAssertionError() {
     if (softAssertionErrors.length > 0) {
         const errorMessages = softAssertionErrors
             .map((entry, index) => `  ${index + 1}. ${entry.message}`)
@@ -66,13 +103,58 @@ function reportSoftAssertionFailures() {
             ''
         ].join('\n');
         // Clear errors
-        const errorCount = softAssertionErrors.length;
         softAssertionErrors = [];
-        // Throw the aggregated error
         const error = new Error(finalMessage);
         error.name = 'SoftAssertionError';
-        throw error;
+        return error;
     }
+    return null;
+}
+/**
+ * Cleanup soft assertion state and report accumulated failures.
+ */
+function finalizeSoftTest() {
+    isInSoftTest = false;
+    restoreAssertions();
+    activeSoftTestTitle = null;
+    return buildSoftAssertionError();
+}
+/**
+ * Cleanup soft assertion state without reporting (used on hard failures).
+ */
+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) => {
+                        abortSoftTest();
+                        throw error;
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                abortSoftTest();
+                throw error;
+            }
+        });
+    };
 }
 /**
  * soft_it - Define a test where all assertions are soft (non-blocking)
@@ -91,82 +173,11 @@ function reportSoftAssertionFailures() {
  *   cy.get('.city').should('have.text', 'NYC');   // Won't stop if fails
  * });
  */
-globalThis.soft_it = function (title, fn) {
-    return it(title, function () {
-        // Setup soft assertion mode
-        isInSoftTest = true;
-        softAssertionErrors = [];
-        setupSoftAssertions();
-        // Wrap the test function execution
-        const executeTest = () => {
-            try {
-                const result = fn.call(this);
-                // Handle async tests (Cypress tests return undefined, but we need to check after cy commands)
-                if (result && typeof result.then === 'function') {
-                    return result.then(() => {
-                        // Test completed - check for errors at the end
-                        return cy.wrap(null).then(() => {
-                            isInSoftTest = false;
-                            reportSoftAssertionFailures();
-                        });
-                    }, (err) => {
-                        isInSoftTest = false;
-                        restoreAssertions();
-                        throw err;
-                    });
-                }
-                // For Cypress tests, we need to hook into the end of the command chain
-                return cy.wrap(null).then(() => {
-                    isInSoftTest = false;
-                    reportSoftAssertionFailures();
-                });
-            }
-            catch (err) {
-                isInSoftTest = false;
-                restoreAssertions();
-                throw err;
-            }
-        };
-        return executeTest();
-    });
-};
+globalThis.soft_it = createSoftIt(it);
 /**
  * soft_it.only - Run only this soft test
  */
-globalThis.soft_it.only = function (title, fn) {
-    return it.only(title, function () {
-        isInSoftTest = true;
-        softAssertionErrors = [];
-        setupSoftAssertions();
-        const executeTest = () => {
-            try {
-                const result = fn.call(this);
-                if (result && typeof result.then === 'function') {
-                    return result.then(() => {
-                        return cy.wrap(null).then(() => {
-                            isInSoftTest = false;
-                            reportSoftAssertionFailures();
-                        });
-                    }, (err) => {
-                        isInSoftTest = false;
-                        restoreAssertions();
-                        throw err;
-                    });
-                }
-                return cy.wrap(null).then(() => {
-                    isInSoftTest = false;
-                    reportSoftAssertionFailures();
-                });
-            }
-            catch (err) {
-                isInSoftTest = false;
-                restoreAssertions();
-                throw err;
-            }
-        };
-        return executeTest();
-    });
-};
+globalThis.soft_it.only = createSoftIt(it.only);
 /**
  * soft_it.skip - Skip this soft test
  */

package/package.json

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