expect-webdriverio 4.5.1 → 4.6.0

package/lib/constants.js

@@ -1,4 +1,6 @@
 export const DEFAULT_OPTIONS = {
     wait: 2000,
     interval: 100,
+    beforeAssertion: async () => { },
+    afterAssertion: async () => { },
 };

package/lib/matchers/browser/toHaveClipboardText.js

@@ -0,0 +1,37 @@
+import { waitUntil, enhanceError, compareText } from '../../utils.js';
+import logger from '@wdio/logger';
+const log = logger('expect-webdriverio');
+export async function toHaveClipboardText(browser, expectedValue, options = {}) {
+    const isNot = this.isNot;
+    const { expectation = 'clipboard text', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveClipboardText',
+        expectedValue,
+        options,
+    });
+    let actual;
+    const pass = await waitUntil(async () => {
+        await browser.setPermissions({ name: 'clipboard-read' }, 'granted')
+            .catch((err) => log.warn(`Couldn't set clipboard permissions: ${err}`));
+        actual = await browser.execute(() => window.navigator.clipboard.readText());
+        return compareText(actual, expectedValue, options).result;
+    }, isNot, options);
+    const message = enhanceError('browser', expectedValue, actual, this, verb, expectation, '', options);
+    const result = {
+        pass,
+        message: () => message
+    };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveClipboardText',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveClipboardTextContaining(browser, clipboardText, options = {}) {
+    return toHaveClipboardText.call(this, browser, clipboardText, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/browser/toHaveTitle.js

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

package/lib/matchers/browser/toHaveUrl.js

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

package/lib/matchers/element/toBeClickable.js

@@ -1,7 +1,11 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeClickable(received, options = {}) {
+export async function toBeClickable(received, options = {}) {
     this.expectation = this.expectation || 'clickable';
-    return executeCommandBe.call(this, received, async (el) => {
+    await options.beforeAssertion?.({
+        matcherName: 'toBeClickable',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, async (el) => {
         try {
             return el.isClickable();
         }
@@ -9,4 +13,10 @@ export function toBeClickable(received, options = {}) {
             return false;
         }
     }, options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeClickable',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeDisabled.js

@@ -1,5 +1,15 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeDisabled(received, options = {}) {
+export async function toBeDisabled(received, options = {}) {
     this.expectation = this.expectation || 'disabled';
-    return executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
+    await options.beforeAssertion?.({
+        matcherName: 'toBeDisabled',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, async (el) => !await el.isEnabled(), options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeDisabled',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeDisplayed.js

@@ -1,7 +1,11 @@
 import { executeCommandBe } from '../../utils.js';
 export async function toBeDisplayed(received, options = {}) {
     this.expectation = this.expectation || 'displayed';
-    return executeCommandBe.call(this, received, async (el) => {
+    await options.beforeAssertion?.({
+        matcherName: 'toBeDisplayed',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, async (el) => {
         try {
             return el.isDisplayed();
         }
@@ -9,4 +13,10 @@ export async function toBeDisplayed(received, options = {}) {
             return false;
         }
     }, options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeDisplayed',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeDisplayedInViewport.js

@@ -1,7 +1,11 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeDisplayedInViewport(received, options = {}) {
+export async function toBeDisplayedInViewport(received, options = {}) {
     this.expectation = this.expectation || 'displayed in viewport';
-    return executeCommandBe.call(this, received, async (el) => {
+    await options.beforeAssertion?.({
+        matcherName: 'toBeDisplayedInViewport',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, async (el) => {
         try {
             return el.isDisplayedInViewport();
         }
@@ -9,4 +13,10 @@ export function toBeDisplayedInViewport(received, options = {}) {
             return false;
         }
     }, options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeDisplayedInViewport',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeEnabled.js

@@ -1,5 +1,15 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeEnabled(received, options = {}) {
+export async function toBeEnabled(received, options = {}) {
     this.expectation = this.expectation || 'enabled';
-    return executeCommandBe.call(this, received, el => el.isEnabled(), options);
+    await options.beforeAssertion?.({
+        matcherName: 'toBeEnabled',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, el => el.isEnabled(), options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeEnabled',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeExisting.js

@@ -1,8 +1,12 @@
 import { executeCommandBe, aliasFn } from '../../utils.js';
-export function toExist(received, options = {}) {
+export async function toExist(received, options = {}) {
     this.expectation = this.expectation || 'exist';
     this.verb = this.verb || '';
-    return executeCommandBe.call(this, received, async (el) => {
+    await options.beforeAssertion?.({
+        matcherName: 'toExist',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, async (el) => {
         try {
             return el.isExisting();
         }
@@ -10,6 +14,12 @@ export function toExist(received, options = {}) {
             return false;
         }
     }, options);
+    await options.afterAssertion?.({
+        matcherName: 'toExist',
+        options,
+        result
+    });
+    return result;
 }
 export function toBeExisting(el, options) {
     return aliasFn.call(this, toExist, { verb: 'be', expectation: 'existing' }, el, options);

package/lib/matchers/element/toBeFocused.js

@@ -1,5 +1,15 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeFocused(received, options = {}) {
+export async function toBeFocused(received, options = {}) {
     this.expectation = this.expectation || 'focused';
-    return executeCommandBe.call(this, received, el => el.isFocused(), options);
+    await options.beforeAssertion?.({
+        matcherName: 'toBeFocused',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, el => el.isFocused(), options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeFocused',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toBeSelected.js

@@ -1,9 +1,29 @@
 import { executeCommandBe } from '../../utils.js';
-export function toBeSelected(received, options = {}) {
+export async function toBeSelected(received, options = {}) {
     this.expectation = this.expectation || 'selected';
-    return executeCommandBe.call(this, received, el => el.isSelected(), options);
+    await options.beforeAssertion?.({
+        matcherName: 'toBeSelected',
+        options,
+    });
+    const result = await executeCommandBe.call(this, received, el => el.isSelected(), options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeSelected',
+        options,
+        result
+    });
+    return result;
 }
-export function toBeChecked(el, options) {
+export async function toBeChecked(el, options = {}) {
     this.expectation = 'checked';
-    return toBeSelected.call(this, el, options);
+    await options.beforeAssertion?.({
+        matcherName: 'toBeChecked',
+        options,
+    });
+    const result = await toBeSelected.call(this, el, options);
+    await options.afterAssertion?.({
+        matcherName: 'toBeChecked',
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveAttribute.js

@@ -15,7 +15,7 @@ async function conditionAttrAndValue(el, attribute, value, options) {
     }
     return compareText(attr, value, options);
 }
-export async function toHaveAttributeAndValueFn(received, attribute, value, options = {}) {
+export async function toHaveAttributeAndValue(received, attribute, value, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
     let el = await received;
@@ -34,7 +34,7 @@ export async function toHaveAttributeAndValueFn(received, attribute, value, opti
         message: () => message
     };
 }
-export async function toHaveAttributeFn(received, attribute) {
+async function toHaveAttributeFn(received, attribute) {
     const isNot = this.isNot;
     const { expectation = 'attribute', verb = 'have' } = this;
     let el = await received;
@@ -50,12 +50,28 @@ export async function toHaveAttributeFn(received, attribute) {
         message: () => message
     };
 }
-export function toHaveAttribute(...args) {
-    if (args.length === 3 || args.length === 4) {
-        return toHaveAttributeAndValueFn.call(this, ...args);
-    }
-    else {
-        return toHaveAttributeFn.call(this, ...args);
-    }
+export async function toHaveAttribute(received, attribute, value, options = {}) {
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveAttribute',
+        expectedValue: [attribute, value],
+        options,
+    });
+    const result = typeof value !== 'undefined'
+        ? await toHaveAttributeAndValue.call(this, received, attribute, value, options)
+        : await toHaveAttributeFn.call(this, received, attribute);
+    await options.afterAssertion?.({
+        matcherName: 'toHaveAttribute',
+        expectedValue: [attribute, value],
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveAttributeContaining(el, attribute, value, options = {}) {
+    return toHaveAttributeAndValue.call(this, el, attribute, value, {
+        ...options,
+        containing: true
+    });
 }
+export const toHaveAttrContaining = toHaveAttributeContaining;
 export const toHaveAttr = toHaveAttribute;

package/lib/matchers/element/toHaveChildren.js

@@ -14,12 +14,17 @@ async function condition(el, options) {
         value: children?.length
     };
 }
-export async function toHaveChildren(received, expected, options = {}) {
+export async function toHaveChildren(received, expectedValue, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'children', verb = 'have' } = this;
-    const numberOptions = typeof expected === 'number'
-        ? { eq: expected }
-        : expected || {};
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveChildren',
+        expectedValue,
+        options,
+    });
+    const numberOptions = typeof expectedValue === 'number'
+        ? { eq: expectedValue }
+        : expectedValue || {};
     let el = await received;
     let children;
     const pass = await waitUntil(async () => {
@@ -32,8 +37,15 @@ export async function toHaveChildren(received, expected, options = {}) {
     const error = numberError(numberOptions);
     const expectedArray = wrapExpectedWithArray(el, children, error);
     const message = enhanceError(el, expectedArray, children, this, verb, expectation, '', numberOptions);
-    return {
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveChildren',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveClass.js

@@ -1,3 +1,4 @@
+import { toHaveAttributeAndValue } from './toHaveAttribute.js';
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareText } from '../../utils.js';
 async function condition(el, attribute, value, options) {
     const { ignoreCase = false, trim = false, containing = false } = options;
@@ -20,32 +21,53 @@ async function condition(el, attribute, value, options) {
             ? !!t.match(value)
             : containing && typeof value === 'string'
                 ? t.includes(value)
-                : compareText(t, value, options);
+                : compareText(t, value, options).result;
     });
     return {
         value: attr,
         result: valueInClasses
     };
 }
-export function toHaveElementClass(...args) {
-    return toHaveClass.call(this || {}, ...args);
+export function toHaveClass(...args) {
+    return toHaveElementClass.call(this || {}, ...args);
 }
-export async function toHaveClass(received, className, options = {}) {
+export async function toHaveElementClass(received, expectedValue, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'class', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveElementClass',
+        expectedValue,
+        options,
+    });
     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]);
+        const result = await executeCommand.call(this, el, condition, options, [attribute, expectedValue, 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 {
+    const message = enhanceError(el, wrapExpectedWithArray(el, attr, expectedValue), attr, this, verb, expectation, '', options);
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveElementClass',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveElementClassContaining(...args) {
+    return toHaveClassContaining.call(this, ...args);
+}
+export function toHaveClassContaining(el, className, options = {}) {
+    return toHaveAttributeAndValue.call(this, el, 'class', className, {
+        ...options,
+        containing: true
+    });
 }

package/lib/matchers/element/toHaveComputedLabel.js

@@ -6,21 +6,39 @@ async function condition(el, label, options) {
     }
     return compareText(actualLabel, label, options);
 }
-export async function toHaveComputedLabel(received, label, options = {}) {
+export async function toHaveComputedLabel(received, expectedValue, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'computed label', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveComputedLabel',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualLabel;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [label, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualLabel = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, label), actualLabel, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualLabel, expectedValue), actualLabel, this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveComputedLabel',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveComputedLabelContaining(el, label, options = {}) {
+    return toHaveComputedLabel.call(this, el, label, {
+        ...options,
+        containing: true
+    });
 }

package/lib/matchers/element/toHaveComputedRole.js

@@ -6,21 +6,39 @@ async function condition(el, role, options) {
     }
     return compareText(actualRole, role, options);
 }
-export async function toHaveComputedRole(received, role, options = {}) {
+export async function toHaveComputedRole(received, expectedValue, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'computed role', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveComputedRole',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualRole;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [role, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualRole = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, role), actualRole, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualRole, expectedValue), actualRole, this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveComputedRole',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveComputedRoleContaining(el, role, options = {}) {
+    return toHaveComputedRole.call(this, el, role, {
+        ...options,
+        containing: true
+    });
 }

package/lib/matchers/element/toHaveElementProperty.js

@@ -17,6 +17,11 @@ async function condition(el, property, value, options = {}) {
 export async function toHaveElementProperty(received, property, value, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'property', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveElementProperty',
+        expectedValue: [property, value],
+        options,
+    });
     let el = await received;
     let prop;
     const pass = await waitUntil(async () => {
@@ -34,8 +39,15 @@ export async function toHaveElementProperty(received, property, value, options =
         const expected = wrapExpectedWithArray(el, prop, value);
         message = enhanceError(el, expected, prop, this, verb, expectation, property, options);
     }
-    return {
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveElementProperty',
+        expectedValue: [property, value],
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveHTML.js

@@ -6,21 +6,39 @@ async function condition(el, html, options) {
     }
     return compareText(actualHTML, html, options);
 }
-export async function toHaveHTML(received, html, options = {}) {
+export async function toHaveHTML(received, expectedValue, options = {}) {
     const isNot = this.isNot;
     const { expectation = 'HTML', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveHTML',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualHTML;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [html, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualHTML = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, html), actualHTML, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualHTML, expectedValue), actualHTML, this, verb, expectation, '', options);
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveHTML',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveHTMLContaining(el, html, options = {}) {
+    return toHaveHTML.call(this, el, html, {
+        ...options,
+        containing: true
+    });
 }