expect-webdriverio 5.3.2 → 5.3.3

package/lib/test/matchers.test.js

@@ -0,0 +1,54 @@
+import { test, expect, vi } from 'vitest';
+import { matchers, expect as expectLib } from '../src/index.js';
+const ALL_MATCHERS = [
+    'toHaveClipboardText',
+    'toHaveTitle',
+    'toHaveUrl',
+    'toBeClickable',
+    'toBeDisabled',
+    'toBeDisplayed',
+    'toBeDisplayedInViewport',
+    'toBeEnabled',
+    'toExist',
+    'toBeExisting',
+    'toBePresent',
+    'toBeFocused',
+    'toBeSelected',
+    'toBeChecked',
+    'toHaveAttributeAndValue',
+    'toHaveAttribute',
+    'toHaveAttr',
+    'toHaveChildren',
+    'toHaveClass',
+    'toHaveElementClass',
+    'toHaveClassContaining',
+    'toHaveComputedLabel',
+    'toHaveComputedRole',
+    'toHaveElementProperty',
+    'toHaveHeight',
+    'toHaveHref',
+    'toHaveLink',
+    'toHaveHTML',
+    'toHaveId',
+    'toHaveSize',
+    'toHaveStyle',
+    'toHaveText',
+    'toHaveValue',
+    'toHaveWidth',
+    'toBeElementsArrayOfSize',
+    'toBeRequested',
+    'toBeRequestedTimes',
+    'toBeRequestedWith',
+    'toBeRequestedWithResponse',
+    'toMatchSnapshot',
+    'toMatchInlineSnapshot'
+];
+test('matchers', () => {
+    expect([...matchers.keys()]).toEqual(ALL_MATCHERS);
+});
+test('allows to add matcher', () => {
+    const matcher = vi.fn((actual, expected) => ({ pass: actual === expected }));
+    expectLib.extend({ toBeCustom: matcher });
+    expectLib('foo').toBeCustom('foo');
+    expect(matchers.keys()).toContain('toBeCustom');
+});

package/lib/test/snapshot.test.js

@@ -0,0 +1,53 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { test, expect } from 'vitest';
+import { expect as expectExport, SnapshotService } from '../src/index.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const __filename = path.basename(fileURLToPath(import.meta.url));
+const service = SnapshotService.initiate({
+    resolveSnapshotPath: (path, extension) => path + extension
+});
+test('supports snapshot testing', async () => {
+    await service.beforeTest({
+        title: 'test',
+        parent: 'parent',
+        file: path.join(__dirname, __filename),
+    });
+    process.env.WDIO_INTERNAL_TEST = 'true';
+    const exp = expectExport;
+    expect(exp).toBeDefined();
+    expect(exp({}).toMatchSnapshot).toBeDefined();
+    expect(exp({}).toMatchInlineSnapshot).toBeDefined();
+    await exp({ a: 'a' }).toMatchSnapshot();
+    await exp({ deep: { nested: { object: 'value' } } }).toMatchInlineSnapshot(`
+      {
+        "deep": {
+          "nested": {
+            "object": "value",
+          },
+        },
+      }
+    `);
+    await service.after();
+    const expectedSnapfileExist = await fs.access(path.resolve(__dirname, 'snapshot.test.ts.snap'))
+        .then(() => true, () => false);
+    expect(expectedSnapfileExist).toBe(true);
+});
+test('supports cucumber snapshot testing', async () => {
+    await service.beforeStep({
+        text: 'Fake step',
+    }, {
+        name: 'Fake scenario',
+        uri: `${__dirname}/file.feature`,
+    });
+    const exp = expectExport;
+    expect(exp).toBeDefined();
+    expect(exp({}).toMatchSnapshot).toBeDefined();
+    expect(exp({}).toMatchInlineSnapshot).toBeDefined();
+    await exp({ cucum: 'ber' }).toMatchSnapshot();
+    await service.after();
+    const expectedSnapfileExist = await fs.access(path.resolve(__dirname, 'file.feature.snap'))
+        .then(() => true, () => false);
+    expect(expectedSnapfileExist).toBe(true);
+});

package/lib/test/softAssertions.test.js

@@ -0,0 +1,332 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { $ } from '@wdio/globals';
+import { expect as expectWdio, SoftAssertionService, SoftAssertService } from '../src/index.js';
+vi.mock('@wdio/globals');
+describe('Soft Assertions', () => {
+    let el;
+    beforeEach(async () => {
+        el = $('sel');
+        el.getText = vi.fn().mockImplementation(() => 'Actual Text');
+        expectWdio.clearSoftFailures();
+    });
+    describe('expect.soft', () => {
+        it('should not throw immediately on failure', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-1', 'test name', 'test file');
+            await expectWdio.soft(el).toHaveText('Expected Text');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].matcherName).toBe('toHaveText');
+            expect(failures[0].error.message).toContain('text');
+        });
+        it('should support chained assertions with .not', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-2', 'test name', 'test file');
+            await expectWdio.soft(el).not.toHaveText('Actual Text');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].matcherName).toBe('not.toHaveText');
+        });
+        it('should support multiple soft failures in the same test', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-3', 'test name', 'test file');
+            await expectWdio.soft(el).toHaveText('First Expected');
+            await expectWdio.soft(el).toHaveText('Second Expected');
+            await expectWdio.soft(el).toHaveText('Third Expected');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(3);
+            expect(failures[0].matcherName).toBe('toHaveText');
+            expect(failures[1].matcherName).toBe('toHaveText');
+            expect(failures[2].matcherName).toBe('toHaveText');
+        });
+        it('should allow passing assertions', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-4', 'test name', 'test file');
+            await expectWdio.soft(el).toHaveText('Actual Text');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(0);
+        });
+        it('assertSoftFailures should throw if failures exist', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-5', 'test name', 'test file');
+            await expectWdio.soft(el).toHaveText('Expected Text');
+            await expect(() => expectWdio.assertSoftFailures()).toThrow(/1 soft assertion failure/);
+        });
+        it('clearSoftFailures should remove all failures', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-6', 'test name', 'test file');
+            await expectWdio.soft(el).toHaveText('First Expected');
+            await expectWdio.soft(el).toHaveText('Second Expected');
+            expect(expectWdio.getSoftFailures().length).toBe(2);
+            expectWdio.clearSoftFailures();
+            expect(expectWdio.getSoftFailures().length).toBe(0);
+        });
+    });
+    describe('SoftAssertService hooks', () => {
+        it('afterTest should throw if soft failures exist', () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('test-hooks-1', 'test hooks', 'test file');
+            const error = new Error('Test failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const testResult = { passed: true, error: 'undefined' };
+            const service = new SoftAssertionService();
+            service.afterTest({
+                file: 'test file', parent: '', title: 'test hooks',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(true);
+            expect(testResult.error).toBeDefined();
+        });
+    });
+    describe('Different Matcher Types', () => {
+        beforeEach(async () => {
+            el = $('sel');
+            el.getText = vi.fn().mockImplementation(() => 'Actual Text');
+            el.isDisplayed = vi.fn().mockImplementation(() => false);
+            el.getAttribute = vi.fn().mockImplementation(() => 'actual-class');
+            el.isClickable = vi.fn().mockImplementation(() => false);
+            expectWdio.clearSoftFailures();
+        });
+        it('should handle boolean matchers', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('boolean-test', 'boolean test', 'test file');
+            await expectWdio.soft(el).toBeDisplayed();
+            await expectWdio.soft(el).toBeClickable();
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(2);
+            expect(failures[0].matcherName).toBe('toBeDisplayed');
+            expect(failures[1].matcherName).toBe('toBeClickable');
+        });
+        it('should handle attribute matchers with multiple parameters', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('attribute-test', 'attribute test', 'test file');
+            await expectWdio.soft(el).toHaveAttribute('class', 'expected-class');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].matcherName).toBe('toHaveAttribute');
+        });
+        it('should handle matchers with options', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('options-test', 'options test', 'test file');
+            await expectWdio.soft(el).toHaveText('Expected', { ignoreCase: true, wait: 1000 });
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].matcherName).toBe('toHaveText');
+        });
+    });
+    describe('Test Isolation', () => {
+        it('should isolate failures between different test contexts', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('isolation-test-1', 'test 1', 'file1');
+            await expectWdio.soft(el).toHaveText('Expected Text 1');
+            expect(expectWdio.getSoftFailures().length).toBe(1);
+            softService.setCurrentTest('isolation-test-2', 'test 2', 'file2');
+            await expectWdio.soft(el).toHaveText('Expected Text 2');
+            expect(expectWdio.getSoftFailures('isolation-test-2').length).toBe(1);
+            expect(expectWdio.getSoftFailures('isolation-test-1').length).toBe(1);
+            expectWdio.clearSoftFailures('isolation-test-1');
+            expect(expectWdio.getSoftFailures('isolation-test-1').length).toBe(0);
+            expect(expectWdio.getSoftFailures('isolation-test-2').length).toBe(1);
+        });
+        it('should handle calls without test context gracefully', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.clearCurrentTest();
+            await expect(async () => {
+                await expectWdio.soft(el).toHaveText('Expected Text');
+            }).rejects.toThrow();
+        });
+        it('should handle rapid concurrent soft assertions', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('concurrent-test', 'concurrent', 'test file');
+            el.getText = vi.fn().mockImplementation(() => 'Actual Text');
+            el.isDisplayed = vi.fn().mockImplementation(() => false);
+            el.isClickable = vi.fn().mockImplementation(() => false);
+            const promises = [
+                expectWdio.soft(el).toHaveText('Expected 1'),
+                expectWdio.soft(el).toBeDisplayed(),
+                expectWdio.soft(el).toBeClickable()
+            ];
+            await Promise.all(promises);
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(3);
+            const matcherNames = failures.map(f => f.matcherName);
+            expect(matcherNames).toContain('toHaveText');
+            expect(matcherNames).toContain('toBeDisplayed');
+            expect(matcherNames).toContain('toBeClickable');
+        });
+    });
+    describe('Edge Cases & Error Handling', () => {
+        it('should handle matcher that throws non-standard errors', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('error-test', 'error test', 'test file');
+            const originalMethod = el.getText;
+            el.getText = vi.fn().mockImplementation(() => {
+                throw new TypeError('Weird browser error');
+            });
+            await expectWdio.soft(el).toHaveText('Expected Text');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].error).toBeInstanceOf(Error);
+            expect(failures[0].error.message).toContain('Weird browser error');
+            el.getText = originalMethod;
+        });
+        it('should handle very long error messages', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('long-error-test', 'long error', 'test file');
+            const veryLongText = 'A'.repeat(10000);
+            await expectWdio.soft(el).toHaveText(veryLongText);
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            expect(failures[0].error.message.length).toBeGreaterThan(0);
+        });
+        it('should handle null/undefined values gracefully', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('null-test', 'null test', 'test file');
+            await expectWdio.soft(el).toHaveText(null);
+            await expectWdio.soft(el).toHaveAttribute('class', undefined);
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(2);
+        });
+        it('should capture error location information', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('location-test', 'location test', 'test file');
+            await expectWdio.soft(el).toHaveText('Expected Text');
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBe(1);
+            if (failures[0].location) {
+                expect(failures[0].location).toBeTruthy();
+                expect(typeof failures[0].location).toBe('string');
+            }
+        });
+        it('should handle maximum failure limits', async () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('limit-test', 'limit test', 'test file');
+            const promises = [];
+            for (let i = 0; i < 150; i++) {
+                promises.push(expectWdio.soft(el).toHaveText(`Expected ${i}`));
+            }
+            await Promise.all(promises);
+            const failures = expectWdio.getSoftFailures();
+            expect(failures.length).toBeGreaterThan(0);
+            expect(failures.length).toBeLessThanOrEqual(150);
+        });
+    });
+    describe('SoftAssertionService Configuration', () => {
+        beforeEach(() => {
+            expectWdio.clearSoftFailures();
+        });
+        it('should auto-assert failures by default', () => {
+            const softService = SoftAssertService.getInstance();
+            const testId = 'test file::config default';
+            softService.setCurrentTest(testId, 'config default', 'test file');
+            const error = new Error('Test failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const service = new SoftAssertionService();
+            const testResult = { passed: true, error: undefined };
+            service.afterTest({
+                file: 'test file',
+                parent: '',
+                title: 'config default',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(false);
+            expect(testResult.error).toBeDefined();
+        });
+        it('should not auto-assert when autoAssertOnTestEnd is false', () => {
+            const softService = SoftAssertService.getInstance();
+            const testId = 'test file::config disabled';
+            softService.setCurrentTest(testId, 'config disabled', 'test file');
+            const error = new Error('Test failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const service = new SoftAssertionService({ autoAssertOnTestEnd: false });
+            const testResult = { passed: true, error: undefined };
+            service.afterTest({
+                file: 'test file',
+                parent: '',
+                title: 'config disabled',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(true);
+            expect(testResult.error).toBeUndefined();
+            const failures = expectWdio.getSoftFailures(testId);
+            expect(failures.length).toBe(1);
+        });
+        it('should still auto-assert with explicit autoAssertOnTestEnd: true', () => {
+            const softService = SoftAssertService.getInstance();
+            const testId = 'test file::config explicit';
+            softService.setCurrentTest(testId, 'config explicit', 'test file');
+            const error = new Error('Test failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const service = new SoftAssertionService({ autoAssertOnTestEnd: true });
+            const testResult = { passed: true, error: undefined };
+            service.afterTest({
+                file: 'test file',
+                parent: '',
+                title: 'config explicit',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(false);
+            expect(testResult.error).toBeDefined();
+        });
+        it('should skip auto-assert if test already has an error', () => {
+            const softService = SoftAssertService.getInstance();
+            softService.setCurrentTest('config-existing-error-test', 'config existing error', 'test file');
+            const error = new Error('Soft assertion failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const service = new SoftAssertionService();
+            const existingError = new Error('Pre-existing test error');
+            const testResult = { passed: false, error: existingError };
+            service.afterTest({
+                file: 'test file',
+                parent: '',
+                title: 'config existing error',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(false);
+            expect(testResult.error).toBe(existingError);
+            expect(testResult.error?.message).toBe('Pre-existing test error');
+        });
+        it('should accept undefined options and use defaults', () => {
+            const service = new SoftAssertionService(undefined);
+            expect(service).toBeDefined();
+            const softService = SoftAssertService.getInstance();
+            const testId = 'test file::config undefined';
+            softService.setCurrentTest(testId, 'config undefined', 'test file');
+            const error = new Error('Test failure');
+            softService.addFailure(error, 'toBeDisplayed');
+            const testResult = { passed: true, error: undefined };
+            service.afterTest({
+                file: 'test file',
+                parent: '',
+                title: 'config undefined',
+                fullName: '',
+                ctx: undefined,
+                type: '',
+                fullTitle: '',
+                pending: false
+            }, null, testResult);
+            expect(testResult.passed).toBe(false);
+            expect(testResult.error).toBeDefined();
+        });
+    });
+});

package/lib/test/util/elementsUtil.test.js

@@ -0,0 +1,18 @@
+import { vi, test, describe, expect } from 'vitest';
+import { $, $$ } from '@wdio/globals';
+import { wrapExpectedWithArray } from '../../src/util/elementsUtil.js';
+vi.mock('@wdio/globals');
+describe('elementsUtil', () => {
+    describe('wrapExpectedWithArray', () => {
+        test('is not array ', async () => {
+            const el = (await $('sel'));
+            const actual = wrapExpectedWithArray(el, 'Test Actual', 'Test Expected');
+            expect(actual).toEqual('Test Expected');
+        });
+        test('is array ', async () => {
+            const els = (await $$('sel'));
+            const actual = wrapExpectedWithArray(els, ['Test Actual', 'Test Actual'], 'Test Expected');
+            expect(actual).toEqual(['Test Expected']);
+        });
+    });
+});

package/lib/test/util/formatMessage.test.js

@@ -0,0 +1,96 @@
+import { test, describe, beforeEach, expect } from 'vitest';
+import { printDiffOrStringify, printExpected, printReceived } from 'jest-matcher-utils';
+import { enhanceError, numberError } from '../../src/util/formatMessage.js';
+describe('formatMessage', () => {
+    describe('enhanceError', () => {
+        describe('default', () => {
+            let actual;
+            beforeEach(() => {
+                actual = enhanceError('Test Subject', 'Test Expected', 'Test Actual', { isNot: false }, 'Test Verb', 'Test Expectation', '', { message: '', containing: false });
+            });
+            test('starting message', () => {
+                expect(actual).toMatch('Expect Test Subject to Test Verb Test Expectation');
+            });
+            test('diff string', () => {
+                const diffString = printDiffOrStringify('Test Expected', 'Test Actual', 'Expected', 'Received', true);
+                expect(actual).toMatch(diffString);
+            });
+        });
+        describe('isNot', () => {
+            let actual;
+            describe('different', () => {
+                beforeEach(() => {
+                    actual = enhanceError('Test Subject', 'Test Expected', 'Test Actual', { isNot: true }, 'Test Verb', 'Test Expectation', '', { message: '', containing: false });
+                });
+                test('starting message', () => {
+                    expect(actual).toMatch('Expect Test Subject not to Test Verb Test Expectation');
+                });
+                test('diff string', () => {
+                    const diffString = printDiffOrStringify('Test Expected', 'Test Actual', 'Expected [not]', 'Received      ', true);
+                    expect(actual).toMatch(diffString);
+                });
+            });
+            describe('same', () => {
+                beforeEach(() => {
+                    actual = enhanceError('Test Subject', 'Test Same', 'Test Same', { isNot: true }, 'Test Verb', 'Test Expectation', '', { message: '', containing: false });
+                });
+                test('starting message', () => {
+                    expect(actual).toMatch('Expect Test Subject not to Test Verb Test Expectation');
+                });
+                test('diff string', () => {
+                    const diffString = `Expected [not]: ${printExpected('Test Same')}\n` +
+                        `Received      : ${printReceived('Test Same')}`;
+                    expect(actual).toMatch(diffString);
+                });
+            });
+        });
+        describe('containing', () => {
+            let actual;
+            beforeEach(() => {
+                actual = enhanceError('Test Subject', 'Test Expected', 'Test Actual', { isNot: false }, 'Test Verb', 'Test Expectation', '', { message: '', containing: true });
+            });
+            test('starting message', () => {
+                expect(actual).toMatch('Expect Test Subject to Test Verb Test Expectation containing');
+            });
+            test('diff string', () => {
+                const diffString = printDiffOrStringify('Test Expected', 'Test Actual', 'Expected', 'Received', true);
+                expect(actual).toMatch(diffString);
+            });
+        });
+        describe('message', () => {
+            let actual;
+            beforeEach(() => {
+                actual = enhanceError('Test Subject', 'Test Expected', 'Test Actual', { isNot: false }, 'Test Verb', 'Test Expectation', '', { message: 'Test Message', containing: false });
+            });
+            test('starting message', () => {
+                expect(actual).toMatch('Test Message\nExpect Test Subject to Test Verb Test Expectation');
+            });
+            test('diff string', () => {
+                const diffString = printDiffOrStringify('Test Expected', 'Test Actual', 'Expected', 'Received', true);
+                expect(actual).toMatch(diffString);
+            });
+        });
+        describe('arg2', () => {
+            let actual;
+            beforeEach(() => {
+                actual = enhanceError('Test Subject', 'Test Expected', 'Test Actual', { isNot: false }, 'Test Verb', 'Test Expectation', 'Test Arg2', { message: 'Test Message', containing: false });
+            });
+            test('starting message', () => {
+                expect(actual).toMatch('Expect Test Subject to Test Verb Test Expectation Test Arg2');
+            });
+            test('diff string', () => {
+                const diffString = printDiffOrStringify('Test Expected', 'Test Actual', 'Expected', 'Received', true);
+                expect(actual).toMatch(diffString);
+            });
+        });
+    });
+    describe('numberError', () => {
+        test('should return correct message', () => {
+            expect(numberError()).toBe('no params');
+            expect(numberError({ eq: 0 })).toBe(0);
+            expect(numberError({ gte: 1 })).toBe('>= 1');
+            expect(numberError({ lte: 1 })).toBe(' <= 1');
+            expect(numberError({ gte: 2, lte: 1 })).toBe('>= 2 && <= 1');
+        });
+    });
+});

package/lib/test/util/refetchElements.test.js

@@ -0,0 +1,19 @@
+import { vi, test, describe, beforeEach, expect } from 'vitest';
+import { $$ } from '@wdio/globals';
+import { refetchElements } from '../../src/util/refetchElements.js';
+vi.mock('@wdio/globals');
+describe('refetchElements', () => {
+    let els;
+    beforeEach(async () => {
+        els = (await $$('parent'));
+        els.parent._length = 5;
+    });
+    test('default', async () => {
+        const actual = await refetchElements(els, 5, true);
+        expect(actual.length).toBe(5);
+    });
+    test('wait is 0', async () => {
+        const actual = await refetchElements(els, 0, true);
+        expect(actual).toEqual(els);
+    });
+});