expect-webdriverio 4.0.0

package/lib/matchers/element/toHaveAttribute.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveAttr = exports.toHaveAttribute = exports.toHaveAttributeFn = exports.toHaveAttributeAndValueFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function conditionAttr(el, attribute) {
+    const attr = await el.getAttribute(attribute);
+    if (typeof attr !== 'string') {
+        return { result: false, value: attr };
+    }
+    else {
+        return { result: true, value: attr };
+    }
+}
+async function conditionAttrAndValue(el, attribute, value, options) {
+    const attr = await el.getAttribute(attribute);
+    if (typeof attr !== 'string') {
+        return { result: false, value: attr };
+    }
+    return utils_1.compareText(attr, value, options);
+}
+function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'attribute', verb = 'have' } = this;
+    return browser.call(async () => {
+        let el = await received;
+        let attr;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
+            el = result.el;
+            attr = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const expected = utils_1.wrapExpectedWithArray(el, attr, value);
+        const message = utils_1.enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+exports.toHaveAttributeAndValueFn = toHaveAttributeAndValueFn;
+function toHaveAttributeFn(received, attribute) {
+    const isNot = this.isNot;
+    const { expectation = 'attribute', verb = 'have' } = this;
+    return browser.call(async () => {
+        let el = await received;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, conditionAttr, {}, [attribute]);
+            el = result.el;
+            return result.success;
+        }, isNot, {});
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+exports.toHaveAttributeFn = toHaveAttributeFn;
+function toHaveAttribute(...args) {
+    if (args.length === 3 || args.length === 4) {
+        return expectAdapter_1.runExpect.call(this, toHaveAttributeAndValueFn, args);
+    }
+    else {
+        return expectAdapter_1.runExpect.call(this, toHaveAttributeFn, args);
+    }
+}
+exports.toHaveAttribute = toHaveAttribute;
+exports.toHaveAttr = toHaveAttribute;

package/lib/matchers/element/toHaveAttributeContaining.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveAttrContaining = exports.toHaveAttributeContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveAttribute_1 = require("./toHaveAttribute");
+function toHaveAttributeContainingFn(el, attribute, value, options = {}) {
+    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, attribute, value, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveAttributeContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveAttributeContainingFn, args);
+}
+exports.toHaveAttributeContaining = toHaveAttributeContaining;
+exports.toHaveAttrContaining = toHaveAttributeContaining;

package/lib/matchers/element/toHaveChildren.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveChildren = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function condition(el, options) {
+    const children = await el.$$('./*');
+    if (!options.lte && !options.gte && !options.eq) {
+        return {
+            result: children.length > 0,
+            value: children === null || children === void 0 ? void 0 : children.length
+        };
+    }
+    return {
+        result: utils_1.compareNumbers(children === null || children === void 0 ? void 0 : children.length, options),
+        value: children === null || children === void 0 ? void 0 : children.length
+    };
+}
+function toHaveChildrenFn(received, expected, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'children', verb = 'have' } = this;
+    let numberOptions;
+    if (typeof expected === 'number') {
+        numberOptions = { eq: expected };
+    }
+    else if (typeof expected === 'object') {
+        numberOptions = expected;
+    }
+    return browser.call(async () => {
+        let el = await received;
+        let children;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, numberOptions, [numberOptions]);
+            el = result.el;
+            children = result.values;
+            return result.success;
+        }, isNot, { ...numberOptions, ...options });
+        utils_1.updateElementsArray(pass, received, el);
+        const error = utils_1.numberError(numberOptions);
+        const expected = utils_1.wrapExpectedWithArray(el, children, error);
+        const message = utils_1.enhanceError(el, expected, children, this, verb, expectation, '', numberOptions);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+function toHaveChildren(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveChildrenFn, args);
+}
+exports.toHaveChildren = toHaveChildren;

package/lib/matchers/element/toHaveElementClass.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveClass = exports.toHaveElementClass = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function condition(el, attribute, value, options) {
+    const { ignoreCase = false, trim = false, containing = false } = options;
+    let attr = await el.getAttribute(attribute);
+    if (typeof attr !== 'string') {
+        return { result: false };
+    }
+    if (trim) {
+        attr = attr.trim();
+    }
+    if (ignoreCase) {
+        attr = attr.toLowerCase();
+        value = value.toLowerCase();
+    }
+    if (containing) {
+        return {
+            result: attr.includes(value),
+            value: attr
+        };
+    }
+    const classes = attr.split(' ');
+    return {
+        result: classes.includes(value),
+        value: attr
+    };
+}
+function toHaveElementClassFn(received, className, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'class', verb = 'have' } = this;
+    const attribute = 'class';
+    return browser.call(async () => {
+        let el = await received;
+        let attr;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [attribute, className, options]);
+            el = result.el;
+            attr = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, utils_1.wrapExpectedWithArray(el, attr, className), attr, this, verb, expectation, '', options);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+function toHaveElementClass(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassFn, args);
+}
+exports.toHaveElementClass = toHaveElementClass;
+function toHaveClass(...args) {
+    console.warn('expect(...).toHaveClass is deprecated and will be removed in next release. Use toHaveElementClass instead.');
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassFn, args);
+}
+exports.toHaveClass = toHaveClass;

package/lib/matchers/element/toHaveElementClassContaining.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveClassContaining = exports.toHaveElementClassContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveAttribute_1 = require("./toHaveAttribute");
+function toHaveElementClassContainingFn(el, className, options = {}) {
+    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, 'class', className, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveElementClassContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassContainingFn, args);
+}
+exports.toHaveElementClassContaining = toHaveElementClassContaining;
+function toHaveClassContaining(...args) {
+    console.warn('expect(...).toHaveClassContaining is deprecated and will be removed in next release. Use toHaveElementClassContaining instead.');
+    return expectAdapter_1.runExpect.call(this, toHaveElementClassContainingFn, args);
+}
+exports.toHaveClassContaining = toHaveClassContaining;

package/lib/matchers/element/toHaveElementProperty.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveElementProperty = exports.toHaveElementPropertyFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function condition(el, property, value, options = {}) {
+    const { asString = false } = options;
+    let prop = await el.getProperty(property);
+    if (prop === null || prop === undefined) {
+        return { result: false, value: prop };
+    }
+    if (value === null) {
+        return { result: true, value: prop };
+    }
+    if (typeof value !== 'string' || (typeof prop !== 'string' && !asString)) {
+        return { result: prop === value, value: prop };
+    }
+    prop = prop.toString();
+    return utils_1.compareText(prop, value, options);
+}
+function toHaveElementPropertyFn(received, property, value, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'property', verb = 'have' } = this;
+    return browser.call(async () => {
+        let el = await received;
+        let prop;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [property, value]);
+            el = result.el;
+            prop = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        let message;
+        if (value === undefined) {
+            message = utils_1.enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
+        }
+        else {
+            const expected = utils_1.wrapExpectedWithArray(el, prop, value);
+            message = utils_1.enhanceError(el, expected, prop, this, verb, expectation, property, options);
+        }
+        return {
+            pass,
+            message: () => message,
+        };
+    });
+}
+exports.toHaveElementPropertyFn = toHaveElementPropertyFn;
+function toHaveElementProperty(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveElementPropertyFn, args);
+}
+exports.toHaveElementProperty = toHaveElementProperty;

package/lib/matchers/element/toHaveHref.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveLink = exports.toHaveHref = exports.toHaveHrefFn = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveAttribute_1 = require("./toHaveAttribute");
+function toHaveHrefFn(el, href, options = {}) {
+    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, 'href', href, options);
+}
+exports.toHaveHrefFn = toHaveHrefFn;
+function toHaveHref(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveHrefFn, args);
+}
+exports.toHaveHref = toHaveHref;
+exports.toHaveLink = toHaveHref;

package/lib/matchers/element/toHaveHrefContaining.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveLinkContaining = exports.toHaveHrefContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveHref_1 = require("./toHaveHref");
+function toHaveHrefContainingFn(el, href, options = {}) {
+    return toHaveHref_1.toHaveHrefFn.call(this, el, href, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveHrefContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveHrefContainingFn, args);
+}
+exports.toHaveHrefContaining = toHaveHrefContaining;
+exports.toHaveLinkContaining = toHaveHrefContaining;

package/lib/matchers/element/toHaveId.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveId = exports.toHaveIdFn = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveAttribute_1 = require("./toHaveAttribute");
+function toHaveIdFn(el, id, options = {}) {
+    return toHaveAttribute_1.toHaveAttributeAndValueFn.call(this, el, 'id', id, options);
+}
+exports.toHaveIdFn = toHaveIdFn;
+function toHaveId(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveIdFn, args);
+}
+exports.toHaveId = toHaveId;

package/lib/matchers/element/toHaveStyle.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveStyle = exports.toHaveStyleFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function condition(el, style, options) {
+    return utils_1.compareStyle(el, style, options);
+}
+function toHaveStyleFn(received, style, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'style', verb = 'have' } = this;
+    return browser.call(async () => {
+        let el = await received;
+        let actualStyle;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [style, options]);
+            el = result.el;
+            actualStyle = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, utils_1.wrapExpectedWithArray(el, actualStyle, style), actualStyle, this, verb, expectation, '', options);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+exports.toHaveStyleFn = toHaveStyleFn;
+function toHaveStyle(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveStyleFn, args);
+}
+exports.toHaveStyle = toHaveStyle;

package/lib/matchers/element/toHaveText.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveText = exports.toHaveTextFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+async function condition(el, text, options) {
+    const actualText = await el.getText();
+    if (Array.isArray(text)) {
+        return utils_1.compareTextWithArray(actualText, text, options);
+    }
+    return utils_1.compareText(actualText, text, options);
+}
+function toHaveTextFn(received, text, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'text', verb = 'have' } = this;
+    return browser.call(async () => {
+        let el = await received;
+        let actualText;
+        const pass = await utils_1.waitUntil(async () => {
+            const result = await utils_1.executeCommand.call(this, el, condition, options, [text, options]);
+            el = result.el;
+            actualText = result.values;
+            return result.success;
+        }, isNot, options);
+        utils_1.updateElementsArray(pass, received, el);
+        const message = utils_1.enhanceError(el, utils_1.wrapExpectedWithArray(el, actualText, text), actualText, this, verb, expectation, '', options);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+exports.toHaveTextFn = toHaveTextFn;
+function toHaveText(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveTextFn, args);
+}
+exports.toHaveText = toHaveText;

package/lib/matchers/element/toHaveTextContaining.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveTextContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveText_1 = require("./toHaveText");
+function toHaveTextContainingFn(el, text, options = {}) {
+    return toHaveText_1.toHaveTextFn.call(this, el, text, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveTextContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveTextContainingFn, args);
+}
+exports.toHaveTextContaining = toHaveTextContaining;

package/lib/matchers/element/toHaveValue.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveValue = exports.toHaveValueFn = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveElementProperty_1 = require("./toHaveElementProperty");
+function toHaveValueFn(el, value, options = {}) {
+    return toHaveElementProperty_1.toHaveElementPropertyFn.call(this, el, 'value', value, options);
+}
+exports.toHaveValueFn = toHaveValueFn;
+function toHaveValue(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveValueFn, args);
+}
+exports.toHaveValue = toHaveValue;

package/lib/matchers/element/toHaveValueContaining.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHaveValueContaining = void 0;
+const expectAdapter_1 = require("../../util/expectAdapter");
+const toHaveValue_1 = require("./toHaveValue");
+function toHaveValueContainingFn(el, value, options = {}) {
+    return toHaveValue_1.toHaveValueFn.call(this, el, value, {
+        ...options,
+        containing: true
+    });
+}
+function toHaveValueContaining(...args) {
+    return expectAdapter_1.runExpect.call(this, toHaveValueContainingFn, args);
+}
+exports.toHaveValueContaining = toHaveValueContaining;

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeElementsArrayOfSize = void 0;
+const utils_1 = require("../../utils");
+const refetchElements_1 = require("../../util/refetchElements");
+const expectAdapter_1 = require("../../util/expectAdapter");
+function toBeElementsArrayOfSizeFn(received, expected, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'elements array of size', verb = 'be' } = this;
+    let numberOptions;
+    if (typeof expected === 'number') {
+        numberOptions = { eq: expected };
+    }
+    else if (!expected || (typeof expected.eq !== 'number' && typeof expected.gte !== 'number' && typeof expected.lte !== 'number')) {
+        throw new Error('Invalid params passed to toBeElementsArrayOfSize.');
+    }
+    else {
+        numberOptions = expected;
+    }
+    return browser.call(async () => {
+        let elements = await received;
+        const arrLength = elements.length;
+        const pass = await utils_1.waitUntil(async () => {
+            elements = await refetchElements_1.refetchElements(elements, numberOptions.wait, true);
+            return utils_1.compareNumbers(elements.length, numberOptions);
+        }, isNot, { ...numberOptions, ...options });
+        utils_1.updateElementsArray(pass, received, elements, true);
+        const error = utils_1.numberError(numberOptions);
+        const message = utils_1.enhanceError(elements, error, arrLength, this, verb, expectation, '', numberOptions);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+function toBeElementsArrayOfSize(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeElementsArrayOfSizeFn, args);
+}
+exports.toBeElementsArrayOfSize = toBeElementsArrayOfSize;

package/lib/matchers/mock/toBeRequested.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeRequested = void 0;
+const toBeRequestedTimes_1 = require("./toBeRequestedTimes");
+const expectAdapter_1 = require("../../util/expectAdapter");
+function toBeRequestedFn(received, options = {}) {
+    return toBeRequestedTimes_1.toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { ...options, gte: 1 });
+}
+function toBeRequested(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeRequestedFn, args);
+}
+exports.toBeRequested = toBeRequested;

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBeRequestedTimes = exports.toBeRequestedTimesFn = void 0;
+const utils_1 = require("../../utils");
+const expectAdapter_1 = require("../../util/expectAdapter");
+const formatMessage_1 = require("../../util/formatMessage");
+function toBeRequestedTimesFn(received, expected = {}, options = {}) {
+    const isNot = this.isNot || false;
+    const { expectation = `called${typeof expected === 'number' ? ' ' + expected : ''} time${expected !== 1 ? 's' : ''}`, verb = 'be' } = this;
+    let numberOptions;
+    if (typeof expected === 'number') {
+        numberOptions = { eq: expected };
+    }
+    else if (typeof expected === 'object') {
+        numberOptions = expected;
+    }
+    return browser.call(async () => {
+        let actual;
+        const pass = await utils_1.waitUntil(async () => {
+            actual = received.calls.length;
+            return utils_1.compareNumbers(actual, numberOptions);
+        }, isNot, { ...numberOptions, ...options });
+        const error = formatMessage_1.numberError(numberOptions);
+        const message = utils_1.enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
+        return {
+            pass,
+            message: () => message
+        };
+    });
+}
+exports.toBeRequestedTimesFn = toBeRequestedTimesFn;
+function toBeRequestedTimes(...args) {
+    return expectAdapter_1.runExpect.call(this, toBeRequestedTimesFn, args);
+}
+exports.toBeRequestedTimes = toBeRequestedTimes;