expect-webdriverio 5.3.3 → 5.3.4

package/lib/test/matchers/element/toHaveWidth.test.js

@@ -1,171 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveWidth } from '../../../src/matchers/element/toHaveWidth.js';
-vi.mock('@wdio/globals');
-describe('toHaveWidth', () => {
-    test('wait for success', async () => {
-        const el = await $('sel');
-        el._attempts = 2;
-        el._size = function (property) {
-            if (this._attempts > 0) {
-                this._attempts--;
-                return null;
-            }
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveWidth.call({}, el, 50, { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveWidth',
-            expectedValue: 50,
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveWidth',
-            expectedValue: 50,
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            throw new Error('some error');
-        };
-        await expect(() => toHaveWidth.call({}, el, 10, {}))
-            .rejects.toThrow('some error');
-    });
-    test('success on the first attempt', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._size = function (property) {
-            this._attempts++;
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.call({}, el, 50, {});
-        expect(result.message()).toEqual('Expect $(`sel`) to have width\n\nExpected: 50\nReceived: serializes to the same string');
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - failure', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._size = function (property) {
-            this._attempts++;
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.call({}, el, 10, { wait: 0 });
-        expect(result.message()).toEqual('Expect $(`sel`) to have width\n\nExpected: 10\nReceived: 50');
-        expect(result.pass).toBe(false);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - success', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._size = function (property) {
-            this._attempts++;
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.call({}, el, 50, { wait: 0 });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('gte and lte', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._size = function (property) {
-            this._attempts++;
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.call({}, el, { gte: 49, lte: 51 }, { wait: 0 });
-        expect(result.message()).toEqual('Expect $(`sel`) to have width\n\nExpected: ">= 49 && <= 51"\nReceived: 50');
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('not - failure', async () => {
-        const el = await $('sel');
-        el._size = function (property) {
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.call({}, el, 50, { wait: 0 });
-        const received = getReceived(result.message());
-        expect(received).not.toContain('not');
-        expect(result.pass).toBe(true);
-    });
-    test("should return false if sizes don't match", async () => {
-        const el = await $('sel');
-        el._size = function (property) {
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.bind({})(el, 10, { wait: 1 });
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if sizes match', async () => {
-        const el = await $('sel');
-        el._size = function (property) {
-            if (property === 'width') {
-                return 50;
-            }
-            if (property === 'height') {
-                return 32;
-            }
-            return { width: 50, height: 32 };
-        };
-        const result = await toHaveWidth.bind({})(el, 50, { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('message', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            return null;
-        };
-        const result = await toHaveWidth.call({}, el, 50);
-        expect(getExpectMessage(result.message())).toContain('to have width');
-    });
-});

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');
-    });
-});