expect-webdriverio 4.0.0-alpha.4 → 4.0.0-alpha.6

package/lib/matchers/browser/toHaveTitle.js

@@ -1,17 +1,15 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
-export function toHaveTitle(browser, title, options = {}) {
+export async function toHaveTitle(browser, title, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'title', verb = 'have' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await waitUntil(async () => {
-            actual = await browser.getTitle();
-            return compareText(actual, title, options).result;
-        }, isNot, options);
-        const message = enhanceError('window', title, actual, this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let actual;
+    const pass = await waitUntil(async () => {
+        actual = await browser.getTitle();
+        return compareText(actual, title, options).result;
+    }, isNot, options);
+    const message = enhanceError('window', title, actual, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
 }

package/lib/matchers/browser/toHaveUrl.js

@@ -1,17 +1,15 @@
 import { waitUntil, enhanceError, compareText } from '../../utils.js';
-export function toHaveUrl(browser, url, options = {}) {
+export async function toHaveUrl(browser, url, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'url', verb = 'have' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await waitUntil(async () => {
-            actual = await browser.getUrl();
-            return compareText(actual, url, options).result;
-        }, isNot, options);
-        const message = enhanceError('window', url, actual, this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let actual;
+    const pass = await waitUntil(async () => {
+        actual = await browser.getUrl();
+        return compareText(actual, url, options).result;
+    }, isNot, options);
+    const message = enhanceError('window', url, actual, this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message
+    };
 }

package/lib/matchers/element/toBeClickable.js

@@ -1,16 +1,12 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeClickable(received, options = {}) {
     this.expectation = this.expectation || 'clickable';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isClickable();
-            }
-            catch {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isClickable();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }

package/lib/matchers/element/toBeDisabled.js

@@ -1,9 +1,5 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeDisabled(received, options = {}) {
     this.expectation = this.expectation || 'disabled';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
 }

package/lib/matchers/element/toBeDisplayed.js

@@ -1,16 +1,12 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
-export function toBeDisplayed(received, options = {}) {
+export async function toBeDisplayed(received, options = {}) {
     this.expectation = this.expectation || 'displayed';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isDisplayed();
-            }
-            catch {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isDisplayed();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -1,16 +1,12 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeDisplayedInViewport(received, options = {}) {
     this.expectation = this.expectation || 'displayed in viewport';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isDisplayedInViewport();
-            }
-            catch {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isDisplayedInViewport();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }

package/lib/matchers/element/toBeEnabled.js

@@ -1,9 +1,5 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeEnabled(received, options = {}) {
     this.expectation = this.expectation || 'enabled';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, el => el.isEnabled(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isEnabled(), options);
 }

package/lib/matchers/element/toBeExisting.js

@@ -1,19 +1,15 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe, aliasFn } from '../../utils.js';
 export function toExist(received, options = {}) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, async (el) => {
-            try {
-                return el.isExisting();
-            }
-            catch {
-                return false;
-            }
-        }, options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, async (el) => {
+        try {
+            return el.isExisting();
+        }
+        catch {
+            return false;
+        }
+    }, options);
 }
 export function toBeExisting(el, options) {
     return aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);

package/lib/matchers/element/toBeFocused.js

@@ -1,9 +1,5 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeFocused(received, options = {}) {
     this.expectation = this.expectation || 'focused';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, el => el.isFocused(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isFocused(), options);
 }

package/lib/matchers/element/toBeSelected.js

@@ -1,11 +1,7 @@
-import { browser } from '@wdio/globals';
 import { executeCommandBe } from '../../utils.js';
 export function toBeSelected(received, options = {}) {
     this.expectation = this.expectation || 'selected';
-    return browser.call(async () => {
-        const result = await executeCommandBe.call(this, received, el => el.isSelected(), options);
-        return result;
-    });
+    return executeCommandBe.call(this, received, el => el.isSelected(), options);
 }
 export function toBeChecked(el, options) {
     this.expectation = 'checked';

package/lib/matchers/element/toHaveAttribute.js

@@ -1,4 +1,3 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
@@ -16,44 +15,40 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     }
     return compareText(attr, value, options);
 }
-export function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
+export async 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 waitUntil(async () => {
-            const result = await executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
-            el = result.el;
-            attr = result.values;
-            return result.success;
-        }, isNot, options);
-        updateElementsArray(pass, received, el);
-        const expected = wrapExpectedWithArray(el, attr, value);
-        const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let el = await received;
+    let attr;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, conditionAttrAndValue, options, [attribute, value, options]);
+        el = result.el;
+        attr = result.values;
+        return result.success;
+    }, isNot, options);
+    updateElementsArray(pass, received, el);
+    const expected = wrapExpectedWithArray(el, attr, value);
+    const message = enhanceError(el, expected, attr, this, verb, expectation, attribute, options);
+    return {
+        pass,
+        message: () => message
+    };
 }
-export function toHaveAttributeFn(received, attribute) {
+export async 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 waitUntil(async () => {
-            const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
-            el = result.el;
-            return result.success;
-        }, isNot, {});
-        updateElementsArray(pass, received, el);
-        const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    let el = await received;
+    const pass = await waitUntil(async () => {
+        const result = await executeCommand.call(this, el, conditionAttr, {}, [attribute]);
+        el = result.el;
+        return result.success;
+    }, isNot, {});
+    updateElementsArray(pass, received, el);
+    const message = enhanceError(el, !isNot, pass, this, verb, expectation, attribute, {});
+    return {
+        pass,
+        message: () => message
+    };
 }
 export function toHaveAttribute(...args) {
     if (args.length === 3 || args.length === 4) {

package/lib/matchers/element/toHaveChildren.js

@@ -1,4 +1,3 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, options) {
     const children = await el.$$('./*');
@@ -15,32 +14,26 @@ async function condition(el, options) {
         value: children?.length
     };
 }
-export function toHaveChildren(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 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 expected = wrapExpectedWithArray(el, children, error);
-        const message = enhanceError(el, expected, children, this, verb, expectation, '', numberOptions);
-        return {
-            pass,
-            message: () => message
-        };
-    });
+    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
+    };
 }

package/lib/matchers/element/toHaveClass.js

@@ -1,4 +1,3 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, attribute, value, options) {
     const { ignoreCase = false, trim = false, containing = false } = options;
@@ -27,24 +26,22 @@ async function condition(el, attribute, value, options) {
 export function toHaveElementClass(...args) {
     return toHaveClass.call(this || {}, ...args);
 }
-export function toHaveClass(received, className, options = {}) {
+export async function toHaveClass(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 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
-        };
-    });
+    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/toHaveElementProperty.js

@@ -1,4 +1,3 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
 async function condition(el, property, value, options = {}) {
     const { asString = false } = options;
@@ -15,30 +14,28 @@ async function condition(el, property, value, options = {}) {
     prop = prop.toString();
     return compareText(prop, value, options);
 }
-export function toHaveElementProperty(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 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,
-        };
-    });
+    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,
+    };
 }

package/lib/matchers/element/toHaveStyle.js

@@ -1,25 +1,22 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, style, options) {
     return compareStyle(el, style, options);
 }
-export function toHaveStyle(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 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
-        };
-    });
+    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
+    };
 }

package/lib/matchers/element/toHaveText.js

@@ -1,4 +1,3 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
 async function condition(el, text, options) {
     const actualText = await el.getText();
@@ -7,23 +6,21 @@ async function condition(el, text, options) {
     }
     return compareText(actualText, text, options);
 }
-export function toHaveText(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 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
-        };
-    });
+    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
+    };
 }

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,7 +1,6 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils.js';
 import { refetchElements } from '../../util/refetchElements.js';
-export function toBeElementsArrayOfSize(received, expected, options = {}) {
+export async function toBeElementsArrayOfSize(received, expected, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'elements array of size', verb = 'be' } = this;
     let numberOptions;
@@ -14,19 +13,17 @@ export function toBeElementsArrayOfSize(received, expected, options = {}) {
     else {
         numberOptions = expected;
     }
-    return browser.call(async () => {
-        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
-        };
-    });
+    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
+    };
 }

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,27 +1,20 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
 import { numberError } from '../../util/formatMessage.js';
-export function toBeRequestedTimes(received, expected = {}, options = {}) {
+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 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
-        };
-    });
+    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
+    };
 }

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,34 +1,31 @@
-import { browser } from '@wdio/globals';
 import { waitUntil, enhanceError } from '../../utils.js';
 import { equals } from '../../jasmineUtils.js';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
-export function toBeRequestedWith(received, requestedWith = {}, options = {}) {
+export async function toBeRequestedWith(received, requestedWith = {}, options = {}) {
     const isNot = this.isNot || false;
     const { expectation = 'called with', verb = 'be' } = this;
-    return browser.call(async () => {
-        let actual;
-        const pass = await waitUntil(async () => {
-            for (const call of received.calls) {
-                actual = call;
-                if (methodMatcher(call.method, requestedWith.method) &&
-                    statusCodeMatcher(call.statusCode, requestedWith.statusCode) &&
-                    urlMatcher(call.url, requestedWith.url) &&
-                    headersMatcher(call.headers, requestedWith.requestHeaders) &&
-                    headersMatcher(call.responseHeaders, requestedWith.responseHeaders) &&
-                    bodyMatcher(call.postData, requestedWith.postData) &&
-                    bodyMatcher(call.body, requestedWith.response)) {
-                    return true;
-                }
+    let actual;
+    const pass = await waitUntil(async () => {
+        for (const call of received.calls) {
+            actual = call;
+            if (methodMatcher(call.method, requestedWith.method) &&
+                statusCodeMatcher(call.statusCode, requestedWith.statusCode) &&
+                urlMatcher(call.url, requestedWith.url) &&
+                headersMatcher(call.headers, requestedWith.requestHeaders) &&
+                headersMatcher(call.responseHeaders, requestedWith.responseHeaders) &&
+                bodyMatcher(call.postData, requestedWith.postData) &&
+                bodyMatcher(call.body, requestedWith.response)) {
+                return true;
             }
-            return false;
-        }, isNot, { ...options, wait: isNot ? 0 : options.wait });
-        const message = enhanceError('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
-        return {
-            pass,
-            message: () => message,
-        };
-    });
+        }
+        return false;
+    }, isNot, { ...options, wait: isNot ? 0 : options.wait });
+    const message = enhanceError('mock', minifyRequestedWith(requestedWith), minifyRequestMock(actual, requestedWith) || 'was not called', this, verb, expectation, '', options);
+    return {
+        pass,
+        message: () => message,
+    };
 }
 const methodMatcher = (method, expected) => {
     if (typeof expected === 'undefined') {

package/lib/utils.js

@@ -1,27 +1,32 @@
-import { browser } from '@wdio/globals';
 import { executeCommand } from './util/executeCommand.js';
 import { wrapExpectedWithArray, updateElementsArray } from './util/elementsUtil.js';
 import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.js';
 import { DEFAULT_OPTIONS } from './constants.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
     if (wait === 0) {
         return await condition();
     }
     try {
         let error;
-        await browser.waitUntil(async () => {
+        const start = Date.now();
+        while (true) {
+            if ((Date.now() - start) > wait) {
+                throw new Error('timeout');
+            }
             error = undefined;
             try {
-                return isNot !== await condition();
+                const result = isNot !== await condition();
+                if (result) {
+                    break;
+                }
+                await sleep(interval);
             }
             catch (err) {
                 error = err;
-                return false;
+                await sleep(interval);
             }
-        }, {
-            timeout: wait,
-            interval
-        });
+        }
         if (error) {
             throw error;
         }
@@ -145,4 +150,4 @@ function aliasFn(fn, { verb, expectation } = {}, ...args) {
     this.expectation = expectation;
     return fn.apply(this, args);
 }
-export { updateElementsArray, wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn, };
+export { updateElementsArray, wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -48,6 +48,7 @@
     "@typescript-eslint/eslint-plugin": "^5.33.0",
     "@typescript-eslint/parser": "^5.33.0",
     "@vitest/coverage-c8": "^0.24.0",
+    "@wdio/globals": "^8.0.0-alpha.505",
     "c8": "^7.12.0",
     "eslint": "^8.21.0",
     "eslint-plugin-import": "^2.26.0",
@@ -58,19 +59,12 @@
     "rimraf": "^3.0.2",
     "shelljs": "^0.8.5",
     "typescript": "^4.7.4",
-    "vitest": "0.24.3"
+    "vitest": "0.24.4",
+    "webdriverio": "^8.0.0-alpha.505"
   },
-  "peerDependencies": {
-    "@wdio/globals": "^8.0.0-alpha.365",
-    "webdriverio": "^8.0.0-alpha.365"
-  },
-  "peerDependenciesMeta": {
-    "@wdio/globals": {
-      "optional": false
-    },
-    "webdriverio": {
-      "optional": false
-    }
+  "optionalDependencies": {
+    "@wdio/globals": "^8.0.0-alpha.505",
+    "webdriverio": "^8.0.0-alpha.505"
   },
   "dependencies": {
     "expect": "^29.0.2",