@koenvanbelle/cypress-soft-assertions 2.3.1 → 2.3.2

package/README.md

@@ -249,6 +249,36 @@ soft_it('works with automatic translation checks', () => {
 - Both plugins register hooks/events, but they can run together safely with the setup above.
 - Keep translation-checker in non-invasive mode (`failOnError: false` in auto mode) so functional assertions remain the source of test pass/fail behavior.
 
+## Force-Fail Hook (strict mode)
+
+If your project (or another plugin) mutates test state in hooks (for example in `test:after:run`) and soft-failed tests appear as passed, enable strict mode per test:
+
+```typescript
+soft_it.strict('fails hard when soft assertions are captured', () => {
+  cy.visit('/');
+  cy.get('#title').should('have.text', 'Wrong Title');
+  cy.get('#status').should('have.text', 'Ready');
+});
+```
+
+You can also use `soft_it.strict.only(...)` and `soft_it.strict.skip(...)`.
+
+To force strict mode for all soft tests in a run, use env flags:
+
+```bash
+cypress run --env softAssertForceFail=true
+```
+
+You can also use:
+
+```bash
+cypress run --env SOFT_ASSERT_FORCE_FAIL=true
+```
+
+When strict mode is enabled (per test or via env), the plugin throws the final `SoftAssertionError` from `afterEach` on the last attempt, preventing downstream hook-based recovery from turning the test green.
+
+Note: strict mode may abort remaining tests in the same suite after the first forced soft failure (standard Cypress hook-failure behavior).
+
 ## License
 
 MIT

package/dist/index.d.ts

@@ -39,6 +39,16 @@ declare global {
          * Run only this test (like it.only)
          */
         function only(title: string, fn: Mocha.Func | Mocha.AsyncFunc): Mocha.Test;
+        /**
+         * Run this soft test in strict mode (force unrecoverable failure)
+         */
+        function strict(title: string, fn: Mocha.Func | Mocha.AsyncFunc): Mocha.Test;
+        namespace strict {
+            /** Run only this strict soft test */
+            function only(title: string, fn: Mocha.Func | Mocha.AsyncFunc): Mocha.Test;
+            /** Skip this strict soft test */
+            function skip(title: string, fn: Mocha.Func | Mocha.AsyncFunc): void;
+        }
         /**
          * Skip this test (like it.skip)
          */

package/dist/index.js

@@ -20,6 +20,7 @@ let softAssertionErrors = [];
 let retryAssertionFailures = new Map();
 let retryFirstSeen = new Map();
 let isInSoftTest = false;
+let forceFailCurrentSoftTest = false;
 let activeFailHandler = null;
 let originalChaiAssert = null;
 // ---------------------------------------------------------------------------
@@ -41,6 +42,26 @@ function getEffectiveTimeout() {
         return 4000;
     }
 }
+function isTruthy(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value !== 0;
+    const normalized = String(value !== null && value !== void 0 ? value : '').trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function shouldForceFailSoftAssertions() {
+    var _a;
+    try {
+        const env = (_a = Cypress.env) === null || _a === void 0 ? void 0 : _a.bind(Cypress);
+        if (!env)
+            return false;
+        return isTruthy(env('softAssertForceFail')) || isTruthy(env('SOFT_ASSERT_FORCE_FAIL'));
+    }
+    catch (_b) {
+        return false;
+    }
+}
 // ---------------------------------------------------------------------------
 // Internal helpers (Cypress-dependent — not unit-testable in isolation)
 // ---------------------------------------------------------------------------
@@ -208,19 +229,22 @@ function buildSoftAssertionError() {
 }
 function finalizeSoftTest() {
     isInSoftTest = false;
+    forceFailCurrentSoftTest = false;
     restoreAssertions();
     return buildSoftAssertionError();
 }
 function abortSoftTest() {
     isInSoftTest = false;
+    forceFailCurrentSoftTest = false;
     restoreAssertions();
     retryAssertionFailures.clear();
     retryFirstSeen.clear();
 }
-function createSoftIt(baseIt) {
+function createSoftIt(baseIt, options) {
     return function (title, fn) {
         return baseIt(title, function () {
             isInSoftTest = true;
+            forceFailCurrentSoftTest = Boolean(options === null || options === void 0 ? void 0 : options.strict) || shouldForceFailSoftAssertions();
             softAssertionErrors = [];
             retryAssertionFailures.clear();
             retryFirstSeen.clear();
@@ -257,10 +281,25 @@ globalThis.soft_it = createSoftIt(it);
  * soft_it.only - Run only this soft test
  */
 globalThis.soft_it.only = createSoftIt(it.only);
+/**
+ * soft_it.strict - Run this soft test in strict mode.
+ *
+ * Strict mode throws the final SoftAssertionError from afterEach on the
+ * last attempt, making the failure unrecoverable by downstream hooks.
+ */
+globalThis.soft_it.strict = createSoftIt(it, { strict: true });
+/**
+ * soft_it.strict.only - Run only this strict soft test
+ */
+globalThis.soft_it.strict.only = createSoftIt(it.only, { strict: true });
 /**
  * soft_it.skip - Skip this soft test
  */
 globalThis.soft_it.skip = it.skip;
+/**
+ * soft_it.strict.skip - Skip this strict soft test
+ */
+globalThis.soft_it.strict.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.
@@ -282,6 +321,12 @@ afterEach(function () {
         // Last (or only) attempt — use runner.fail() to mark the TEST as failed
         // rather than the hook. Throwing from afterEach on the final attempt
         // would skip remaining tests in the suite.
+        if (forceFailCurrentSoftTest) {
+            // Strict mode: force an unrecoverable hook failure.
+            // This guarantees a failed result even when other plugins mutate
+            // test state in test:after:run.
+            throw finalError;
+        }
         const runner = (_c = Cypress.mocha) === null || _c === void 0 ? void 0 : _c.getRunner();
         if (runner && test) {
             runner.fail(test, finalError);

package/package.json

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