expect-webdriverio 5.3.3 → 5.3.4

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

@@ -1,291 +0,0 @@
-import { vi, test, describe, expect, beforeEach } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived, getExpected } from '../../__fixtures__/utils.js';
-import { toHaveHTML } from '../../../src/matchers/element/toHaveHTML.js';
-vi.mock('@wdio/globals');
-describe('toHaveHTML', () => {
-    test('wait for success', async () => {
-        const el = await $('sel');
-        el._attempts = 2;
-        el._html = function () {
-            if (this._attempts > 0) {
-                this._attempts--;
-                return '';
-            }
-            return '<div>foo</div>';
-        };
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveHTML.call({}, el, '<div>foo</div>', { ignoreCase: true, beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveHTML',
-            expectedValue: '<div>foo</div>',
-            options: { ignoreCase: true, beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveHTML',
-            expectedValue: '<div>foo</div>',
-            options: { ignoreCase: true, beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            throw new Error('some error');
-        };
-        await expect(() => toHaveHTML.call({}, el, '<div>foo</div>', { ignoreCase: true }))
-            .rejects.toThrow('some error');
-    });
-    test('success on the first attempt', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, '<div>foo</div>', { 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._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, 'foo', { 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._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, '<div>foo</div>', { wait: 0 });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('not - failure', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({ isNot: true }, el, '<div>foo</div>', { wait: 0 });
-        const received = getReceived(result.message());
-        expect(received).not.toContain('not');
-        expect(result.pass).toBe(true);
-    });
-    test("should return false if htmls don't match", async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({ isNot: true })(el, 'foobar', { wait: 1 });
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if htmls match', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({ isNot: true })(el, '<div>foo</div>', { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html + single replacer matches the expected html', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div>bar</div>', { replace: ['foo', 'bar'] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html + replace (string) matches the expected html', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div>bar</div>', { replace: [['foo', 'bar']] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html + replace (regex) matches the expected html', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div>bar</div>', { replace: [[/foo/, 'bar']] });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html starts with expected html', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div>', { atStart: true });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html ends with expected html', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '</div>', { atEnd: true });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html contains the expected html at the given index', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, 'iv>foo', { atIndex: 2 });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html equals the expected html with includeSelectorTag set to false', async () => {
-        const el = await $('sel');
-        el._html = function (includeSelectorTag) {
-            return includeSelectorTag ? '<div><div>foo</div></div>' : '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div>foo</div>', { includeSelectorTag: false });
-        expect(result.pass).toBe(true);
-    });
-    test('should return true if actual html equals the expected html with includeSelectorTag set to false', async () => {
-        const el = await $('sel');
-        el._html = function (includeSelectorTag) {
-            return includeSelectorTag ? '<div><div>foo</div></div>' : '<div>foo</div>';
-        };
-        const result = await toHaveHTML.bind({})(el, '<div><div>foo</div></div>', {
-            includeSelectorTag: true,
-        });
-        expect(result.pass).toBe(true);
-    });
-    test('message', async () => {
-        const el = await $('sel');
-        el._html = function () {
-            return '';
-        };
-        const result = await toHaveHTML.call({}, el, '<div>foo</div>');
-        expect(getExpectMessage(result.message())).toContain('to have HTML');
-    });
-    test('success if array matches with html and ignoreCase', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', '<div>foo</div>'], { ignoreCase: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with html and trim', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '   <div>foo</div>   ';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', '<div>foo</div>', 'toto'], { trim: true });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with html and replace (string)', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', '<div>foo</div>', 'toto'], {
-            replace: [['Web', 'Browser']],
-        });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with html and replace (regex)', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', '<div>foo</div>', 'toto'], {
-            replace: [[/Web/g, 'Browser']],
-        });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('success if array matches with html and multiple replacers and one of the replacers is a function', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>FOO</div>';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', '<p>foo</p>', 'toto'], {
-            replace: [
-                [/div/g, 'p'],
-                [/[A-Z]/g, (match) => match.toLowerCase()],
-            ],
-        });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('failure if array does not match with html', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._html = function () {
-            this._attempts++;
-            return '<div>foo</div>';
-        };
-        const result = await toHaveHTML.call({}, el, ['div', 'foo'], { wait: 1 });
-        expect(result.pass).toBe(false);
-        expect(el._attempts).toBe(1);
-    });
-    describe('with RegExp', () => {
-        let el;
-        beforeEach(async () => {
-            el = await $('sel');
-            el._html = vi.fn().mockImplementation(() => {
-                return 'This is example HTML';
-            });
-        });
-        test('success if match', async () => {
-            const result = await toHaveHTML.call({}, el, /ExAmplE/i);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with RegExp', async () => {
-            const result = await toHaveHTML.call({}, el, ['div', /ExAmPlE/i]);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with html', async () => {
-            const result = await toHaveHTML.call({}, el, ['This is example HTML', /Webdriver/i]);
-            expect(result.pass).toBe(true);
-        });
-        test('success if array matches with html and ignoreCase', async () => {
-            const result = await toHaveHTML.call({}, el, ['ThIs Is ExAmPlE HTML', /Webdriver/i], {
-                ignoreCase: true,
-            });
-            expect(result.pass).toBe(true);
-        });
-        test('failure if no match', async () => {
-            const result = await toHaveHTML.call({}, el, /Webdriver/i);
-            expect(result.pass).toBe(false);
-            expect(getExpectMessage(result.message())).toContain('to have HTML');
-            expect(getExpected(result.message())).toContain('/Webdriver/i');
-            expect(getReceived(result.message())).toContain('This is example HTML');
-        });
-        test('failure if array does not match with html', async () => {
-            const result = await toHaveHTML.call({}, el, ['div', /Webdriver/i]);
-            expect(result.pass).toBe(false);
-            expect(getExpectMessage(result.message())).toContain('to have HTML');
-            expect(getExpected(result.message())).toContain('/Webdriver/i');
-            expect(getExpected(result.message())).toContain('div');
-        });
-    });
-});

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

@@ -1,171 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveHeight } from '../../../src/matchers/element/toHaveHeight.js';
-vi.mock('@wdio/globals');
-describe('toHaveHeight', () => {
-    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 toHaveHeight.call({}, el, 32, { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveHeight',
-            expectedValue: 32,
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveHeight',
-            expectedValue: 32,
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            throw new Error('some error');
-        };
-        await expect(() => toHaveHeight.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 toHaveHeight.call({}, el, 32, {});
-        expect(result.message()).toEqual('Expect $(`sel`) to have height\n\nExpected: 32\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 toHaveHeight.call({}, el, 10, { wait: 0 });
-        expect(result.message()).toEqual('Expect $(`sel`) to have height\n\nExpected: 10\nReceived: 32');
-        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 toHaveHeight.call({}, el, 32, { 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 toHaveHeight.call({}, el, { gte: 31, lte: 33 }, { wait: 0 });
-        expect(result.message()).toEqual('Expect $(`sel`) to have height\n\nExpected: ">= 31 && <= 33"\nReceived: 32');
-        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 toHaveHeight.call({}, el, 32, { 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 toHaveHeight.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 toHaveHeight.bind({})(el, 32, { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('message', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            return null;
-        };
-        const result = await toHaveHeight.call({}, el, 50);
-        expect(getExpectMessage(result.message())).toContain('to have height');
-    });
-});

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

@@ -1,54 +0,0 @@
-import { vi, test, describe, expect, beforeEach } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getExpected, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveHref } from '../../../src/matchers/element/toHaveHref.js';
-vi.mock('@wdio/globals');
-describe('toHaveHref', () => {
-    let el;
-    beforeEach(async () => {
-        el = await $('sel');
-        el.getAttribute = vi.fn().mockImplementation((attribute) => {
-            if (attribute === 'href') {
-                return 'https://www.example.com';
-            }
-            return null;
-        });
-    });
-    test('success when contains', async () => {
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveHref.call({}, el, 'https://www.example.com', { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveHref',
-            expectedValue: 'https://www.example.com',
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveHref',
-            expectedValue: 'https://www.example.com',
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    describe('failure when doesnt contain', () => {
-        let result;
-        beforeEach(async () => {
-            result = await toHaveHref.call({}, el, 'an href');
-        });
-        test('failure', () => {
-            expect(result.pass).toBe(false);
-        });
-        describe('message shows correctly', () => {
-            test('expect message', () => {
-                expect(getExpectMessage(result.message())).toContain('to have attribute href');
-            });
-            test('expected message', () => {
-                expect(getExpected(result.message())).toContain('an href');
-            });
-            test('received message', () => {
-                expect(getReceived(result.message())).toContain('https://www.example.com');
-            });
-        });
-    });
-});

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

@@ -1,54 +0,0 @@
-import { vi, test, describe, expect, beforeEach } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getExpected, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveId } from '../../../src/matchers/element/toHaveId.js';
-vi.mock('@wdio/globals');
-describe('toHaveId', () => {
-    let el;
-    beforeEach(async () => {
-        el = await $('sel');
-        el.getAttribute = vi.fn().mockImplementation((attribute) => {
-            if (attribute === 'id') {
-                return 'test id';
-            }
-            return null;
-        });
-    });
-    test('success', async () => {
-        const result = await toHaveId.call({}, el, 'test id');
-        expect(result.pass).toBe(true);
-    });
-    describe('failure', () => {
-        let result;
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        beforeEach(async () => {
-            result = await toHaveId.call({}, el, 'an attribute', { beforeAssertion, afterAssertion });
-        });
-        test('failure', () => {
-            expect(beforeAssertion).toBeCalledWith({
-                matcherName: 'toHaveId',
-                expectedValue: 'an attribute',
-                options: { beforeAssertion, afterAssertion }
-            });
-            expect(result.pass).toBe(false);
-            expect(afterAssertion).toBeCalledWith({
-                matcherName: 'toHaveId',
-                expectedValue: 'an attribute',
-                options: { beforeAssertion, afterAssertion },
-                result
-            });
-        });
-        describe('message shows correctly', () => {
-            test('expect message', () => {
-                expect(getExpectMessage(result.message())).toContain('to have attribute id');
-            });
-            test('expected message', () => {
-                expect(getExpected(result.message())).toContain('an attribute');
-            });
-            test('received message', () => {
-                expect(getReceived(result.message())).toContain('test id');
-            });
-        });
-    });
-});

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

@@ -1,109 +0,0 @@
-import { vi, test, describe, expect } from 'vitest';
-import { $ } from '@wdio/globals';
-import { getExpectMessage, getReceived } from '../../__fixtures__/utils.js';
-import { toHaveSize } from '../../../src/matchers/element/toHaveSize.js';
-vi.mock('@wdio/globals');
-describe('toHaveSize', () => {
-    test('wait for success', async () => {
-        const el = await $('sel');
-        el._attempts = 2;
-        el._size = function () {
-            if (this._attempts > 0) {
-                this._attempts--;
-                return null;
-            }
-            return { width: 32, height: 32 };
-        };
-        const beforeAssertion = vi.fn();
-        const afterAssertion = vi.fn();
-        const result = await toHaveSize.call({}, el, { width: 32, height: 32 }, { beforeAssertion, afterAssertion });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(0);
-        expect(beforeAssertion).toBeCalledWith({
-            matcherName: 'toHaveSize',
-            expectedValue: { width: 32, height: 32 },
-            options: { beforeAssertion, afterAssertion }
-        });
-        expect(afterAssertion).toBeCalledWith({
-            matcherName: 'toHaveSize',
-            expectedValue: { width: 32, height: 32 },
-            options: { beforeAssertion, afterAssertion },
-            result
-        });
-    });
-    test('wait but failure', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            throw new Error('some error');
-        };
-        await expect(() => toHaveSize.call({}, el, { width: 32, height: 32 }, {}))
-            .rejects.toThrow('some error');
-    });
-    test('success on the first attempt', async () => {
-        const el = await $('sel');
-        el._attempts = 0;
-        el._size = function () {
-            this._attempts++;
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.call({}, el, { width: 32, height: 32 }, {});
-        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 () {
-            this._attempts++;
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.call({}, el, { width: 15, height: 32 }, { 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._size = function () {
-            this._attempts++;
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.call({}, el, { width: 32, height: 32 }, { wait: 0 });
-        expect(result.pass).toBe(true);
-        expect(el._attempts).toBe(1);
-    });
-    test('not - failure', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.call({}, el, { width: 32, height: 32 }, { 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 () {
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.bind({})(el, { width: 15, height: 32 }, { wait: 1 });
-        expect(result.pass).toBe(false);
-    });
-    test('should return true if sizes match', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            return { width: 32, height: 32 };
-        };
-        const result = await toHaveSize.bind({})(el, { width: 32, height: 32 }, { wait: 1 });
-        expect(result.pass).toBe(true);
-    });
-    test('message', async () => {
-        const el = await $('sel');
-        el._size = function () {
-            return null;
-        };
-        const result = await toHaveSize.call({}, el, { width: 32, height: 32 });
-        expect(getExpectMessage(result.message())).toContain('to have size');
-    });
-});