@koenvanbelle/cypress-soft-assertions 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,293 @@
+# Cypress Soft Assertions
+
+A Cypress plugin that provides `soft_it()` - a drop-in replacement for `it()` that makes all assertions soft. Assertions continue execution on failure, and all failures are aggregated and reported at the end of the test.
+
+## Overview
+
+Standard Cypress assertions stop test execution at the first failure. With `soft_it()`:
+
+- All assertions run even if some fail
+- See all failures at once - no need to fix one issue and rerun to find the next
+- Drop-in replacement - just change `it()` to `soft_it()`
+- No manual tracking - failures automatically aggregated and reported
+
+## Installation
+
+Install the plugin as a development dependency:
+
+```bash
+npm install cypress-soft-assertions --save-dev
+```
+
+or using Yarn:
+
+```bash
+yarn add cypress-soft-assertions --dev
+```
+
+## Integration
+
+### Step 1: Import the Plugin
+
+Add the import to your Cypress support file. This registers the `soft_it()` function globally.
+
+**For TypeScript projects** - Edit `cypress/support/e2e.ts` (or `cypress/support/commands.ts`):
+
+```typescript
+import 'cypress-soft-assertions';
+```
+
+**For JavaScript projects** - Edit `cypress/support/e2e.js` (or `cypress/support/commands.js`):
+
+```javascript
+require('cypress-soft-assertions');
+```
+
+### Step 2: Add Type Definitions (TypeScript only)
+
+If you're using TypeScript, ensure your `tsconfig.json` includes the plugin types:
+
+```json
+{
+  "compilerOptions": {
+    "types": ["cypress", "cypress-soft-assertions"]
+  }
+}
+```
+
+Alternatively, add a reference directive at the top of your test files:
+
+```typescript
+/// <reference types="cypress-soft-assertions" />
+```
+
+### Step 3: Use in Tests
+
+Replace `it()` with `soft_it()` in any test where you want soft assertion behavior:
+
+```typescript
+describe('Product Page', () => {
+  soft_it('validates all product details', () => {
+    cy.visit('https://example.com/product/123');
+    
+    // All these assertions will run even if some fail
+    cy.get('.product-name').should('have.text', 'Awesome Product');
+    cy.get('.product-price').should('have.text', '$99.99');
+    cy.get('.stock-status').should('have.text', 'In Stock');
+    Supported Assertion Types
+
+`soft_it()` works with all Cypress assertion styles:
+
+```typescript
+soft_it('supports all assertion types', () => {
+  cy.visit('/page');
+  
+  // .should() assertions
+  cy.get('.title').should('be.visible');
+  cy.get('.title').should('have.text', 'Welcome');
+  
+  // .should() with callback
+  cy.get('.items').should(($items) => {
+    expect($items).to.have.length(5);
+    expect($items.first()).to.contain('Item 1');
+  });
+  
+  // expect() in .then()
+  cy.get('.price').then($el => {
+    expect($el.text()).to.equal('$99.99');
+  });
+  
+  // Chained assertions
+  cy.get('.button')
+    .should('be.visible')
+    .and('have.class', 'active')
+    .and('contain', 'Submit');
+});
+```
+
+### Mixing soft_it() with Regular it()
+
+You can use both `soft_it()` and regular `it()` in the same test suite:
+
+```typescript
+describe('User Profile', () => {
+  // Regular test - stops on first failure
+  it('loads the page', () => {
+    cy.visit('/profile');
+    cy.get('h1').should('be.visible');
+  });
+  
+  // Soft test - all assertions run
+  soft_it('validates profile fields', () => {
+    cy.get('.username').should('have.text', 'john_doe');
+    cy.get('.email').should('have.text', 'john@example.com');
+    cy.get('.member-since').should('contain', '2023');
+    cy.get('.posts-count').should('have.text', '42
+  
+  // Chained assertions
+  cy.get('.button')
+    .should('be.visible')
+    .and('have.class', 'active')
+    .and('contain', 'Submit');
+});
+```
+
+### Multiple Tests
+
+You can mix `soft_it()` with regular `it()` tests:
+
+```typescript
+describe('User Profile', () => {
+  // Regular test - stops on first failure
+  it('loads the page', () => {
+    cy.visit('/profile');
+    cy.get('h1').should('be.visible');
+  });
+  
+  // Soft test - all assertions run
+  soft_it('validates profile fields', () => {
+    cy.get('.username').should('have.text', 'john_doe');
+    cy.get('.email').should('have.text', 'john@example.com');
+    cy.get('.member-since').should('contain', '2023');
+    cy.get('.posts-count').should('have.text', '42');
+  });
+  
+  // Another soft test
+  soft_it('validates account settings', () => {
+    cy.get('[data-test=notifications]').should('be.checked');
+    cy.get('[data-test=newsletter]').should('not.be.checked');
+    cy.get('[data-test=theme]').should('have.value', 'dark');
+  });
+});
+```
+
+### Using soft_it.only and soft_it.skip
+
+Just like regular `it()`:
+
+```typescript
+describe('Test Suite', () => {
+  // Run only this test
+  soft_it.only('validates important fields', () => {
+    cy.get('.field1').should('exist');
+The plugin supports `.only` and `.skip` modifiers just like regular `it()`:
+
+```typescript
+describe('Test Suite', () => {
+  // Run only this test
+  soft_it.only('validates important fields', () => {
+    cy.get('.field1').should('exist');
+    cy.get('.field2').should('exist');
+  });
+  
+  // Skip this test
+  soft_it.skip('validates optional fields', () => {
+    cy.get('.optional').should('exist');
+  });
+});
+```
+
+## How It Works
+
+`soft_it()` intercepts Chai assertions within the test block and captures failures instead of throwing them immediately. At the end of the test, all captured failures are aggregated and reported in a single error message.
+
+The plugin works with:
+- `.should()` assertions
+- `expect()` assertions
+- `assert()` assertions
+- Custom Cypress commands that use assertions
+- Assertion chains (`.and()`)
+
+## Important Notes
+
+### When Assertions Are Reported
+
+Failures are reported at the end of the test after all Cypress commands complete. The test will be marked as failed, and all assertion failures will be listed together.
+
+### Regular vs Soft Tests
+
+- **Regular `it()`**: Stops at first assertion failure
+- **Soft `soft_it()`**: Runs all assertions, reports all failures at the end
+
+### Non-Assertion Errors
+
+Non-assertion errors (network errors, timeouts, command errors) will still stop test execution immediately. `soft_it()` only makes assertions soft.
+
+```typescript
+soft_it('example', () => {
+  cy.visit('/page');  // If this fails (timeout, 404), test stops immediately
+  cy.get('.missing').should('exist');  // This assertion is soft
+  cy.get('.other').should('exist');    // This assertion is soft
+});
+```
+
+## Best Practices
+
+### Use for Validation-Heavy Tests
+
+`soft_it()` is ideal for tests that validate many fields:
+
+```typescript
+soft_it('validates user profile completeness', () => {
+  cy.get('.name').should('not.be.empty');
+  cy.get('.email').should('match', /@/);
+  cy.get('.phone').should('have.length.at.least', 10);
+  cy.get('.address').should('not.be.empty');
+  cy.get('.city').should('not.be.empty');
+  cy.get('.avatar').should('be.visible');
+});
+```
+
+### Use Regular it() for Critical Setup
+
+Use regular `it()` for setup steps that must succeed:
+
+```typescript
+it('logs in successfully', () => {
+  cy.visit('/login');
+  cy.get('#username').type('user');
+  cy.get('#password').type('pass');
+  cy.get('button[type=submit]').click();
+  cy.url().should('include', '/dashboard');
+});
+
+soft_it('validates dashboard widgets', () => {
+  cy.get('.widget-1').should('be.visible');
+  cy.get('.widget-2').should('be.visible');
+  cy.get('.widget-3').should('be.visible');
+});
+```
+
+### Group Related Validations
+
+Use `soft_it()` to group validations of related elements:
+
+```typescript
+soft_it('validates navigation menu', () => {
+  cy.get('nav a').eq(0).should('have.text', 'Home');
+  cy.get('nav a').eq(1).should('have.text', 'Products');
+  cy.get('nav a').eq(2).should('have.text', 'About');
+  cy.get('nav a').eq(3).should('have.text', 'Contact');
+});
+```
+
+## Error Output Format
+
+When soft assertions fail, you receive a formatted error report:
+
+```
+================================================================================
+SOFT ASSERTION FAILURES (4 failed):
+================================================================================
+  1. expected '<input#email>' to have value 'test@example.com', but the value was 'wrong@example.com'
+  2. expected '<div.order-total>' to contain '$99.99', but it contained '$89.99'
+  3. expected '<div.tax>' to contain '$8.75', but it contained '$7.50'
+  4. expected '<div.grand-total>' to contain '$113.74', but it contained '$102.49'
+================================================================================
+```
+
+## License
+
+MIT
+
+##

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Cypress Soft Assertions Plugin
+ *
+ * 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.
+ */
+declare global {
+    /**
+     * soft_it - Define a test where all assertions are soft (non-blocking)
+     *
+     * All Cypress assertions (.should(), expect(), assert()) within this test block
+     * will continue execution even when they fail. At the end of the test, all failures
+     * are collected and reported together in a single error.
+     *
+     * @param title - Test title
+     * @param fn - Test function
+     *
+     * @example
+     * soft_it('validates product page', () => {
+     *   cy.visit('/product/123');
+     *   cy.get('.title').should('have.text', 'Product Name');
+     *   cy.get('.price').should('have.text', '$99.99');
+     *   cy.get('.stock').should('contain', 'In Stock');
+     *   // All assertions run, failures reported together at the end
+     * });
+     */
+    function soft_it(title: string, fn: Mocha.Func | Mocha.AsyncFunc): Mocha.Test;
+    namespace soft_it {
+        /**
+         * Run only this test (like it.only)
+         */
+        function only(title: string, fn: Mocha.Func | Mocha.AsyncFunc): Mocha.Test;
+        /**
+         * Skip this test (like it.skip)
+         */
+        function skip(title: string, fn: Mocha.Func | Mocha.AsyncFunc): void;
+    }
+}
+export {};

package/dist/index.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * Cypress Soft Assertions Plugin
+ *
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+let softAssertionErrors = [];
+let isInSoftTest = false;
+let originalAssert = null;
+/**
+ * Intercept Chai assertions to capture failures instead of throwing
+ */
+function setupSoftAssertions() {
+    if (!originalAssert) {
+        // Store the original assert function
+        originalAssert = chai.Assertion.prototype.assert;
+    }
+    // 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
+            }
+        }
+        else {
+            // Normal behavior for regular tests
+            originalAssert.apply(this, args);
+        }
+    };
+}
+/**
+ * Restore original Chai assertion behavior
+ */
+function restoreAssertions() {
+    if (originalAssert) {
+        chai.Assertion.prototype.assert = originalAssert;
+    }
+}
+/**
+ * Report all collected soft assertion failures
+ */
+function reportSoftAssertionFailures() {
+    if (softAssertionErrors.length > 0) {
+        const errorMessages = softAssertionErrors
+            .map((entry, index) => `  ${index + 1}. ${entry.message}`)
+            .join('\n');
+        const finalMessage = [
+            '',
+            '='.repeat(80),
+            `SOFT ASSERTION FAILURES (${softAssertionErrors.length} failed):`,
+            '='.repeat(80),
+            errorMessages,
+            '='.repeat(80),
+            ''
+        ].join('\n');
+        // Clear errors
+        const errorCount = softAssertionErrors.length;
+        softAssertionErrors = [];
+        // Throw the aggregated error
+        const error = new Error(finalMessage);
+        error.name = 'SoftAssertionError';
+        throw error;
+    }
+}
+/**
+ * soft_it - Define a test where all assertions are soft (non-blocking)
+ *
+ * All Cypress assertions (.should(), expect(), assert()) within this test
+ * will continue execution on failure. At the end, all failures are reported together.
+ *
+ * @param title - Test title
+ * @param fn - Test function
+ *
+ * @example
+ * soft_it('validates multiple fields', () => {
+ *   cy.visit('/page');
+ *   cy.get('.name').should('have.text', 'John');  // Won't stop if fails
+ *   cy.get('.age').should('have.text', '25');     // Won't stop if fails
+ *   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();
+    });
+};
+/**
+ * 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();
+    });
+};
+/**
+ * soft_it.skip - Skip this soft test
+ */
+globalThis.soft_it.skip = it.skip;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@koenvanbelle/cypress-soft-assertions",
+  "version": "1.0.0",
+  "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",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "cy:open": "cypress open",
+    "cy:run": "cypress run",
+    "test": "npm run build && cypress run"
+  },
+  "keywords": [
+    "cypress",
+    "soft-assertions",
+    "testing",
+    "automation",
+    "e2e",
+    "cypress-plugin",
+    "test",
+    "assert",
+    "assertion"
+  ],
+  "author": "Koen Van Belle",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vanbellekoen/cypress-soft-assertions"
+  },
+  "bugs": {
+    "url": "https://github.com/vanbellekoen/cypress-soft-assertions/issues"
+  },
+  "homepage": "https://github.com/vanbellekoen/cypress-soft-assertions#readme",
+  "peerDependencies": {
+    "cypress": ">=10.0.0"
+  },
+  "devDependencies": {
+    "cypress": "^15.9.0",
+    "typescript": "^5.9.3",
+    "@types/mocha": "^10.0.10"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}