expect-webdriverio 5.3.3 → 5.3.4

package/lib/test/matchers/mock/toBeRequestedWith.test.js

@@ -1,343 +0,0 @@
-import { vi, test, describe, expect, beforeEach, afterEach } from 'vitest';
-import { toBeRequestedWith } from '../../../src/matchers/mock/toBeRequestedWith.js';
-import { removeColors, getExpectMessage, getExpected, getReceived } from '../../__fixtures__/utils.js';
-vi.mock('@wdio/globals');
-class TestMock {
-    constructor() {
-        this._calls = [];
-    }
-    get calls() {
-        return this._calls;
-    }
-}
-function reduceHeaders(headers) {
-    return Object.entries(headers).reduce((acc, [, value]) => {
-        acc[value.name] = value.value.value;
-        return acc;
-    }, {});
-}
-const authKey = 'Bearer ' + '2'.repeat(128);
-const mockGet = {
-    request: {
-        url: 'http://localhost:8080/api/search?pages=20',
-        method: 'GET',
-        request: '123',
-        headersSize: 123,
-        bodySize: 123,
-        timings: {},
-        cookies: [],
-        headers: [{
-                name: 'Authorization',
-                value: { type: 'string', value: authKey }
-            }, {
-                name: 'foo',
-                value: { type: 'string', value: 'bar' }
-            }]
-    },
-    response: {
-        headers: {},
-        status: 200,
-    },
-};
-const mockPost = {
-    request: {
-        url: 'https://my-app/api/add-tags',
-        method: 'POST',
-        request: '123',
-        headersSize: 123,
-        bodySize: 123,
-        timings: {},
-        cookies: [],
-        headers: [{
-                name: 'Authorization',
-                value: { type: 'string', value: authKey }
-            }, {
-                name: 'foo',
-                value: { type: 'string', value: 'bar' }
-            }, {
-                name: 'Accept',
-                value: { type: 'string', value: '*' }
-            }],
-    },
-    response: {
-        status: 201,
-        headers: []
-    },
-};
-describe('toBeRequestedWith', () => {
-    test('wait for success, exact match', async () => {
-        const mock = new TestMock();
-        setTimeout(() => {
-            mock.calls.push({ ...mockGet });
-        }, 5);
-        setTimeout(() => {
-            mock.calls.push({ ...mockGet }, { ...mockPost });
-        }, 15);
-        const params = {
-            url: mockPost.request.url,
-            method: mockPost.request.method,
-            requestHeaders: {},
-            statusCode: mockPost.response.status,
-            responseHeaders: {},
-        };
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toBeRequestedWith.call({}, mock, params, { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedWith',
-            expectedValue: params,
-            options: { beforeAssertion, afterAssertion },
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedWith',
-            expectedValue: params,
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait for failure', async () => {
-        const mock = new TestMock();
-        setTimeout(() => {
-            mock.calls.push({ ...mockGet }, { ...mockPost });
-        }, 15);
-        const params = {
-            url: 'post.url',
-            method: 'post.method',
-            requestHeaders: {},
-            responseHeaders: {}
-        };
-        const result = await toBeRequestedWith.call({}, mock, params);
-        expect(result.pass).toBe(false);
-    });
-    test('wait for NOT failure, empty params', async () => {
-        const mock = new TestMock();
-        mock.calls.push({ ...mockGet }, { ...mockPost });
-        setTimeout(() => {
-            mock.calls.push({ ...mockGet }, { ...mockPost });
-        }, 10);
-        const result = await toBeRequestedWith.call({ isNot: true }, mock, {});
-        expect(result.pass).toBe(true);
-    });
-    test('wait for NOT success', async () => {
-        const mock = new TestMock();
-        setTimeout(() => {
-            mock.calls.push({ ...mockGet }, { ...mockPost });
-        }, 10);
-        const result = await toBeRequestedWith.call({ isNot: true }, mock, { method: 'DELETE' });
-        expect(result.pass).toBe(false);
-    });
-    const scenarios = [
-        {
-            name: 'success, url only',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                url: mockPost.request.url,
-            },
-        },
-        {
-            name: 'success, method only',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                method: ['DELETE', 'PUT', mockPost.request.method, 'GET'],
-            },
-        },
-        {
-            name: 'success, statusCode only',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                statusCode: [203, 200, 201],
-            },
-        },
-        {
-            name: 'success, requestHeaders only',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                requestHeaders: {
-                    Authorization: authKey,
-                    foo: 'bar',
-                    Accept: '*'
-                },
-            },
-        },
-        {
-            name: 'success, responseHeaders only',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                responseHeaders: {},
-            },
-        },
-        {
-            name: 'failure, url only',
-            mocks: [{ ...mockPost }],
-            pass: false,
-            params: {
-                url: '/api/api',
-            },
-        },
-        {
-            name: 'failure, method only',
-            mocks: [{ ...mockPost }],
-            pass: false,
-            params: {
-                method: ['DELETE', 'PUT'],
-            },
-        },
-        {
-            name: 'failure, statusCode only',
-            mocks: [{ ...mockPost }],
-            pass: false,
-            params: {
-                statusCode: [400, 401],
-            },
-        },
-        {
-            name: 'failure, requestHeaders only',
-            mocks: [{ ...mockPost }],
-            pass: false,
-            params: {
-                requestHeaders: { Cache: 'false' },
-            },
-        },
-        {
-            name: 'failure, responseHeaders only',
-            mocks: [{ ...mockPost }],
-            pass: false,
-            params: {
-                responseHeaders: { Cache: 'false' },
-            },
-        },
-        {
-            name: 'special matcher, url',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                url: expect.stringMatching(/.*\/API\/.*/i),
-            },
-        },
-        {
-            name: 'special matcher, headers',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                requestHeaders: expect.objectContaining({
-                    Authorization: expect.stringContaining('Bearer '),
-                }),
-            },
-        },
-        {
-            name: 'special matcher, postData',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                postData: expect.stringMatching('"search"'),
-            },
-        },
-        {
-            name: 'special matcher, response',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                response: expect.arrayContaining([expect.objectContaining({ id: 2 })]),
-            },
-        },
-        {
-            name: 'function, url',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                url: (url) => url.startsWith('https'),
-            },
-        },
-        {
-            name: 'function, headers',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                requestHeaders: (headers) => headers.foo === 'bar',
-            },
-        },
-        {
-            name: 'function, postData',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                postData: (r) => JSON.parse(r).length === 2,
-            },
-        },
-        {
-            name: 'function, response',
-            mocks: [{ ...mockPost }],
-            pass: true,
-            params: {
-                response: (r) => r.includes('id') && r.includes('name'),
-            },
-        },
-    ];
-    scenarios.forEach((scenario) => {
-        test(scenario.name, async () => {
-            const mock = new TestMock();
-            mock.calls.push(...scenario.mocks);
-            const result = await toBeRequestedWith.call({}, mock, scenario.params);
-            expect(result.pass).toBe(scenario.pass);
-        });
-    });
-    describe('error messages', () => {
-        const consoleError = global.console.error;
-        beforeEach(() => {
-            global.console.error = vi.fn();
-        });
-        test('unsupported method', async () => {
-            const mock = new TestMock();
-            mock.calls.push({ ...mockGet });
-            const result = await toBeRequestedWith.call({}, mock, { method: 1234 });
-            expect(result.pass).toBe(false);
-            expect(global.console.error).toBeCalledWith('expect.toBeRequestedWith: unsupported value passed to method 1234');
-        });
-        afterEach(() => {
-            global.console.error = consoleError;
-        });
-    });
-    test('message', async () => {
-        const mock = new TestMock();
-        const requested = await toBeRequestedWith.call({}, mock, {
-            url: () => false,
-            method: ['DELETE', 'PUT'],
-            requestHeaders: reduceHeaders(mockPost.request.headers),
-            responseHeaders: reduceHeaders(mockPost.response.headers),
-            postData: expect.anything(),
-            response: [...Array(50).keys()].map((_, id) => ({ id, name: `name_${id}` })),
-        });
-        const wasNotCalled = removeColors(requested.message());
-        expect(getExpectMessage(wasNotCalled)).toBe('Expect mock to be called with');
-        expect(getExpected(wasNotCalled)).toBe('Expected: {' +
-            '"method": ["DELETE", "PUT"], ' +
-            '"postData": "Anything ", ' +
-            '"requestHeaders": {"Accept": "*", "Authorization": "Bearer ..2222222", "foo": "bar"}, ' +
-            '"response": [{"id": 0, "name": "name_0"}, "... 49 more items"], ' +
-            '"responseHeaders": {}, ' +
-            '"url": "() => false"}');
-        expect(getReceived(wasNotCalled)).toBe('Received: "was not called"');
-        mock.calls.push(mockPost);
-        const notRequested = await toBeRequestedWith.call({ isNot: true }, mock, {
-            url: () => true,
-            method: mockPost.request.method,
-        });
-        const wasCalled = removeColors(notRequested.message());
-        expect(wasCalled).toBe(`Expect mock not to be called with
-
-- Expected [not]  - 1
-+ Received        + 1
-
-  Object {
-    "method": "POST",
--   "url": "() => true",
-+   "url": "https://my-app/api/add-tags",
-  }`);
-    });
-});

package/lib/test/matchers.test.js

@@ -1,54 +0,0 @@
-import { test, expect, vi } from 'vitest';
-import { matchers, expect as expectLib } from '../src/index.js';
-const ALL_MATCHERS = [
-    'toHaveClipboardText',
-    'toHaveTitle',
-    'toHaveUrl',
-    'toBeClickable',
-    'toBeDisabled',
-    'toBeDisplayed',
-    'toBeDisplayedInViewport',
-    'toBeEnabled',
-    'toExist',
-    'toBeExisting',
-    'toBePresent',
-    'toBeFocused',
-    'toBeSelected',
-    'toBeChecked',
-    'toHaveAttributeAndValue',
-    'toHaveAttribute',
-    'toHaveAttr',
-    'toHaveChildren',
-    'toHaveClass',
-    'toHaveElementClass',
-    'toHaveClassContaining',
-    'toHaveComputedLabel',
-    'toHaveComputedRole',
-    'toHaveElementProperty',
-    'toHaveHeight',
-    'toHaveHref',
-    'toHaveLink',
-    'toHaveHTML',
-    'toHaveId',
-    'toHaveSize',
-    'toHaveStyle',
-    'toHaveText',
-    'toHaveValue',
-    'toHaveWidth',
-    'toBeElementsArrayOfSize',
-    'toBeRequested',
-    'toBeRequestedTimes',
-    'toBeRequestedWith',
-    'toBeRequestedWithResponse',
-    'toMatchSnapshot',
-    'toMatchInlineSnapshot'
-];
-test('matchers', () => {
-    expect([...matchers.keys()]).toEqual(ALL_MATCHERS);
-});
-test('allows to add matcher', () => {
-    const matcher = vi.fn((actual, expected) => ({ pass: actual === expected }));
-    expectLib.extend({ toBeCustom: matcher });
-    expectLib('foo').toBeCustom('foo');
-    expect(matchers.keys()).toContain('toBeCustom');
-});

package/lib/test/snapshot.test.js

@@ -1,53 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { test, expect } from 'vitest';
-import { expect as expectExport, SnapshotService } from '../src/index.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const __filename = path.basename(fileURLToPath(import.meta.url));
-const service = SnapshotService.initiate({
-    resolveSnapshotPath: (path, extension) => path + extension
-});
-test('supports snapshot testing', async () => {
-    await service.beforeTest({
-        title: 'test',
-        parent: 'parent',
-        file: path.join(__dirname, __filename),
-    });
-    process.env.WDIO_INTERNAL_TEST = 'true';
-    const exp = expectExport;
-    expect(exp).toBeDefined();
-    expect(exp({}).toMatchSnapshot).toBeDefined();
-    expect(exp({}).toMatchInlineSnapshot).toBeDefined();
-    await exp({ a: 'a' }).toMatchSnapshot();
-    await exp({ deep: { nested: { object: 'value' } } }).toMatchInlineSnapshot(`
-      {
-        "deep": {
-          "nested": {
-            "object": "value",
-          },
-        },
-      }
-    `);
-    await service.after();
-    const expectedSnapfileExist = await fs.access(path.resolve(__dirname, 'snapshot.test.ts.snap'))
-        .then(() => true, () => false);
-    expect(expectedSnapfileExist).toBe(true);
-});
-test('supports cucumber snapshot testing', async () => {
-    await service.beforeStep({
-        text: 'Fake step',
-    }, {
-        name: 'Fake scenario',
-        uri: `${__dirname}/file.feature`,
-    });
-    const exp = expectExport;
-    expect(exp).toBeDefined();
-    expect(exp({}).toMatchSnapshot).toBeDefined();
-    expect(exp({}).toMatchInlineSnapshot).toBeDefined();
-    await exp({ cucum: 'ber' }).toMatchSnapshot();
-    await service.after();
-    const expectedSnapfileExist = await fs.access(path.resolve(__dirname, 'file.feature.snap'))
-        .then(() => true, () => false);
-    expect(expectedSnapfileExist).toBe(true);
-});