expect-webdriverio 5.1.0 → 5.2.0

package/lib/index.js

@@ -1,6 +1,8 @@
 import { expect as expectLib } from 'expect';
 import wdioMatchers from './matchers.js';
 import { DEFAULT_OPTIONS } from './constants.js';
+import createSoftExpect from './softExpect.js';
+import { SoftAssertService } from './softAssert.js';
 export const matchers = new Map();
 const extend = expectLib.extend;
 expectLib.extend = (m) => {
@@ -11,7 +13,20 @@ expectLib.extend = (m) => {
     return extend(m);
 };
 expectLib.extend(wdioMatchers);
-export const expect = expectLib;
+const expectWithSoft = expectLib;
+Object.defineProperty(expectWithSoft, 'soft', {
+    value: (actual) => createSoftExpect(actual)
+});
+Object.defineProperty(expectWithSoft, 'getSoftFailures', {
+    value: (testId) => SoftAssertService.getInstance().getFailures(testId)
+});
+Object.defineProperty(expectWithSoft, 'assertSoftFailures', {
+    value: (testId) => SoftAssertService.getInstance().assertNoFailures(testId)
+});
+Object.defineProperty(expectWithSoft, 'clearSoftFailures', {
+    value: (testId) => SoftAssertService.getInstance().clearFailures(testId)
+});
+export const expect = expectWithSoft;
 export const getConfig = () => DEFAULT_OPTIONS;
 export const setDefaultOptions = (options = {}) => {
     Object.entries(options).forEach(([key, value]) => {
@@ -22,4 +37,6 @@ export const setDefaultOptions = (options = {}) => {
 };
 export const setOptions = setDefaultOptions;
 export { SnapshotService } from './snapshot.js';
+export { SoftAssertService } from './softAssert.js';
+export { SoftAssertionService } from './softAssertService.js';
 export * as utils from './utils.js';

package/lib/matchers/snapshot.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { expect } from '../index.js';
+import { expect } from 'expect';
 import { SnapshotService } from '../snapshot.js';
 function returnSnapshotError(snapshotError) {
     try {

package/lib/softAssert.js

@@ -0,0 +1,76 @@
+export class SoftAssertService {
+    constructor() {
+        this.failureMap = new Map();
+        this.currentTest = null;
+    }
+    static getInstance() {
+        if (!SoftAssertService.instance) {
+            SoftAssertService.instance = new SoftAssertService();
+        }
+        return SoftAssertService.instance;
+    }
+    setCurrentTest(testId, testName, testFile) {
+        this.currentTest = { id: testId, name: testName, file: testFile };
+        if (!this.failureMap.has(testId)) {
+            this.failureMap.set(testId, []);
+        }
+    }
+    clearCurrentTest() {
+        this.currentTest = null;
+    }
+    getCurrentTestId() {
+        return this.currentTest?.id || null;
+    }
+    addFailure(error, matcherName) {
+        const testId = this.getCurrentTestId();
+        if (!testId) {
+            throw error;
+        }
+        const stackLines = error.stack?.split('\n') || [];
+        let location = '';
+        for (const line of stackLines) {
+            if (line && !line.includes('expect-webdriverio') && !line.includes('node_modules')) {
+                location = line.trim();
+                break;
+            }
+        }
+        const failures = this.failureMap.get(testId) || [];
+        failures.push({ error, matcherName, location });
+        this.failureMap.set(testId, failures);
+    }
+    getFailures(testId) {
+        const id = testId || this.getCurrentTestId();
+        if (!id) {
+            return [];
+        }
+        return this.failureMap.get(id) || [];
+    }
+    clearFailures(testId) {
+        const id = testId || this.getCurrentTestId();
+        if (id) {
+            this.failureMap.delete(id);
+        }
+    }
+    assertNoFailures(testId) {
+        const id = testId || this.getCurrentTestId();
+        if (!id) {
+            return;
+        }
+        const failures = this.getFailures(id);
+        if (failures.length === 0) {
+            return;
+        }
+        let message = `${failures.length} soft assertion failure${failures.length > 1 ? 's' : ''}:\n\n`;
+        failures.forEach((failure, index) => {
+            message += `${index + 1}) ${failure.matcherName}: ${failure.error.message}\n`;
+            if (failure.location) {
+                message += `   at ${failure.location}\n`;
+            }
+            message += '\n';
+        });
+        this.clearFailures(id);
+        const error = new Error(message);
+        error.name = 'SoftAssertionsError';
+        throw error;
+    }
+}

package/lib/softAssertService.js

@@ -0,0 +1,47 @@
+import { SoftAssertService } from './softAssert';
+export class SoftAssertionService {
+    constructor(serviceOptions) {
+        this.softAssertService = SoftAssertService.getInstance();
+        this.options = {
+            autoAssertOnTestEnd: true,
+            ...serviceOptions
+        };
+    }
+    beforeTest(test) {
+        const testId = this.getTestId(test);
+        this.softAssertService.setCurrentTest(testId, test.title, test.file);
+    }
+    beforeStep(step, scenario) {
+        const stepId = `${scenario.uri || ''}:${scenario.name || ''}:${step.text || ''}`;
+        this.softAssertService.setCurrentTest(stepId, step.text, scenario.uri);
+    }
+    afterTest(test, _, result) {
+        if (!result.error && this.options.autoAssertOnTestEnd) {
+            try {
+                const testId = this.getTestId(test);
+                this.softAssertService.assertNoFailures(testId);
+            }
+            catch (error) {
+                result.error = error;
+                result.passed = false;
+            }
+        }
+        this.softAssertService.clearCurrentTest();
+    }
+    afterStep(step, scenario, result) {
+        if (result.passed) {
+            try {
+                const stepId = `${scenario.uri || ''}:${scenario.name || ''}:${step.text || ''}`;
+                this.softAssertService.assertNoFailures(stepId);
+            }
+            catch (error) {
+                result.error = error;
+                result.passed = false;
+            }
+        }
+        this.softAssertService.clearCurrentTest();
+    }
+    getTestId(test) {
+        return `${test.file || ''}:${test.parent || ''}:${test.title || ''}`;
+    }
+}

package/lib/softExpect.js

@@ -0,0 +1,68 @@
+import { expect, matchers } from './index.js';
+import { SoftAssertService } from './softAssert.js';
+const createSoftExpect = (actual) => {
+    const softService = SoftAssertService.getInstance();
+    return new Proxy({}, {
+        get(target, prop) {
+            const propName = String(prop);
+            if (propName === 'not') {
+                return createSoftNotProxy(actual, softService);
+            }
+            if (propName === 'resolves' || propName === 'rejects') {
+                return createSoftChainProxy(actual, propName, softService);
+            }
+            if (matchers.has(propName)) {
+                return createSoftMatcher(actual, propName, softService);
+            }
+            return undefined;
+        }
+    });
+};
+const createSoftNotProxy = (actual, softService) => {
+    return new Proxy({}, {
+        get(target, prop) {
+            const propName = String(prop);
+            if (matchers.has(propName)) {
+                return createSoftMatcher(actual, propName, softService, 'not');
+            }
+            return undefined;
+        }
+    });
+};
+const createSoftChainProxy = (actual, chainType, softService) => {
+    return new Proxy({}, {
+        get(target, prop) {
+            const propName = String(prop);
+            if (matchers.has(propName)) {
+                return createSoftMatcher(actual, propName, softService, chainType);
+            }
+            return undefined;
+        }
+    });
+};
+const createSoftMatcher = (actual, matcherName, softService, prefix) => {
+    return async (...args) => {
+        try {
+            let expectChain = expect(actual);
+            if (prefix === 'not') {
+                expectChain = expectChain.not;
+            }
+            else if (prefix === 'resolves') {
+                expectChain = expectChain.resolves;
+            }
+            else if (prefix === 'rejects') {
+                expectChain = expectChain.rejects;
+            }
+            return await expectChain[matcherName](...args);
+        }
+        catch (error) {
+            const fullMatcherName = prefix ? `${prefix}.${matcherName}` : matcherName;
+            softService.addFailure(error, fullMatcherName);
+            return {
+                pass: true,
+                message: () => `Soft assertion failed: ${fullMatcherName}`
+            };
+        }
+    };
+};
+export default createSoftExpect;

package/lib/tsconfig.build.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/types.ts","../src/utils.ts","../src/matchers/snapshot.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveClass.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/refetchElements.ts"],"version":"5.7.3"}
+{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/softAssert.ts","../src/softAssertService.ts","../src/softExpect.ts","../src/types.ts","../src/utils.ts","../src/matchers/snapshot.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveClass.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/refetchElements.ts"],"version":"5.8.3"}

package/lib/utils.js

@@ -1,5 +1,5 @@
 import isEqual from 'lodash.isequal';
-import { expect } from './index.js';
+import { expect } from 'expect';
 import { DEFAULT_OPTIONS } from './constants.js';
 import { wrapExpectedWithArray } from './util/elementsUtil.js';
 import { executeCommand } from './util/executeCommand.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "5.1.0",
+  "version": "5.2.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -70,14 +70,14 @@
     "@types/node": "^22.9.0",
     "@wdio/types": "^9.9.0",
     "@vitest/coverage-v8": "^3.0.5",
-    "@wdio/eslint": "^0.0.5",
+    "@wdio/eslint": "^0.1.0",
     "c8": "^10.1.2",
     "eslint": "^9.15.0",
     "husky": "^9.1.5",
     "npm-run-all2": "^7.0.1",
-    "release-it": "^18.1.1",
+    "release-it": "^19.0.1",
     "rimraf": "^6.0.1",
-    "shelljs": "^0.8.5",
+    "shelljs": "^0.9.1",
     "typescript": "^5.5.4",
     "vitest": "^3.0.4",
     "webdriverio": "^9.2.11"

package/types/expect-webdriverio.d.ts

@@ -14,6 +14,35 @@ declare namespace ExpectWebdriverIO {
         }
     }
 
+    interface SoftFailure {
+        error: Error;
+        matcherName: string;
+        location?: string;
+    }
+
+    class SoftAssertService {
+        static getInstance(): SoftAssertService;
+        setCurrentTest(testId: string, testName?: string, testFile?: string): void;
+        clearCurrentTest(): void;
+        getCurrentTestId(): string | null;
+        addFailure(error: Error, matcherName: string): void;
+        getFailures(testId?: string): SoftFailure[];
+        clearFailures(testId?: string): void;
+        assertNoFailures(testId?: string): void;
+    }
+
+    interface SoftAssertionServiceOptions {
+        autoAssertOnTestEnd?: boolean;
+    }
+
+    class SoftAssertionService implements import('@wdio/types').Services.ServiceInstance {
+        constructor(serviceOptions?: SoftAssertionServiceOptions, capabilities?: any, config?: any);
+        beforeTest(test: import('@wdio/types').Frameworks.Test): void;
+        beforeStep(step: import('@wdio/types').Frameworks.PickleStep, scenario: import('@wdio/types').Frameworks.Scenario): void;
+        afterTest(test: import('@wdio/types').Frameworks.Test, context: any, result: import('@wdio/types').Frameworks.TestResult): void;
+        afterStep(step: import('@wdio/types').Frameworks.PickleStep, scenario: import('@wdio/types').Frameworks.Scenario, result: { passed: boolean, error?: Error }): void;
+    }
+
     interface AssertionResult {
         pass: boolean
         message(): string
@@ -447,6 +476,57 @@ declare namespace ExpectWebdriverIO {
         asymmetricMatch(...args: any[]): boolean
         toString(): string
     }
+
+    /**
+     * expect function declaration, containing two generics:
+     *  - T: the type of the actual value, e.g. WebdriverIO.Browser or WebdriverIO.Element
+     *  - R: the type of the return value, e.g. Promise<void> or void
+     */
+    interface Expect {
+        <T = unknown, R extends void | Promise<void> = void | Promise<void>>(actual: T): Matchers<R, T>
+
+        /**
+         * Creates a soft assertion wrapper around standard expect
+         * Soft assertions record failures but don't throw errors immediately
+         * All failures are collected and reported at the end of the test
+         */
+        soft<T = unknown>(actual: T): Matchers<Promise<void>, T>
+
+        /**
+         * Get all current soft assertion failures
+         */
+        getSoftFailures(testId?: string): SoftFailure[]
+
+        /**
+         * Manually assert all soft failures (throws an error if any failures exist)
+         */
+        assertSoftFailures(testId?: string): void
+
+        /**
+         * Clear all current soft assertion failures
+         */
+        clearSoftFailures(testId?: string): void
+
+        // Standard asymmetric matchers from Jest
+        extend(map: Record<string, Function>): void
+        anything(): PartialMatcher
+        any(sample: unknown): PartialMatcher
+        stringContaining(expected: string): PartialMatcher
+        objectContaining(sample: Record<string, unknown>): PartialMatcher
+        arrayContaining(sample: Array<unknown>): PartialMatcher
+        stringMatching(expected: string | RegExp): PartialMatcher
+        not: AsymmetricMatchers
+    }
+
+    interface AsymmetricMatchers {
+        any(expectedObject: any): PartialMatcher
+        anything(): PartialMatcher
+        arrayContaining(sample: Array<unknown>): PartialMatcher
+        objectContaining(sample: Record<string, unknown>): PartialMatcher
+        stringContaining(expected: string): PartialMatcher
+        stringMatching(expected: string | RegExp): PartialMatcher
+        not: AsymmetricMatchers
+    }
 }
 
 declare module 'expect-webdriverio' {