expect-webdriverio 4.8.1 → 4.9.1

package/lib/index.js

@@ -1,6 +1,5 @@
 import { expect as expectLib } from 'expect';
 import wdioMatchers from './matchers.js';
-import * as expectUtils from './utils.js';
 import { DEFAULT_OPTIONS } from './constants.js';
 expectLib.extend({ ...wdioMatchers });
 export const expect = expectLib;
@@ -14,4 +13,5 @@ export const setDefaultOptions = (options = {}) => {
     });
 };
 export const setOptions = setDefaultOptions;
-export const utils = expectUtils;
+export * from './snapshot.js';
+export * as utils from './utils.js';

package/lib/matchers/snapshot.js

@@ -0,0 +1,86 @@
+import path from 'node:path';
+import { expect } from '../index.js';
+import { SnapshotService } from '../snapshot.js';
+function returnSnapshotError(snapshotError) {
+    try {
+        expect(snapshotError.actual).toBe(snapshotError.expected);
+    }
+    catch (e) {
+        return {
+            pass: false,
+            message: () => e.message
+        };
+    }
+    throw snapshotError;
+}
+function toMatchSnapshotAssert(received, message, inlineOptions) {
+    const snapshotService = SnapshotService.initiate();
+    try {
+        snapshotService.client.assert({
+            received,
+            message,
+            filepath: snapshotService.currentFilePath,
+            name: snapshotService.currentTestName,
+            ...(inlineOptions ? {
+                ...inlineOptions,
+                isInline: true
+            } : {
+                isInline: false
+            })
+        });
+        return {
+            pass: true,
+            message: () => 'Snapshot matches'
+        };
+    }
+    catch (e) {
+        return returnSnapshotError(e);
+    }
+}
+async function toMatchSnapshotAsync(asyncReceived, message, inlineOptions) {
+    let received = await asyncReceived;
+    if (received && typeof received === 'object' && 'elementId' in received) {
+        received = await received.getHTML(true);
+    }
+    return toMatchSnapshotAssert(received, message, inlineOptions);
+}
+function toMatchSnapshotHelper(received, message, inlineOptions) {
+    const snapshotService = SnapshotService.initiate();
+    if (!snapshotService.currentFilePath || !snapshotService.currentTestName) {
+        throw new Error('Snapshot service is not initialized');
+    }
+    if (received && typeof received === 'object' &&
+        ('elementId' in received ||
+            'then' in received)) {
+        return toMatchSnapshotAsync(received, message, inlineOptions);
+    }
+    return toMatchSnapshotAssert(received, message, inlineOptions);
+}
+export function toMatchSnapshot(received, message) {
+    return toMatchSnapshotHelper(received, message);
+}
+export function toMatchInlineSnapshot(received, inlineSnapshot, message) {
+    const browserErrorStack = this.errorStack;
+    function __INLINE_SNAPSHOT__(inlineSnapshot, message) {
+        const error = new Error('inline snapshot');
+        if (browserErrorStack && error.stack) {
+            error.stack = [
+                ...error.stack.split('\n').slice(0, 3),
+                ...browserErrorStack
+                    .split('\n')
+                    .slice(2)
+                    .map((line) => line
+                    .replace(/http:\/\/localhost:\d+/g, '')
+                    .replace('/@fs/', '/'))
+            ].join('\n');
+        }
+        error.stack = error.stack?.split('\n').filter((line) => (line.includes('__INLINE_SNAPSHOT__') ||
+            !(line.includes('__EXTERNAL_MATCHER_TRAP__') ||
+                line.includes(`expect-webdriverio${path.sep}lib${path.sep}matchers${path.sep}snapshot.js:`)))).join('\n');
+        return toMatchSnapshotHelper(received, message, {
+            inlineSnapshot,
+            error
+        });
+    }
+    return __INLINE_SNAPSHOT__(inlineSnapshot, message);
+}

package/lib/matchers.js

@@ -24,6 +24,7 @@ import * as toHaveStyle from './matchers/element/toHaveStyle.js';
 import * as toBeRequested from './matchers/mock/toBeRequested.js';
 import * as toBeRequestedTimes from './matchers/mock/toBeRequestedTimes.js';
 import * as toBeRequestedWith from './matchers/mock/toBeRequestedWith.js';
+import * as snapshotMatchers from './matchers/snapshot.js';
 const matchers = {
     ...toHaveClipboardText,
     ...toHaveTitle,
@@ -51,6 +52,7 @@ const matchers = {
     ...toBeRequested,
     ...toBeRequestedTimes,
     ...toBeRequestedWith,
+    ...snapshotMatchers
 };
 Object.keys(matchers).forEach((key) => {
     if (key.endsWith('Fn')) {

package/lib/snapshot.js

@@ -0,0 +1,72 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _SnapshotService_instances, _SnapshotService_currentFilePath, _SnapshotService_currentTestName, _SnapshotService_options, _SnapshotService_snapshotResults, _SnapshotService_snapshotEnvironment, _SnapshotService_snapshotClient, _SnapshotService_isEqual;
+import { expect } from '@wdio/globals';
+import { SnapshotClient } from '@vitest/snapshot';
+import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
+let service;
+export class SnapshotService {
+    constructor(updateState) {
+        _SnapshotService_instances.add(this);
+        _SnapshotService_currentFilePath.set(this, void 0);
+        _SnapshotService_currentTestName.set(this, void 0);
+        _SnapshotService_options.set(this, void 0);
+        _SnapshotService_snapshotResults.set(this, []);
+        _SnapshotService_snapshotEnvironment.set(this, new NodeSnapshotEnvironment());
+        _SnapshotService_snapshotClient.set(this, new SnapshotClient({
+            isEqual: __classPrivateFieldGet(this, _SnapshotService_instances, "m", _SnapshotService_isEqual).bind(this),
+        }));
+        __classPrivateFieldSet(this, _SnapshotService_options, {
+            updateSnapshot: updateState,
+            snapshotEnvironment: __classPrivateFieldGet(this, _SnapshotService_snapshotEnvironment, "f"),
+        }, "f");
+    }
+    get currentFilePath() {
+        return __classPrivateFieldGet(this, _SnapshotService_currentFilePath, "f");
+    }
+    get currentTestName() {
+        return __classPrivateFieldGet(this, _SnapshotService_currentTestName, "f");
+    }
+    get client() {
+        return __classPrivateFieldGet(this, _SnapshotService_snapshotClient, "f");
+    }
+    get results() {
+        return __classPrivateFieldGet(this, _SnapshotService_snapshotResults, "f");
+    }
+    beforeTest(test) {
+        __classPrivateFieldSet(this, _SnapshotService_currentFilePath, test.file, "f");
+        __classPrivateFieldSet(this, _SnapshotService_currentTestName, `${test.parent} > ${test.title}`, "f");
+        __classPrivateFieldGet(this, _SnapshotService_snapshotClient, "f").startCurrentRun(test.file, test.fullTitle, __classPrivateFieldGet(this, _SnapshotService_options, "f"));
+    }
+    async afterTest() {
+        const result = await __classPrivateFieldGet(this, _SnapshotService_snapshotClient, "f").finishCurrentRun();
+        if (!result) {
+            return;
+        }
+        __classPrivateFieldGet(this, _SnapshotService_snapshotResults, "f").push(result);
+    }
+    static initiate(updateState = 'new') {
+        if (!service) {
+            service = new SnapshotService(updateState);
+        }
+        return service;
+    }
+}
+_SnapshotService_currentFilePath = new WeakMap(), _SnapshotService_currentTestName = new WeakMap(), _SnapshotService_options = new WeakMap(), _SnapshotService_snapshotResults = new WeakMap(), _SnapshotService_snapshotEnvironment = new WeakMap(), _SnapshotService_snapshotClient = new WeakMap(), _SnapshotService_instances = new WeakSet(), _SnapshotService_isEqual = function _SnapshotService_isEqual(received, expected) {
+    try {
+        expect(received).toBe(expected);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.8.1",
+  "version": "4.9.1",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -75,8 +75,8 @@
     "rimraf": "^5.0.5",
     "shelljs": "^0.8.5",
     "typescript": "^5.3.3",
-    "vitest": "1.1.3",
-    "webdriverio": "8.27.0"
+    "vitest": "1.2.0",
+    "webdriverio": "8.27.2"
   },
   "optionalDependencies": {
     "@wdio/globals": "^8.27.0",
@@ -84,6 +84,7 @@
     "webdriverio": "^8.27.0"
   },
   "dependencies": {
+    "@vitest/snapshot": "^1.2.1",
     "expect": "^29.7.0",
     "jest-matcher-utils": "^29.7.0",
     "lodash.isequal": "^4.5.0"

package/types/expect-webdriverio.d.ts

@@ -1,15 +1,16 @@
 declare namespace ExpectWebdriverIO {
-    /**
-     * 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
-     */
-    function expect<T = unknown, R extends void | Promise<void> = void | Promise<void>>(
-        actual: T
-    ): Matchers<R, T>
+    const expect: ExpectWebdriverIO.Expect
     function setOptions(options: DefaultOptions): void
     function getConfig(): any
 
+    class SnapshotService {
+        static initiate(
+            updateState?: import('@vitest/snapshot').SnapshotUpdateState
+        ): import('@wdio/types').Services.ServiceInstance & {
+            results: import('@vitest/snapshot').SnapshotResult[]
+        }
+    }
+
     interface AssertionResult {
         pass: boolean
         message(): string
@@ -467,12 +468,10 @@ declare namespace ExpectWebdriverIO {
         ): R
 
         // ==== network mock ====
-
         /**
          * Check that `WebdriverIO.Mock` was called
          */
         toBeRequested(options?: ExpectWebdriverIO.CommandOptions): R
-
         /**
          * Check that `WebdriverIO.Mock` was called N times
          */
@@ -480,11 +479,21 @@ declare namespace ExpectWebdriverIO {
             times: number | ExpectWebdriverIO.NumberOptions,
             options?: ExpectWebdriverIO.NumberOptions
         ): R
-
         /**
          * Check that `WebdriverIO.Mock` was called with the specific parameters
          */
         toBeRequestedWith(requestedWith: RequestedWith, options?: ExpectWebdriverIO.CommandOptions): R
+        /**
+         * snapshot matcher
+         * @param label optional snapshot label
+         */
+        toMatchSnapshot(label?: string): R
+        /**
+         * inline snapshot matcher
+         * @param snapshot snapshot string (autogenerated if not specified)
+         * @param label optional snapshot label
+         */
+        toMatchInlineSnapshot(snapshot?: string, label?: string): R
     }
 
     type RequestedWith = {

package/types/standalone.d.ts

@@ -10,6 +10,11 @@ declare namespace ExpectWebdriverIO {
         rejects: Matchers<R, T>
     }
 
+    /**
+     * 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
+     */
     type Expect = {
         <T = unknown, R extends void | Promise<void> = void | Promise<void>>(actual: T): Matchers<R, T>
         extend(map: Record<string, Function>): void