expect-webdriverio 5.3.3 → 5.4.0

package/lib/test/matchers/elements/toBeElementsArrayOfSize.test.js

@@ -1,141 +0,0 @@
-import { vi, test, describe, expect, beforeEach } from 'vitest';
-import { $$ } from '@wdio/globals';
-import { getExpectMessage, getReceived, getExpected } from '../../__fixtures__/utils.js';
-import { toBeElementsArrayOfSize } from '../../../src/matchers/elements/toBeElementsArrayOfSize.js';
-const createMockElementArray = (length) => {
-    const array = Array.from({ length }, () => ({}));
-    const mockArray = {
-        selector: 'parent',
-        get length() { return array.length; },
-        set length(newLength) { array.length = newLength; },
-        parent: {
-            $: vi.fn(),
-            $$: vi.fn().mockReturnValue(array),
-        },
-        foundWith: '$$',
-        props: [],
-        [Symbol.iterator]: array[Symbol.iterator].bind(array),
-        filter: vi.fn().mockReturnThis(),
-        map: vi.fn().mockReturnThis(),
-        find: vi.fn().mockReturnThis(),
-        forEach: vi.fn(),
-        some: vi.fn(),
-        every: vi.fn(),
-        slice: vi.fn().mockReturnThis(),
-        toArray: vi.fn().mockReturnThis(),
-    };
-    return Object.assign(array, mockArray);
-};
-vi.mock('@wdio/globals', () => ({
-    $$: vi.fn().mockImplementation(() => createMockElementArray(2))
-}));
-describe('toBeElementsArrayOfSize', () => {
-    let els;
-    beforeEach(() => {
-        els = $$('parent');
-    });
-    describe('success', () => {
-        test('array of size 2', async () => {
-            const beforeAssertion = vi.fn();
-            const afterAssertion = vi.fn();
-            const result = await toBeElementsArrayOfSize.call({}, els, 2, { beforeAssertion, afterAssertion });
-            expect(result.pass).toBe(true);
-            expect(beforeAssertion).toBeCalledWith({
-                matcherName: 'toBeElementsArrayOfSize',
-                expectedValue: 2,
-                options: { beforeAssertion, afterAssertion }
-            });
-            expect(afterAssertion).toBeCalledWith({
-                matcherName: 'toBeElementsArrayOfSize',
-                expectedValue: 2,
-                options: { beforeAssertion, afterAssertion },
-                result
-            });
-        });
-        test('array of size 5', async () => {
-            els = createMockElementArray(5);
-            const result = await toBeElementsArrayOfSize.call({}, els, 5, {});
-            expect(result.pass).toBe(true);
-        });
-    });
-    describe('failure', () => {
-        let result;
-        beforeEach(async () => {
-            result = await toBeElementsArrayOfSize.call({}, els, 5, {});
-        });
-        test('fails', () => {
-            expect(result.pass).toBe(false);
-        });
-        describe('message shows correctly', () => {
-            test('expect message', () => {
-                expect(getExpectMessage(result.message())).toContain('to be elements array of size');
-            });
-            test('expected message', () => {
-                expect(getExpected(result.message())).toContain('5');
-            });
-            test('received message', () => {
-                expect(getReceived(result.message())).toContain('2');
-            });
-        });
-    });
-    describe('error catching', () => {
-        test('throws error with incorrect size param', async () => {
-            await expect(toBeElementsArrayOfSize.call({}, els, '5')).rejects.toThrow('Invalid params passed to toBeElementsArrayOfSize.');
-        });
-        test('works if size contains options', async () => {
-            const result = await toBeElementsArrayOfSize.call({}, els, { lte: 5 });
-            expect(result.pass).toBe(true);
-        });
-    });
-    describe('number options', () => {
-        test.each([
-            ['lte', 10, true],
-            ['lte', 1, false],
-            ['gte', 1, true],
-            ['gte', 10, false],
-            ['gte and lte', { gte: 1, lte: 10 }, true],
-            ['not gte but is lte', { gte: 10, lte: 10 }, false],
-            ['not lte but is gte', { gte: 1, lte: 1 }, false],
-        ])('should handle %s correctly', async (_, option, expected) => {
-            const result = await toBeElementsArrayOfSize.call({}, els, typeof option === 'object' ? option : { [_]: option });
-            expect(result.pass).toBe(expected);
-        });
-    });
-    describe('array update', () => {
-        test('updates the received array when assertion passes', async () => {
-            const receivedArray = createMockElementArray(2);
-            receivedArray.parent._length = 5;
-            receivedArray.parent.$$ = vi.fn().mockReturnValue(createMockElementArray(5));
-            const result = await toBeElementsArrayOfSize.call({}, receivedArray, 5);
-            expect(result.pass).toBe(true);
-            expect(receivedArray.length).toBe(5);
-        });
-        test('does not update the received array when assertion fails', async () => {
-            const receivedArray = createMockElementArray(2);
-            const result = await toBeElementsArrayOfSize.call({}, receivedArray, 10);
-            expect(result.pass).toBe(false);
-            expect(receivedArray.length).toBe(2);
-        });
-        test('does not modify non-array received values', async () => {
-            const nonArrayEls = {
-                selector: 'parent',
-                length: 2,
-                parent: {
-                    $: vi.fn(),
-                    $$: vi.fn().mockReturnValue(createMockElementArray(5)),
-                },
-                foundWith: '$$',
-                props: [],
-            };
-            const result = await toBeElementsArrayOfSize.call({}, nonArrayEls, 5);
-            expect(result.pass).toBe(true);
-            expect(nonArrayEls.length).toBe(2);
-        });
-        test('does not alter the array when checking', async () => {
-            const receivedArray = createMockElementArray(2);
-            const result = await toBeElementsArrayOfSize.call({}, receivedArray, 2);
-            expect(result.pass).toBe(true);
-            expect(receivedArray.length).toBe(2);
-        });
-    });
-});

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

@@ -1,73 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { toBeRequested } from '../../../src/matchers/mock/toBeRequested.js';
-import { getExpected, getExpectMessage, getReceived, removeColors } from '../../__fixtures__/utils.js';
-vi.mock('@wdio/globals');
-class TestMock {
-    constructor() {
-        this.on = vi.fn();
-        this._calls = [];
-    }
-    get calls() {
-        return this._calls;
-    }
-    abort() { return Promise.resolve(); }
-    abortOnce() { return Promise.resolve(); }
-    respond() { return Promise.resolve(); }
-    respondOnce() { return Promise.resolve(); }
-    clear() { return Promise.resolve(); }
-    restore() { return Promise.resolve(); }
-    waitForResponse() { return Promise.resolve(true); }
-}
-const mockMatch = {
-    body: 'foo',
-    url: '/foo/bar',
-    method: 'POST',
-    headers: {},
-    responseHeaders: {},
-    statusCode: 200,
-    initialPriority: 'Low',
-    referrerPolicy: 'origin'
-};
-describe('toBeRequested', () => {
-    test('wait for success', async () => {
-        const mock = new TestMock();
-        const result = await toBeRequested(mock);
-        expect(result.pass).toBe(false);
-        setTimeout(() => {
-            mock.calls.push(mockMatch);
-            mock.calls.push(mockMatch);
-        }, 10);
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result2 = await toBeRequested(mock, { beforeAssertion, afterAssertion });
-        expect(result2.pass).toBe(true);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedTimes',
-            expectedValue: { gte: 1 },
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedTimes',
-            expectedValue: { gte: 1 },
-            options: { beforeAssertion, afterAssertion },
-            result: result2
-        });
-    });
-    test('not to be called', async () => {
-        const mock = new TestMock();
-        const result = await toBeRequested.call({ isNot: true }, mock);
-        expect(result.pass).toBe(false);
-        mock.calls.push(mockMatch);
-        const result4 = await toBeRequested.call({ isNot: true }, mock);
-        expect(result4.pass).toBe(true);
-    });
-    test('message', async () => {
-        const mock = new TestMock();
-        const message = removeColors((await toBeRequested(mock)).message());
-        expect(getExpectMessage(message)).toBe('Expect mock to be called');
-        expect(getReceived(message)).toBe('Received: 0');
-        expect(getExpected(message)).toBe('Expected: ">= 1"');
-        const result2 = await toBeRequested.call({ isNot: true }, mock);
-        expect(result2.message()).toContain('Expect mock not to be called');
-    });
-});

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

@@ -1,108 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { toBeRequestedTimes } from '../../../src/matchers/mock/toBeRequestedTimes.js';
-import { removeColors, getReceived, getExpected, getExpectMessage } from '../../__fixtures__/utils.js';
-vi.mock('@wdio/globals');
-class TestMock {
-    constructor() {
-        this.on = vi.fn();
-        this._calls = [];
-    }
-    get calls() {
-        return this._calls;
-    }
-    abort() { return Promise.resolve(); }
-    abortOnce() { return Promise.resolve(); }
-    respond() { return Promise.resolve(); }
-    respondOnce() { return Promise.resolve(); }
-    clear() { return Promise.resolve(); }
-    restore() { return Promise.resolve(); }
-    waitForResponse() { return Promise.resolve(true); }
-}
-const mockMatch = {
-    body: 'foo',
-    url: '/foo/bar',
-    method: 'POST',
-    headers: {},
-    responseHeaders: {},
-    statusCode: 200,
-    initialPriority: 'Low',
-    referrerPolicy: 'origin'
-};
-describe('toBeRequestedTimes', () => {
-    test('wait for success', async () => {
-        const mock = new TestMock();
-        setTimeout(() => {
-            mock.calls.push(mockMatch);
-        }, 10);
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toBeRequestedTimes.call({}, mock, 1, { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedTimes',
-            expectedValue: 1,
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toBeRequestedTimes',
-            expectedValue: 1,
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait for success using number options', async () => {
-        const mock = new TestMock();
-        setTimeout(() => {
-            mock.calls.push(mockMatch);
-        }, 10);
-        const result = await toBeRequestedTimes.call({}, mock, { gte: 1 });
-        expect(result.pass).toBe(true);
-        const result2 = await toBeRequestedTimes.call({}, mock, { eq: 1 });
-        expect(result2.pass).toBe(true);
-    });
-    test('wait but failure', async () => {
-        const mock = new TestMock();
-        const result = await toBeRequestedTimes.call({}, mock, 1);
-        expect(result.pass).toBe(false);
-        setTimeout(() => {
-            mock.calls.push(mockMatch);
-            mock.calls.push(mockMatch);
-        }, 10);
-        const result2 = await toBeRequestedTimes.call({}, mock, 1);
-        expect(result2.pass).toBe(false);
-        const result3 = await toBeRequestedTimes.call({}, mock, 2);
-        expect(result3.pass).toBe(true);
-        const result4 = await toBeRequestedTimes.call({}, mock, { gte: 2 });
-        expect(result4.pass).toBe(true);
-        const result5 = await toBeRequestedTimes.call({}, mock, { lte: 2 });
-        expect(result5.pass).toBe(true);
-        const result6 = await toBeRequestedTimes.call({}, mock, { lte: 3 });
-        expect(result6.pass).toBe(true);
-    });
-    test('not to be called', async () => {
-        const mock = new TestMock();
-        const result = await toBeRequestedTimes.call({ isNot: true }, mock, 0);
-        expect(result.pass).toBe(true);
-        const result2 = await toBeRequestedTimes.call({ isNot: true }, mock, 1);
-        expect(result2.pass).toBe(false);
-        mock.calls.push(mockMatch);
-        const result3 = await toBeRequestedTimes.call({ isNot: true }, mock, 0);
-        expect(result3.pass).toBe(false);
-        const result4 = await toBeRequestedTimes.call({ isNot: true }, mock, 1);
-        expect(result4.pass).toBe(true);
-    });
-    test('message', async () => {
-        const mock = new TestMock();
-        const result = await toBeRequestedTimes.call({}, mock, 0);
-        expect(result.message()).toContain('Expect mock to be called 0 times');
-        const result2 = await toBeRequestedTimes.call({}, mock, 1);
-        expect(result2.message()).toContain('Expect mock to be called 1 time');
-        const result3 = await toBeRequestedTimes.call({}, mock, 2);
-        expect(result3.message()).toContain('Expect mock to be called 2 times');
-        const result4 = await toBeRequestedTimes.call({}, mock, { gte: 3 });
-        const message4 = removeColors(result4.message());
-        expect(getExpectMessage(message4)).toBe('Expect mock to be called times');
-        expect(getExpected(message4)).toBe('Expected: ">= 3"');
-        expect(getReceived(message4)).toBe('Received: 0');
-    });
-});

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",
-  }`);
-    });
-});