expect-webdriverio 5.3.2 → 5.3.3

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

@@ -0,0 +1,333 @@
+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

@@ -0,0 +1,81 @@
+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');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,171 @@
+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');
+    });
+});