expect-webdriverio 5.3.1 → 5.3.3

package/lib/{matchers → src/matchers}/snapshot.js

@@ -76,7 +76,7 @@ export function toMatchInlineSnapshot(received, inlineSnapshot, message) {
         }
         const trace = error.stack?.split('\n').filter((line) => (line.includes('__INLINE_SNAPSHOT__') ||
             !(line.includes('__EXTERNAL_MATCHER_TRAP__') ||
-                line.includes(`expect-webdriverio${path.sep}lib${path.sep}matchers${path.sep}snapshot.js:`)))) || [];
+                line.includes(`expect-webdriverio${path.sep}lib${path.sep}matchers${path.sep}snapshot.js:`)))).filter((line) => (!line.includes('node_modules/jasmine-core/'))) || [];
         if (process.env.WDIO_INTERNAL_TEST) {
             trace.splice(2, 1);
         }

package/lib/test/__fixtures__/utils.js

@@ -0,0 +1,19 @@
+export function matcherNameToString(matcherName) {
+    return matcherName.replace(/([A-Z])/g, ' $1').toLowerCase();
+}
+export function getExpectMessage(msg) {
+    return msg.split('\n')[0];
+}
+export function getExpected(msg) {
+    return getReceivedOrExpected(msg, 'Expected');
+}
+export function getReceived(msg) {
+    return getReceivedOrExpected(msg, 'Received');
+}
+function getReceivedOrExpected(msg, type) {
+    return msg.split('\n').find((line, idx) => idx > 1 && line.startsWith(type));
+}
+export function removeColors(msg) {
+    const s = msg.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    return s;
+}

package/lib/test/index.test.js

@@ -0,0 +1,8 @@
+import { test, expect } from 'vitest';
+import { setOptions, expect as expectExport, matchers, utils } from '../src/index.js';
+test('index', () => {
+    expect(setOptions.name).toBe('setDefaultOptions');
+    expect(expectExport).toBeDefined();
+    expect(utils.compareText).toBeDefined();
+    expect(matchers.size).toEqual(41);
+});

package/lib/test/matchers/beMatchers.test.js

@@ -0,0 +1,109 @@
+import { vi, test, describe, expect } from 'vitest';
+import { $ } from '@wdio/globals';
+import { getExpectMessage, getReceived, matcherNameToString } from '../__fixtures__/utils.js';
+import * as Matchers from '../../src/matchers.js';
+vi.mock('@wdio/globals');
+const ignoredMatchers = ['toBeElementsArrayOfSize', 'toBeDisabled', 'toBeRequested', 'toBeRequestedTimes', 'toBeRequestedWithResponse', 'toBeRequestedWith'];
+const beMatchers = [
+    ...Object.keys(Matchers).filter(name => name.startsWith('toBe') && !ignoredMatchers.includes(name)),
+    'toExist'
+];
+describe('be* matchers', () => {
+    beMatchers.forEach((name) => {
+        const fn = Matchers[name];
+        describe(name, () => {
+            test('wait for success', async () => {
+                const el = await $('sel');
+                el._attempts = 2;
+                el._value = function () {
+                    if (this._attempts > 0) {
+                        this._attempts--;
+                        return false;
+                    }
+                    return true;
+                };
+                const result = await fn.call({}, el);
+                expect(result.pass).toBe(true);
+                expect(el._attempts).toBe(0);
+            });
+            test('wait but failure', async () => {
+                const el = await $('sel');
+                el._value = function () {
+                    throw new Error('some error');
+                };
+                await expect(() => fn.call({}, el, 10, {}))
+                    .rejects.toThrow('some error');
+            });
+            test('success on the first attempt', async () => {
+                const el = await $('sel');
+                el._attempts = 0;
+                el._value = function () {
+                    this._attempts++;
+                    return true;
+                };
+                const result = await fn.call({}, el);
+                expect(result.pass).toBe(true);
+                expect(el._attempts).toBe(1);
+            });
+            test('no wait - failure', async () => {
+                const el = await $('sel');
+                el._attempts = 0;
+                el._value = function () {
+                    this._attempts++;
+                    return false;
+                };
+                const result = await fn.call({}, el, { 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._value = function () {
+                    this._attempts++;
+                    return true;
+                };
+                const result = await fn.call({}, el, { wait: 0 });
+                expect(result.pass).toBe(true);
+                expect(el._attempts).toBe(1);
+            });
+            test('not - failure', async () => {
+                const result = await fn.call({ isNot: true }, $('sel'), { wait: 0 });
+                const received = getReceived(result.message());
+                expect(received).not.toContain('not');
+                expect(result.pass).toBe(true);
+            });
+            test('not - success', async () => {
+                const el = await $('sel');
+                el._value = function () {
+                    return false;
+                };
+                const result = await fn.call({ isNot: true }, el, { wait: 0 });
+                const received = getReceived(result.message());
+                expect(received).toContain('not');
+                expect(result.pass).toBe(false);
+            });
+            test('not - failure (with wait)', async () => {
+                const result = await fn.call({ isNot: true }, $('sel'), { wait: 1 });
+                const received = getReceived(result.message());
+                expect(received).not.toContain('not');
+                expect(result.pass).toBe(true);
+            });
+            test('not - success (with wait)', async () => {
+                const el = await $('sel');
+                el._value = function () {
+                    return false;
+                };
+                const result = await fn.call({ isNot: true }, el, { wait: 1 });
+                const received = getReceived(result.message());
+                expect(received).toContain('not');
+                expect(result.pass).toBe(false);
+            });
+            test('message', async () => {
+                const result = await fn.call({}, $('sel'));
+                expect(getExpectMessage(result.message()))
+                    .toContain(matcherNameToString(name));
+            });
+        });
+    });
+});

package/lib/test/matchers/browser/toHaveClipboardText.test.js

@@ -0,0 +1,21 @@
+import { vi, test, expect } from 'vitest';
+import { browser } from '@wdio/globals';
+import { toHaveClipboardText } from '../../../src/matchers/browser/toHaveClipboardText.js';
+vi.mock('@wdio/globals');
+const beforeAssertion = vi.fn();
+const afterAssertion = vi.fn();
+test('toHaveClipboardText', async () => {
+    const result = await toHaveClipboardText.call({}, browser, 'some ClipBoard text', { ignoreCase: true, beforeAssertion, afterAssertion });
+    expect(result.pass).toBe(true);
+    expect(beforeAssertion).toBeCalledWith({
+        matcherName: 'toHaveClipboardText',
+        expectedValue: 'some ClipBoard text',
+        options: { ignoreCase: true, beforeAssertion, afterAssertion }
+    });
+    expect(afterAssertion).toBeCalledWith({
+        matcherName: 'toHaveClipboardText',
+        expectedValue: 'some ClipBoard text',
+        options: { ignoreCase: true, beforeAssertion, afterAssertion },
+        result
+    });
+});

package/lib/test/matchers/browserMatchers.test.js

@@ -0,0 +1,102 @@
+import { vi, test, describe, expect } from 'vitest';
+import { browser } from '@wdio/globals';
+import { getExpectMessage, getReceived, matcherNameToString, getExpected } from '../__fixtures__/utils.js';
+import * as Matchers from '../../src/matchers.js';
+vi.mock('@wdio/globals');
+const browserMatchers = ['toHaveUrl', 'toHaveTitle'];
+const validText = ' Valid Text ';
+const wrongText = ' Wrong Text ';
+describe('browser matchers', () => {
+    browserMatchers.forEach((name) => {
+        const fn = Matchers[name];
+        describe(name, () => {
+            test('wait for success', async () => {
+                browser._attempts = 2;
+                browser._value = function () {
+                    if (this._attempts > 0) {
+                        this._attempts--;
+                        return wrongText;
+                    }
+                    return validText;
+                };
+                const result = await fn.call({}, browser, validText, { trim: false });
+                expect(result.pass).toBe(true);
+                expect(browser._attempts).toBe(0);
+            });
+            test('wait but failure', async () => {
+                browser._value = function () {
+                    throw new Error('some error');
+                };
+                await expect(() => fn.call({}, browser, validText, { trim: false }))
+                    .rejects.toThrow('some error');
+            });
+            test('success on the first attempt', async () => {
+                browser._attempts = 0;
+                browser._value = function () {
+                    this._attempts++;
+                    return validText;
+                };
+                const result = await fn.call({}, browser, validText, { trim: false });
+                expect(result.pass).toBe(true);
+                expect(browser._attempts).toBe(1);
+            });
+            test('no wait - failure', async () => {
+                browser._attempts = 0;
+                browser._value = function () {
+                    this._attempts++;
+                    return wrongText;
+                };
+                const result = await fn.call({}, browser, validText, { wait: 0, trim: false });
+                expect(result.pass).toBe(false);
+                expect(browser._attempts).toBe(1);
+            });
+            test('no wait - success', async () => {
+                browser._attempts = 0;
+                browser._value = function () {
+                    this._attempts++;
+                    return validText;
+                };
+                const result = await fn.call({}, browser, validText, { wait: 0, trim: false });
+                expect(result.pass).toBe(true);
+                expect(browser._attempts).toBe(1);
+            });
+            test('not - failure', async () => {
+                const result = await fn.call({ isNot: true }, browser, validText, { wait: 0, trim: false });
+                expect(getExpectMessage(result.message())).toContain('not');
+                expect(getExpected(result.message())).toContain('not');
+                expect(result.pass).toBe(true);
+            });
+            test('not - success', async () => {
+                browser._value = function () {
+                    return wrongText;
+                };
+                const result = await fn.call({ isNot: true }, browser, validText, { wait: 0 });
+                expect(getExpectMessage(result.message())).toContain('not');
+                expect(getExpected(result.message())).toContain('Valid');
+                expect(getReceived(result.message())).toContain('Wrong');
+                expect(result.pass).toBe(false);
+            });
+            test('not - failure (with wait)', async () => {
+                delete browser._value;
+                const result = await fn.call({ isNot: true }, browser, validText, { wait: 1, trim: false });
+                expect(getExpectMessage(result.message())).toContain('not');
+                expect(getExpected(result.message())).toContain('not');
+                expect(result.pass).toBe(true);
+            });
+            test('not - success (with wait)', async () => {
+                browser._value = function () {
+                    return wrongText;
+                };
+                const result = await fn.call({ isNot: true }, browser, validText, { wait: 1 });
+                expect(getExpectMessage(result.message())).toContain('not');
+                expect(getExpected(result.message())).toContain('Valid');
+                expect(getReceived(result.message())).toContain('Wrong');
+                expect(result.pass).toBe(false);
+            });
+            test('message', async () => {
+                const result = await fn.call({}, browser);
+                expect(getExpectMessage(result.message())).toContain(matcherNameToString(name));
+            });
+        });
+    });
+});

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

@@ -0,0 +1,121 @@
+import { vi, test, describe, expect } from 'vitest';
+import { $ } from '@wdio/globals';
+import { getExpectMessage, getReceived } from '../../__fixtures__/utils.js';
+import { toBeDisabled } from '../../../src/matchers/element/toBeDisabled.js';
+vi.mock('@wdio/globals');
+describe('toBeDisabled', () => {
+    test('wait for success', async () => {
+        const el = await $('sel');
+        el._attempts = 2;
+        el._value = function () {
+            if (this._attempts > 0) {
+                this._attempts--;
+                return true;
+            }
+            return false;
+        };
+        const beforeAssertion = vi.fn();
+        const afterAssertion = vi.fn();
+        const result = await toBeDisabled.call({}, el, { beforeAssertion, afterAssertion });
+        expect(result.pass).toBe(true);
+        expect(el._attempts).toBe(0);
+        expect(beforeAssertion).toBeCalledWith({
+            matcherName: 'toBeDisabled',
+            options: { beforeAssertion, afterAssertion }
+        });
+        expect(afterAssertion).toBeCalledWith({
+            matcherName: 'toBeDisabled',
+            options: { beforeAssertion, afterAssertion },
+            result
+        });
+    });
+    test('wait but failure', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            throw new Error('some error');
+        };
+        await expect(() => toBeDisabled.call({}, el))
+            .rejects.toThrow('some error');
+    });
+    test('success on the first attempt', async () => {
+        const el = await $('sel');
+        el._attempts = 0;
+        el._value = function () {
+            this._attempts++;
+            return false;
+        };
+        const result = await toBeDisabled.call({}, el);
+        expect(result.pass).toBe(true);
+        expect(el._attempts).toBe(1);
+    });
+    test('no wait - failure', async () => {
+        const el = await $('sel');
+        el._attempts = 0;
+        el._value = function () {
+            this._attempts++;
+            return true;
+        };
+        const result = await toBeDisabled.call({}, el, { 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._value = function () {
+            this._attempts++;
+            return false;
+        };
+        const result = await toBeDisabled.call({}, el, { wait: 0 });
+        expect(result.pass).toBe(true);
+        expect(el._attempts).toBe(1);
+    });
+    test('not - failure', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            return false;
+        };
+        const result = await toBeDisabled.call({ isNot: true }, el, { wait: 0 });
+        const received = getReceived(result.message());
+        expect(received).not.toContain('not');
+        expect(result.pass).toBe(true);
+    });
+    test('not - success', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            return true;
+        };
+        const result = await toBeDisabled.call({ isNot: true }, el, { wait: 0 });
+        const received = getReceived(result.message());
+        expect(received).toContain('not');
+        expect(result.pass).toBe(false);
+    });
+    test('not - failure (with wait)', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            return false;
+        };
+        const result = await toBeDisabled.call({ isNot: true }, el, { wait: 1 });
+        const received = getReceived(result.message());
+        expect(received).not.toContain('not');
+        expect(result.pass).toBe(true);
+    });
+    test('not - success (with wait)', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            return true;
+        };
+        const result = await toBeDisabled.call({ isNot: true }, el, { wait: 1 });
+        const received = getReceived(result.message());
+        expect(received).toContain('not');
+        expect(result.pass).toBe(false);
+    });
+    test('message', async () => {
+        const el = await $('sel');
+        el._value = function () {
+            return false;
+        };
+        const result = await toBeDisabled.call({}, el);
+        expect(getExpectMessage(result.message())).toContain('to be disabled');
+    });
+});

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

@@ -0,0 +1,131 @@
+import { vi, test, describe, expect, beforeEach } from 'vitest';
+import { $ } from '@wdio/globals';
+import { getExpectMessage, getExpected, getReceived } from '../../__fixtures__/utils.js';
+import { toHaveAttribute } from '../../../src/matchers/element/toHaveAttribute.js';
+vi.mock('@wdio/globals');
+describe('toHaveAttribute', () => {
+    let el;
+    beforeEach(async () => {
+        el = await $('sel');
+    });
+    describe('attribute exists', () => {
+        test('success when present', async () => {
+            const beforeAssertion = vi.fn();
+            const afterAssertion = vi.fn();
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 'Correct Value';
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', undefined, { beforeAssertion, afterAssertion });
+            expect(result.pass).toBe(true);
+            expect(beforeAssertion).toBeCalledWith({
+                matcherName: 'toHaveAttribute',
+                expectedValue: ['attribute_name', undefined],
+                options: { beforeAssertion, afterAssertion }
+            });
+            expect(afterAssertion).toBeCalledWith({
+                matcherName: 'toHaveAttribute',
+                expectedValue: ['attribute_name', undefined],
+                options: { beforeAssertion, afterAssertion },
+                result
+            });
+        });
+        test('failure when not present', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return null;
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name');
+            expect(result.pass).toBe(false);
+        });
+        describe('message shows correctly', () => {
+            let result;
+            beforeEach(async () => {
+                el.getAttribute = vi.fn().mockImplementation(() => {
+                    return null;
+                });
+                result = await toHaveAttribute.call({}, el, 'attribute_name');
+            });
+            test('expect message', () => {
+                expect(getExpectMessage(result.message())).toContain('to have attribute');
+            });
+            test('expected message', () => {
+                expect(getExpected(result.message())).toContain('true');
+            });
+            test('received message', () => {
+                expect(getReceived(result.message())).toContain('false');
+            });
+        });
+    });
+    describe('attribute has value', () => {
+        test('success with correct value', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 'Correct Value';
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', 'Correct Value', { ignoreCase: true });
+            expect(result.pass).toBe(true);
+        });
+        test('success with RegExp and correct value', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 'Correct Value';
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', /cOrReCt VaLuE/i);
+            expect(result.pass).toBe(true);
+        });
+        test('failure with wrong value', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 'Wrong Value';
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', 'Correct Value', { ignoreCase: true });
+            expect(result.pass).toBe(false);
+        });
+        test('failure with non-string attribute value as actual', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 123;
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', 'Correct Value', { ignoreCase: true });
+            expect(result.pass).toBe(false);
+        });
+        test('failure with non-string attribute value as expected', async () => {
+            el.getAttribute = vi.fn().mockImplementation(() => {
+                return 'Correct Value';
+            });
+            const result = await toHaveAttribute.call({}, el, 'attribute_name', 123, { ignoreCase: true });
+            expect(result.pass).toBe(false);
+        });
+        describe('message shows correctly', () => {
+            let result;
+            beforeEach(async () => {
+                el.getAttribute = vi.fn().mockImplementation(() => {
+                    return 'Wrong';
+                });
+                result = await toHaveAttribute.call({}, el, 'attribute_name', 'Correct');
+            });
+            test('expect message', () => {
+                expect(getExpectMessage(result.message())).toContain('to have attribute');
+            });
+            test('expected message', () => {
+                expect(getExpected(result.message())).toContain('Correct');
+            });
+            test('received message', () => {
+                expect(getReceived(result.message())).toContain('Wrong');
+            });
+        });
+        describe('failure with RegExp, message shows correctly', () => {
+            let result;
+            beforeEach(async () => {
+                el.getAttribute = vi.fn().mockImplementation(() => {
+                    return 'Wrong';
+                });
+                result = await toHaveAttribute.call({}, el, 'attribute_name', /WDIO/);
+            });
+            test('expect message', () => {
+                expect(getExpectMessage(result.message())).toContain('to have attribute');
+            });
+            test('expected message', () => {
+                expect(getExpected(result.message())).toContain('/WDIO/');
+            });
+            test('received message', () => {
+                expect(getReceived(result.message())).toContain('Wrong');
+            });
+        });
+    });
+});

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

@@ -0,0 +1,62 @@
+import { vi, test, describe, expect } from 'vitest';
+import { $ } from '@wdio/globals';
+import { toHaveChildren } from '../../../src/matchers/element/toHaveChildren.js';
+vi.mock('@wdio/globals');
+describe('toHaveChildren', () => {
+    test('no value', async () => {
+        const beforeAssertion = vi.fn();
+        const afterAssertion = vi.fn();
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, undefined, { wait: 0, beforeAssertion, afterAssertion });
+        expect(result.pass).toBe(true);
+        expect(beforeAssertion).toBeCalledWith({
+            matcherName: 'toHaveChildren',
+            options: { wait: 0, beforeAssertion, afterAssertion }
+        });
+        expect(afterAssertion).toBeCalledWith({
+            matcherName: 'toHaveChildren',
+            options: { wait: 0, beforeAssertion, afterAssertion },
+            result
+        });
+    });
+    test('If no options passed in + children exists', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, {});
+        expect(result.pass).toBe(true);
+    });
+    test('exact number value', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, 2, { wait: 1 });
+        expect(result.pass).toBe(true);
+    });
+    test('exact value', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, { eq: 2, wait: 1 });
+        expect(result.pass).toBe(true);
+    });
+    test('gte value', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, { gte: 2, wait: 1 });
+        expect(result.pass).toBe(true);
+    });
+    test('exact value - failure', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, { eq: 3, wait: 1 });
+        expect(result.pass).toBe(false);
+    });
+    test('lte value - failure', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.call({}, el, { lte: 1, wait: 0 });
+        expect(result.pass).toBe(false);
+    });
+    test('.not exact value - failure', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.bind({ isNot: true })(el, { eq: 2, wait: 0 });
+        expect(result.pass).toBe(true);
+    });
+    test('.not exact value - success', async () => {
+        const el = await $('sel');
+        const result = await toHaveChildren.bind({ isNot: true })(el, { eq: 3, wait: 1 });
+        expect(result.pass).toBe(false);
+    });
+});