expect-webdriverio 4.5.2 → 4.6.1

package/lib/matchers/element/toHaveHTML.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, html, options) {
     const actualHTML = await el.getHTML(options.includeSelectorTag);
     if (Array.isArray(html)) {
@@ -6,21 +7,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 = DEFAULT_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 = DEFAULT_OPTIONS) {
+    return toHaveHTML.call(this, el, html, {
+        ...options,
+        containing: true
+    });
 }

package/lib/matchers/element/toHaveHeight.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, height) {
     const actualHeight = await el.getSize('height');
     return {
@@ -6,21 +7,33 @@ async function condition(el, height) {
         result: actualHeight === height,
     };
 }
-export async function toHaveHeight(received, height, options = {}) {
+export async function toHaveHeight(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'height', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveHeight',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualHeight;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [height, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualHeight = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualHeight, height), actualHeight, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualHeight, expectedValue), actualHeight, this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveHeight',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveHref.js

@@ -1,5 +1,25 @@
-import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
-export function toHaveHref(el, href, options = {}) {
-    return toHaveAttributeAndValueFn.call(this, el, 'href', href, options);
+import { toHaveAttributeAndValue } from './toHaveAttribute.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveHref(el, expectedValue, options = DEFAULT_OPTIONS) {
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveHref',
+        expectedValue,
+        options,
+    });
+    const result = await toHaveAttributeAndValue.call(this, el, 'href', expectedValue, options);
+    await options.afterAssertion?.({
+        matcherName: 'toHaveHref',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }
 export const toHaveLink = toHaveHref;
+export function toHaveHrefContaining(el, href, options = DEFAULT_OPTIONS) {
+    return toHaveHref.call(this, el, href, {
+        ...options,
+        containing: true
+    });
+}
+export const toHaveLinkContaining = toHaveHrefContaining;

package/lib/matchers/element/toHaveId.js

@@ -1,4 +1,17 @@
-import { toHaveAttributeAndValueFn } from './toHaveAttribute.js';
-export function toHaveId(el, id, options = {}) {
-    return toHaveAttributeAndValueFn.call(this, el, 'id', id, options);
+import { toHaveAttributeAndValue } from './toHaveAttribute.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toHaveId(el, expectedValue, options = DEFAULT_OPTIONS) {
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveId',
+        expectedValue,
+        options,
+    });
+    const result = await toHaveAttributeAndValue.call(this, el, 'id', expectedValue, options);
+    await options.afterAssertion?.({
+        matcherName: 'toHaveId',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveSize.js

@@ -1,23 +1,36 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, compareObject, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, size) {
     const actualSize = await el.getSize();
     return compareObject(actualSize, size);
 }
-export async function toHaveSize(received, size, options = {}) {
+export async function toHaveSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'size', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveSize',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualSize;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [size, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualSize = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, size), actualSize, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualSize, expectedValue), actualSize, this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveSize',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveStyle.js

@@ -1,22 +1,35 @@
 import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, style, options) {
     return compareStyle(el, style, options);
 }
-export async function toHaveStyle(received, style, options = {}) {
+export async function toHaveStyle(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'style', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveStyle',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualStyle;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [style, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, 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 {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualStyle, expectedValue), actualStyle, this, verb, expectation, '', options);
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveStyle',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/element/toHaveText.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray, updateElementsArray } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, text, options) {
     const actualText = await el.getText();
     if (Array.isArray(text)) {
@@ -6,21 +7,39 @@ async function condition(el, text, options) {
     }
     return compareText(actualText, text, options);
 }
-export async function toHaveText(received, text, options = {}) {
+export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'text', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveText',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualText;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [text, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, 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 {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualText, expectedValue), actualText, this, verb, expectation, '', options);
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveText',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+export function toHaveTextContaining(el, text, options = DEFAULT_OPTIONS) {
+    return toHaveText.call(this, el, text, {
+        ...options,
+        containing: true
+    });
 }

package/lib/matchers/element/toHaveValue.js

@@ -1,4 +1,11 @@
 import { toHaveElementProperty } from './toHaveElementProperty.js';
-export function toHaveValue(el, value, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export function toHaveValue(el, value, options = DEFAULT_OPTIONS) {
     return toHaveElementProperty.call(this, el, 'value', value, options);
 }
+export function toHaveValueContaining(el, value, options = DEFAULT_OPTIONS) {
+    return toHaveValue.call(this, el, value, {
+        ...options,
+        containing: true
+    });
+}

package/lib/matchers/element/toHaveWidth.js

@@ -1,4 +1,5 @@
 import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, updateElementsArray, } from '../../utils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 async function condition(el, width) {
     const actualWidth = await el.getSize('width');
     return {
@@ -6,21 +7,33 @@ async function condition(el, width) {
         result: actualWidth === width,
     };
 }
-export async function toHaveWidth(received, width, options = {}) {
+export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'width', verb = 'have' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toHaveWidth',
+        expectedValue,
+        options,
+    });
     let el = await received;
     let actualWidth;
     const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, options, [width, options]);
+        const result = await executeCommand.call(this, el, condition, options, [expectedValue, options]);
         el = result.el;
         actualWidth = result.values;
         return result.success;
     }, isNot, options);
     updateElementsArray(pass, received, el);
-    const message = enhanceError(el, wrapExpectedWithArray(el, actualWidth, width), actualWidth, this, verb, expectation, '', options);
-    return {
+    const message = enhanceError(el, wrapExpectedWithArray(el, actualWidth, expectedValue), actualWidth, this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toHaveWidth',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,17 +1,23 @@
 import { waitUntil, enhanceError, compareNumbers, numberError, updateElementsArray } from '../../utils.js';
 import { refetchElements } from '../../util/refetchElements.js';
-export async function toBeElementsArrayOfSize(received, expected, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;
     const { expectation = 'elements array of size', verb = 'be' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toBeElementsArrayOfSize',
+        expectedValue,
+        options,
+    });
     let numberOptions;
-    if (typeof expected === 'number') {
-        numberOptions = { eq: expected };
+    if (typeof expectedValue === 'number') {
+        numberOptions = { eq: expectedValue };
     }
-    else if (!expected || (typeof expected.eq !== 'number' && typeof expected.gte !== 'number' && typeof expected.lte !== 'number')) {
+    else if (!expectedValue || (typeof expectedValue.eq !== 'number' && typeof expectedValue.gte !== 'number' && typeof expectedValue.lte !== 'number')) {
         throw new Error('Invalid params passed to toBeElementsArrayOfSize.');
     }
     else {
-        numberOptions = expected;
+        numberOptions = expectedValue;
     }
     let elements = await received;
     const arrLength = elements.length;
@@ -22,8 +28,15 @@ export async function toBeElementsArrayOfSize(received, expected, options = {})
     updateElementsArray(pass, received, elements, true);
     const error = numberError(numberOptions);
     const message = enhanceError(elements, error, arrLength, this, verb, expectation, '', numberOptions);
-    return {
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toBeElementsArrayOfSize',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/mock/toBeRequested.js

@@ -1,4 +1,5 @@
 import { toBeRequestedTimes } from './toBeRequestedTimes.js';
-export function toBeRequested(received, options = {}) {
-    return toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { ...options, gte: 1 });
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export function toBeRequested(received, options = DEFAULT_OPTIONS) {
+    return toBeRequestedTimes.call({ ...(this || {}), expectation: 'called' }, received, { gte: 1 }, options);
 }

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,11 +1,17 @@
 import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
 import { numberError } from '../../util/formatMessage.js';
-export async function toBeRequestedTimes(received, expected = {}, options = {}) {
+import { DEFAULT_OPTIONS } from '../../constants.js';
+export async function toBeRequestedTimes(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot || false;
-    const { expectation = `called${typeof expected === 'number' ? ' ' + expected : ''} time${expected !== 1 ? 's' : ''}`, verb = 'be' } = this;
-    const numberOptions = typeof expected === 'number'
-        ? { eq: expected }
-        : expected || {};
+    const { expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, verb = 'be' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toBeRequestedTimes',
+        expectedValue,
+        options,
+    });
+    const numberOptions = typeof expectedValue === 'number'
+        ? { eq: expectedValue }
+        : expectedValue || {};
     let actual;
     const pass = await waitUntil(async () => {
         actual = received.calls.length;
@@ -13,8 +19,15 @@ export async function toBeRequestedTimes(received, expected = {}, options = {})
     }, isNot, { ...numberOptions, ...options });
     const error = numberError(numberOptions);
     const message = enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
-    return {
+    const result = {
         pass,
         message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toBeRequestedTimes',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,31 +1,44 @@
 import { waitUntil, enhanceError } from '../../utils.js';
 import { equals } from '../../jasmineUtils.js';
+import { DEFAULT_OPTIONS } from '../../constants.js';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
-export async function toBeRequestedWith(received, requestedWith = {}, options = {}) {
+export async function toBeRequestedWith(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot || false;
     const { expectation = 'called with', verb = 'be' } = this;
+    await options.beforeAssertion?.({
+        matcherName: 'toBeRequestedWith',
+        expectedValue,
+        options,
+    });
     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)) {
+            if (methodMatcher(call.method, expectedValue.method) &&
+                statusCodeMatcher(call.statusCode, expectedValue.statusCode) &&
+                urlMatcher(call.url, expectedValue.url) &&
+                headersMatcher(call.headers, expectedValue.requestHeaders) &&
+                headersMatcher(call.responseHeaders, expectedValue.responseHeaders) &&
+                bodyMatcher(call.postData, expectedValue.postData) &&
+                bodyMatcher(call.body, expectedValue.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 {
+    const message = enhanceError('mock', minifyRequestedWith(expectedValue), minifyRequestMock(actual, expectedValue) || 'was not called', this, verb, expectation, '', options);
+    const result = {
         pass,
-        message: () => message,
+        message: () => message
     };
+    await options.afterAssertion?.({
+        matcherName: 'toBeRequestedWith',
+        expectedValue,
+        options,
+        result
+    });
+    return result;
 }
 const methodMatcher = (method, expected) => {
     if (typeof expected === 'undefined') {

package/lib/matchers.js

@@ -1,7 +1,6 @@
+import * as toHaveClipboardText from './matchers/browser/toHaveClipboardText.js';
 import * as toHaveTitle from './matchers/browser/toHaveTitle.js';
-import * as toHaveTitleContaining from './matchers/browser/toHaveTitleContaining.js';
 import * as toHaveUrl from './matchers/browser/toHaveUrl.js';
-import * as toHaveUrlContaining from './matchers/browser/toHaveUrlContaining.js';
 import * as toBeElementsArrayOfSize from './matchers/elements/toBeElementsArrayOfSize.js';
 import * as toBeClickable from './matchers/element/toBeClickable.js';
 import * as toBeDisabled from './matchers/element/toBeDisabled.js';
@@ -12,27 +11,22 @@ import * as toBeExisting from './matchers/element/toBeExisting.js';
 import * as toBeFocused from './matchers/element/toBeFocused.js';
 import * as toBeSelected from './matchers/element/toBeSelected.js';
 import * as toHaveAttribute from './matchers/element/toHaveAttribute.js';
-import * as toHaveAttributeContaining from './matchers/element/toHaveAttributeContaining.js';
 import * as toHaveChildren from './matchers/element/toHaveChildren.js';
 import * as toHaveClass from './matchers/element/toHaveClass.js';
-import * as toHaveClassContaining from './matchers/element/toHaveClassContaining.js';
 import * as toHaveHref from './matchers/element/toHaveHref.js';
-import * as toHaveHrefContaining from './matchers/element/toHaveHrefContaining.js';
 import * as toHaveId from './matchers/element/toHaveId.js';
+import * as toHaveSize from './matchers/element/toHaveSize.js';
 import * as toHaveElementProperty from './matchers/element/toHaveElementProperty.js';
 import * as toHaveText from './matchers/element/toHaveText.js';
-import * as toHaveTextContaining from './matchers/element/toHaveTextContaining.js';
 import * as toHaveValue from './matchers/element/toHaveValue.js';
-import * as toHaveValueContaining from './matchers/element/toHaveValueContaining.js';
 import * as toHaveStyle from './matchers/element/toHaveStyle.js';
 import * as toBeRequested from './matchers/mock/toBeRequested.js';
 import * as toBeRequestedTimes from './matchers/mock/toBeRequestedTimes.js';
 import * as toBeRequestedWith from './matchers/mock/toBeRequestedWith.js';
 const matchers = {
+    ...toHaveClipboardText,
     ...toHaveTitle,
-    ...toHaveTitleContaining,
     ...toHaveUrl,
-    ...toHaveUrlContaining,
     ...toBeElementsArrayOfSize,
     ...toBeClickable,
     ...toBeDisabled,
@@ -43,18 +37,14 @@ const matchers = {
     ...toBeFocused,
     ...toBeSelected,
     ...toHaveAttribute,
-    ...toHaveAttributeContaining,
     ...toHaveChildren,
     ...toHaveClass,
-    ...toHaveClassContaining,
     ...toHaveHref,
-    ...toHaveHrefContaining,
     ...toHaveId,
+    ...toHaveSize,
     ...toHaveElementProperty,
     ...toHaveText,
-    ...toHaveTextContaining,
     ...toHaveValue,
-    ...toHaveValueContaining,
     ...toHaveStyle,
     ...toBeRequested,
     ...toBeRequestedTimes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.5.2",
+  "version": "4.6.1",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -81,6 +81,7 @@
   },
   "optionalDependencies": {
     "@wdio/globals": "^8.23.1",
+    "@wdio/logger": "^8.16.17",
     "webdriverio": "^8.23.1"
   },
   "dependencies": {