expect-webdriverio 4.0.0 → 4.1.0

package/lib/matchers/element/toHaveAttributeContaining.js

@@ -1,16 +1,8 @@
-"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, {
+import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
+export function toHaveAttributeContaining(el, attribute, value, options = {}) {
+    return 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;
+export const toHaveAttrContaining = toHaveAttributeContaining;

package/lib/matchers/element/toHaveChildren.js

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

package/lib/matchers/element/toHaveClass.js

@@ -0,0 +1,47 @@
+import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+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();
+        if (!(value instanceof RegExp)) {
+            value = value.toLowerCase();
+        }
+    }
+    const classes = attr.split(' ');
+    const valueInClasses = classes.some((t) => {
+        return value instanceof RegExp ? !!t.match(value) : containing ? t.includes(value) : t === value;
+    });
+    return {
+        value: attr,
+        result: valueInClasses
+    };
+}
+export function toHaveElementClass(...args) {
+    return toHaveClass.call(this || {}, ...args);
+}
+export async function toHaveClass(received, className, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'class', verb = 'have' } = this;
+    const attribute = 'class';
+    let el = await received;
+    let attr;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [attribute, className, options]);
+        el = result.el;
+        attr = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, wrapExpectedWithArray(el, attr, className), attr, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
+}

package/lib/matchers/element/toHaveClassContaining.js

@@ -0,0 +1,10 @@
+import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
+export function toHaveElementClassContaining(...args) {
+    return toHaveClassContaining.call(this, ...args);
+}
+export function toHaveClassContaining(el, className, options = {}) {
+    return toHaveAttributeAndValueFn.call(this, el, 'class', className, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,8 +1,4 @@
-"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");
+import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
 async function condition(el, property, value, options = {}) {
     const { asString = false } = options;
     let prop = await el.getProperty(property);
@@ -12,41 +8,34 @@ async function condition(el, property, value, options = {}) {
     if (value === null) {
         return { result: true, value: prop };
     }
-    if (typeof value !== 'string' || (typeof prop !== 'string' && !asString)) {
+    if (!(value instanceof RegExp) && (typeof value !== 'string' || (typeof prop !== 'string' && !asString))) {
         return { result: prop === value, value: prop };
     }
     prop = prop.toString();
-    return utils_1.compareText(prop, value, options);
+    return compareText(prop, value, options);
 }
-function toHaveElementPropertyFn(received, property, value, options = {}) {
+export async function toHaveElementProperty(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);
+    let el = await received;
+    let prop;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [property, value]);
+        el = result.el;
+        prop = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    let message;
+    if (value === undefined) {
+        message = enhanceError(el, !isNot, pass, this, verb, expectation, property, options);
+    }
+    else {
+        const expected = wrapExpectedWithArray(el, prop, value);
+        message = enhanceError(el, expected, prop, this, verb, expectation, property, options);
+    }
+    return {
+        pass,
+        message: () => message,
+    };
 }
-exports.toHaveElementProperty = toHaveElementProperty;

package/lib/matchers/element/toHaveHref.js

@@ -1,14 +1,5 @@
-"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);
+import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
+export function toHaveHref(el, href, options = {}) {
+    return 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;
+export const toHaveLink = toHaveHref;

package/lib/matchers/element/toHaveHrefContaining.js

@@ -1,16 +1,8 @@
-"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, {
+import { toHaveHref } from './toHaveHref.js';
+export function toHaveHrefContaining(el, href, options = {}) {
+    return toHaveHref.call(this, el, href, {
         ...options,
         containing: true
     });
 }
-function toHaveHrefContaining(...args) {
-    return expectAdapter_1.runExpect.call(this, toHaveHrefContainingFn, args);
-}
-exports.toHaveHrefContaining = toHaveHrefContaining;
-exports.toHaveLinkContaining = toHaveHrefContaining;
+export const toHaveLinkContaining = toHaveHrefContaining;

package/lib/matchers/element/toHaveId.js

@@ -1,13 +1,4 @@
-"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);
+import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
+export function toHaveId(el, id, options = {}) {
+    return 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

@@ -1,33 +1,22 @@
-"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");
+import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, style, options) {
-    return utils_1.compareStyle(el, style, options);
+    return compareStyle(el, style, options);
 }
-function toHaveStyleFn(received, style, options = {}) {
+export async function toHaveStyle(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
-        };
-    });
+    let el = await received;
+    let actualStyle;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [style, options]);
+        el = result.el;
+        actualStyle = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, 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

@@ -1,37 +1,26 @@
-"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");
+import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, text, options) {
     const actualText = await el.getText();
     if (Array.isArray(text)) {
-        return utils_1.compareTextWithArray(actualText, text, options);
+        return compareTextWithArray(actualText, text, options);
     }
-    return utils_1.compareText(actualText, text, options);
+    return compareText(actualText, text, options);
 }
-function toHaveTextFn(received, text, options = {}) {
+export async function toHaveText(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
-        };
-    });
+    let el = await received;
+    let actualText;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, condition, options, [text, options]);
+        el = result.el;
+        actualText = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, 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

@@ -1,15 +1,7 @@
-"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, {
+import { toHaveText } from './toHaveText.js';
+export function toHaveTextContaining(el, text, options = {}) {
+    return toHaveText.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

@@ -1,13 +1,4 @@
-"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);
+import { toHaveElementProperty } from './toHaveElementProperty.js';
+export function toHaveValue(el, value, options = {}) {
+    return toHaveElementProperty.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

@@ -1,15 +1,7 @@
-"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, {
+import { toHaveValue } from './toHaveValue.js';
+export function toHaveValueContaining(el, value, options = {}) {
+    return toHaveValue.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

@@ -1,10 +1,6 @@
-"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 = {}) {
+import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils.js';
+import { refetchElements } from '../../util/refetchElements.js';
+export async function toBeElementsArrayOfSize(received, expected, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'elements array of size', verb = 'be' } = this;
     let numberOptions;
@@ -17,23 +13,17 @@ function toBeElementsArrayOfSizeFn(received, expected, options = {}) {
     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
-        };
-    });
+    let elements = await received;
+    const arrLength = elements.length;
+    const pass = await waitUntil(async () => {
+        elements = await refetchElements(elements, numberOptions.wait, true);
+        return compareNumbers(elements.length, numberOptions);
+    }, isNot, { ...numberOptions, ...options });
+    updateElementsArray(pass, received, elements, true);
+    const error = numberError(numberOptions);
+    const message = 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

@@ -1,12 +1,4 @@
-"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 });
+import { toBeRequestedTimes } from './toBeRequestedTimes.js';
+export function toBeRequested(received, options = {}) {
+    return 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

@@ -1,35 +1,20 @@
-"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 = {}) {
+import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
+import { numberError } from '../../util/formatMessage.js';
+export async function toBeRequestedTimes(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
-        };
-    });
+    const numberOptions = typeof expected === 'number'
+        ? { eq: expected }
+        : expected || {};
+    let actual;
+    const pass = await waitUntil(async () => {
+        actual = received.calls.length;
+        return compareNumbers(actual, numberOptions);
+    }, isNot, { ...numberOptions, ...options });
+    const error = numberError(numberOptions);
+    const message = 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;