cypress-enterprise-commands/dist/commands/12.Validation_Assertions.js

Reusable Cypress custom commands for enterprise web applications

"use strict";
Cypress.Commands.add("softAssertElement", (element, assertion, expected, description = "Soft assertion") => {
    cy.wrap(element).should(($el) => {
        try {
            if (typeof assertion === "function") {
                assertion($el);
            }
            else {
                // Handle Chai assertions safely
                const assertionChain = expect($el);
                if (assertion in assertionChain) {
                    // Type-safe dynamic assertion call
                    assertionChain[assertion](expected);
                }
                else {
                    throw new Error(`Invalid assertion: ${assertion}`);
                }
            }
            Cypress.log({
                name: "Soft Assert",
                message: `✅ PASS: ${description}`,
                consoleProps: () => ({ status: "passed" }),
            });
        }
        catch (err) {
            Cypress.log({
                name: "Soft Assert",
                message: `❌ FAIL: ${description}`,
                consoleProps: () => ({
                    status: "failed",
                    error: err instanceof Error ? err.message : String(err),
                    element: $el,
                }),
            });
        }
    });
});
Cypress.Commands.add("softAssertValue", (actual, expected, message = "Soft assertion") => {
    try {
        expect(actual).to.equal(expected);
        Cypress.log({
            name: "Soft Assert",
            message: `✅ PASS: ${message}`,
            consoleProps: () => ({ actual, expected }),
        });
    }
    catch (err) {
        Cypress.log({
            name: "Soft Assert",
            message: `❌ FAIL: ${message}`,
            consoleProps: () => ({ error: err.message, actual, expected }),
        });
    }
});
let softAssertionResults = [];
Cypress.Commands.add("softAssert", { prevSubject: ["optional", "element", "window", "document"] }, (subject, assertionFn, description, options = {}) => {
    // Explicit return type
    const { expected, subjectAlias = "" } = options;
    let actual;
    let passed = false;
    let error;
    try {
        assertionFn(subject);
        actual = subject;
        passed = true;
    }
    catch (err) {
        error = err instanceof Error ? err : new Error(String(err));
        actual = error.message.includes("expected")
            ? error.message.split("expected")[1]?.split("to")[0]?.trim()
            : subject;
    }
    const result = {
        description,
        passed,
        error,
        expected,
        actual,
        subject: subjectAlias || subject,
    };
    softAssertionResults.push(result);
    Cypress.log({
        name: "softAssert",
        message: `${passed ? "✅ PASS" : "❌ FAIL"}: ${description}`,
        consoleProps: () => ({
            Status: passed ? "Passed" : "Failed",
            Description: description,
            Subject: result.subject,
            Expected: expected,
            Actual: actual,
            ...(error ? { Error: error.message, "Stack Trace": error.stack } : {}),
        }),
    });
    // Return void explicitly to match Chainable<void>
    return cy.wrap(undefined, { log: false });
});