expect-webdriverio 5.3.3 → 5.3.4

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

@@ -1,199 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveStyle } from '../../../src/matchers/element/toHaveStyle.js';
-vi.mock('@wdio/globals');
-describe('toHaveStyle', () => {
-    let el;
-    const mockStyle = {
-        'font-family': 'Faktum',
-        'font-size': '26px',
-        'color': '#000'
-    };
-    test('wait for success', async () => {
-        el = await $('sel');
-        el._attempts = 2;
-        let counter = 0;
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            if (el._attempts > 0) {
-                counter++;
-                if (counter === Object.keys(mockStyle).length) {
-                    counter = 0;
-                    el._attempts--;
-                }
-                return { value: 'Wrong Value' };
-            }
-            return { value: mockStyle[property] };
-        });
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveStyle.call({}, el, mockStyle, { ignoreCase: true, beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveStyle',
-            expectedValue: mockStyle,
-            options: { ignoreCase: true, beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveStyle',
-            expectedValue: mockStyle,
-            options: { ignoreCase: true, beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        el.getCSSProperty = vi.fn().mockImplementation(() => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            throw new Error('some error');
-        });
-        await expect(() => toHaveStyle.call({}, el, mockStyle, { ignoreCase: true }))
-            .rejects.toThrow('some error');
-    });
-    test('success on the first attempt', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            return { value: mockStyle[property] };
-        });
-        const result = await toHaveStyle.call({}, el, mockStyle, { ignoreCase: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - failure', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        el.getCSSProperty = vi.fn().mockImplementation(() => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            return { value: 'Wrong Value' };
-        });
-        const result = await toHaveStyle.call({}, el, mockStyle, { wait: 0 });
-        expect(result.pass).toBe(false);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - success', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            return { value: mockStyle[property] };
-        });
-        const result = await toHaveStyle.call({}, el, mockStyle, { wait: 0 });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('not - failure', async () => {
-        const el = await $('sel');
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            return { value: mockStyle[property] };
-        });
-        const result = await toHaveStyle.call({ isNot: true }, el, mockStyle, { wait: 0 });
-        const received = getReceived(result.message());
-        expect(received).not.toContain('not');
-        expect(result.pass).toBe(true);
-    });
-    test('should return false if styles dont match', async () => {
-        const el = await $('sel');
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            return { value: mockStyle[property] };
-        });
-        const wrongStyle = {
-            'font-family': 'Incorrect Font',
-            'font-size': '100px',
-            'color': '#fff'
-        };
-        const result = await toHaveStyle.bind({ isNot: true })(el, wrongStyle, { wait: 1 });
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if styles match', async () => {
-        const el = await $('sel');
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            return { value: mockStyle[property] };
-        });
-        const result = await toHaveStyle.bind({ isNot: true })(el, mockStyle, { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('message shows correctly', async () => {
-        const el = await $('sel');
-        el.getCSSProperty = vi.fn().mockImplementation(() => {
-            return { value: 'Wrong Value' };
-        });
-        const result = await toHaveStyle.call({}, el, 'WebdriverIO');
-        expect(getExpectMessage(result.message())).toContain('to have style');
-    });
-    test('success if style matches with ignoreCase', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        const actualStyle = {
-            'font-family': 'Faktum',
-            'font-size': '26px',
-            'color': '#fff'
-        };
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            return { value: actualStyle[property] };
-        });
-        const alteredCaseStyle = {
-            'font-family': 'FaKtum',
-            'font-size': '26px',
-            'color': '#FFF'
-        };
-        const result = await toHaveStyle.call({}, el, alteredCaseStyle, { ignoreCase: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if style matches with trim', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        let counter = 0;
-        const actualStyle = {
-            'font-family': '   Faktum   ',
-            'font-size': '   26px   ',
-            'color': '    #fff     '
-        };
-        el.getCSSProperty = vi.fn().mockImplementation((property) => {
-            counter++;
-            if (counter === Object.keys(mockStyle).length) {
-                counter = 0;
-                el._attempts++;
-            }
-            return { value: actualStyle[property] };
-        });
-        const alteredSpaceStyle = {
-            'font-family': 'Faktum',
-            'font-size': '26px',
-            'color': '#fff'
-        };
-        const result = await toHaveStyle.call({}, el, alteredSpaceStyle, { trim: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-});

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

@@ -1,333 +0,0 @@
-import { $, $$ } from '@wdio/globals';
-import { beforeEach, describe, expect, test, vi } from 'vitest';
-import { getExpectMessage, getReceived, getExpected } from '../../__fixtures__/utils.js';
-import { toHaveText } from '../../../src/matchers/element/toHaveText.js';
-vi.mock('@wdio/globals');
-describe('toHaveText', () => {
-    describe('when receiving an element array', () => {
-        let els;
-        beforeEach(async () => {
-            els = await $$('parent');
-            const el1 = await $('sel');
-            el1._text = function () {
-                return 'WebdriverIO';
-            };
-            const el2 = await $('dev');
-            el2._text = function () {
-                return 'Get Started';
-            };
-            els[0] = el1;
-            els[1] = el2;
-        });
-        test('should return true if the received element array matches the expected text array', async () => {
-            const result = await toHaveText.bind({})(els, ['WebdriverIO', 'Get Started']);
-            expect(result.pass).toBe(true);
-        });
-        test('should return true if the received element array matches the expected text array & ignoreCase', async () => {
-            const result = await toHaveText.bind({})(els, ['webdriverio', 'get started'], { ignoreCase: true });
-            expect(result.pass).toBe(true);
-        });
-        test('should return false if the received element array does not match the expected text array', async () => {
-            const result = await toHaveText.bind({})(els, ['webdriverio', 'get started']);
-            expect(result.pass).toBe(false);
-        });
-        test('should return true if the expected message shows correctly', async () => {
-            const result = await toHaveText.bind({})(els, ['webdriverio', 'get started'], { message: 'Test' });
-            expect(getExpectMessage(result.message())).toContain('Test');
-        });
-    });
-    test('wait for success', async () => {
-        const el = await $('sel');
-        el._attempts = 2;
-        el._text = function () {
-            if (this._attempts > 0) {
-                this._attempts--;
-                return '';
-            }
-            return 'webdriverio';
-        };
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveText.call({}, el, 'WebdriverIO', { ignoreCase: true, beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveText',
-            expectedValue: 'WebdriverIO',
-            options: { ignoreCase: true, beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveText',
-            expectedValue: 'WebdriverIO',
-            options: { ignoreCase: true, beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            throw new Error('some error');
-        };
-        await expect(() => toHaveText.call({}, el, 'WebdriverIO', { ignoreCase: true }))
-            .rejects.toThrow('some error');
-    });
-    test('success on the first attempt', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, 'WebdriverIO', { ignoreCase: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - failure', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'webdriverio';
-        };
-        const result = await toHaveText.call({}, el, 'WebdriverIO', { wait: 0 });
-        expect(result.pass).toBe(false);
-        expect(el._attempts).toBe(1);
-    });
-    test('no wait - success', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, 'WebdriverIO', { wait: 0 });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('not - failure', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({ isNot: true }, el, 'WebdriverIO', { wait: 0 });
-        const received = getReceived(result.message());
-        expect(received).not.toContain('not');
-        expect(result.pass).toBe(true);
-    });
-    test('should return false if texts don\'t match', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({ isNot: true })(el, 'foobar', { wait: 1 });
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if texts match', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({ isNot: true })(el, 'WebdriverIO', { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text + single replacer matches the expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'BrowserdriverIO', { replace: ['Web', 'Browser'] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text + replace (string) matches the expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'BrowserdriverIO', { replace: [['Web', 'Browser']] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text + replace (regex) matches the expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'BrowserdriverIO', { replace: [[/Web/, 'Browser']] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text starts with expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'Web', { atStart: true });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text ends with expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'IO', { atEnd: true });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual text contains the expected text at the given index', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, 'iverIO', { atIndex: 5 });
-        expect(result.pass).toBe(true);
-    });
-    test('message', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return '';
-        };
-        const result = await toHaveText.call({}, el, 'WebdriverIO');
-        expect(getExpectMessage(result.message())).toContain('to have text');
-    });
-    test('success if array matches with text and ignoreCase', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'Webdriverio'], { ignoreCase: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with text and trim', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return '   WebdriverIO   ';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'WebdriverIO', 'toto'], { trim: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with text and replace (string)', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'BrowserdriverIO', 'toto'], { replace: [['Web', 'Browser']] });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with text and replace (regex)', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'BrowserdriverIO', 'toto'], { replace: [[/Web/g, 'Browser']] });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with text and multiple replacers and one of the replacers is a function', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'browserdriverio', 'toto'], {
-            replace: [
-                [/Web/g, 'Browser'],
-                [/[A-Z]/g, (match) => match.toLowerCase()],
-            ],
-        });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('failure if array does not match with text', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._text = function () {
-            this._attempts++;
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.call({}, el, ['WDIO', 'Webdriverio'], { wait: 1 });
-        expect(result.pass).toBe(false);
-        expect(el._attempts).toBe(1);
-    });
-    test('should return true if actual text contains the expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, expect.stringContaining('iverIO'), {});
-        expect(result.pass).toBe(true);
-    });
-    test('should return false if actual text does not contain the expected text', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, expect.stringContaining('WDIO'), {});
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if actual text contains one of the expected texts', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, [expect.stringContaining('iverIO'), expect.stringContaining('WDIO')], {});
-        expect(result.pass).toBe(true);
-    });
-    test('should return false if actual text does not contain the expected texts', async () => {
-        const el = await $('sel');
-        el._text = function () {
-            return 'WebdriverIO';
-        };
-        const result = await toHaveText.bind({})(el, [expect.stringContaining('EXAMPLE'), expect.stringContaining('WDIO')], {});
-        expect(result.pass).toBe(false);
-    });
-    describe('with RegExp', () => {
-        let el;
-        beforeEach(async () => {
-            el = await $('sel');
-            el._text = vi.fn().mockImplementation(() => {
-                return 'This is example text';
-            });
-        });
-        test('success if match', async () => {
-            const result = await toHaveText.call({}, el, /ExAmplE/i);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with RegExp', async () => {
-            const result = await toHaveText.call({}, el, ['WDIO', /ExAmPlE/i]);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with text', async () => {
-            const result = await toHaveText.call({}, el, ['This is example text', /Webdriver/i]);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with text and ignoreCase', async () => {
-            const result = await toHaveText.call({}, el, ['ThIs Is ExAmPlE tExT', /Webdriver/i], {
-                ignoreCase: true,
-            });
-            expect(result.pass).toBe(true);
-        });
-        test('failure if no match', async () => {
-            const result = await toHaveText.call({}, el, /Webdriver/i);
-            expect(result.pass).toBe(false);
-            expect(getExpectMessage(result.message())).toContain('to have text');
-            expect(getExpected(result.message())).toContain('/Webdriver/i');
-            expect(getReceived(result.message())).toContain('This is example text');
-        });
-        test('failure if array does not match with text', async () => {
-            const result = await toHaveText.call({}, el, ['WDIO', /Webdriver/i]);
-            expect(result.pass).toBe(false);
-            expect(getExpectMessage(result.message())).toContain('to have text');
-            expect(getExpected(result.message())).toContain('/Webdriver/i');
-            expect(getExpected(result.message())).toContain('WDIO');
-        });
-    });
-});

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

@@ -1,81 +0,0 @@
-import { vi, test, describe, expect, beforeEach } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived, getExpected } from '../../__fixtures__/utils.js';
-import { toHaveValue } from '../../../src/matchers/element/toHaveValue.js';
-vi.mock('@wdio/globals');
-describe('toHaveValue', () => {
-    let el;
-    beforeEach(async () => {
-        el = await $('sel');
-        el._value = vi.fn().mockImplementation(() => {
-            return 'This is an example value';
-        });
-    });
-    describe('success', () => {
-        test('exact passes', async () => {
-            const beforeAssertion = vi.fn();
-            const afterAssertion = vi.fn();
-            const result = await toHaveValue.call({}, el, 'This is an example value', { beforeAssertion, afterAssertion });
-            expect(result.pass).toBe(true);
-            expect(beforeAssertion).toBeCalledWith({
-                matcherName: 'toHaveElementProperty',
-                expectedValue: ['value', 'This is an example value'],
-                options: { beforeAssertion, afterAssertion }
-            });
-            expect(afterAssertion).toBeCalledWith({
-                matcherName: 'toHaveElementProperty',
-                expectedValue: ['value', 'This is an example value'],
-                options: { beforeAssertion, afterAssertion },
-                result
-            });
-        });
-        test('assymetric passes', async () => {
-            const result = await toHaveValue.call({}, el, expect.stringContaining('example value'));
-            expect(result.pass).toBe(true);
-        });
-        test('RegExp passes', async () => {
-            const result = await toHaveValue.call({}, el, /ExAmPlE/i);
-            expect(result.pass).toBe(true);
-        });
-    });
-    describe('failure', () => {
-        let result;
-        beforeEach(async () => {
-            result = await toHaveValue.call({}, el, 'webdriver');
-        });
-        test('does not pass', () => {
-            expect(result.pass).toBe(false);
-        });
-        describe('message shows correctly', () => {
-            test('expect message', () => {
-                expect(getExpectMessage(result.message())).toContain('to have property value');
-            });
-            test('expected message', () => {
-                expect(getExpected(result.message())).toContain('webdriver');
-            });
-            test('received message', () => {
-                expect(getReceived(result.message())).toContain('This is an example value');
-            });
-        });
-    });
-    describe('failure with RegExp', () => {
-        let result;
-        beforeEach(async () => {
-            result = await toHaveValue.call({}, el, /WDIO/);
-        });
-        test('does not pass', () => {
-            expect(result.pass).toBe(false);
-        });
-        describe('message shows correctly', () => {
-            test('expect message', () => {
-                expect(getExpectMessage(result.message())).toContain('to have property value');
-            });
-            test('expected message', () => {
-                expect(getExpected(result.message())).toContain('/WDIO/');
-            });
-            test('received message', () => {
-                expect(getReceived(result.message())).toContain('This is an example value');
-            });
-        });
-    });
-});