expect-webdriverio 4.14.0 → 4.15.1

package/lib/matchers/element/toHaveAttribute.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function conditionAttr(el, attribute) {
     const attr = await el.getAttribute(attribute);
     if (typeof attr !== 'string') {

package/lib/matchers/element/toHaveChildren.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareNumbers, numberError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, options) {
     const children = await el.$$('./*');
     if (typeof options.lte !== 'number' &&

package/lib/matchers/element/toHaveClass.js

@@ -2,7 +2,7 @@ import { DEFAULT_OPTIONS } from '../../constants.js';
 import { compareText, compareTextWithArray, enhanceError, executeCommand, isAsymmeyricMatcher, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 import { toHaveAttributeAndValue } from './toHaveAttribute.js';
 async function condition(el, attribute, value, options) {
-    const actualClass = await (await el).getAttribute(attribute);
+    const actualClass = await el.getAttribute(attribute);
     if (typeof actualClass !== 'string') {
         return { result: false };
     }

package/lib/matchers/element/toHaveComputedLabel.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, label, options) {
     const actualLabel = await el.getComputedLabel();
     if (Array.isArray(label)) {

package/lib/matchers/element/toHaveComputedRole.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, role, options) {
     const actualRole = await el.getComputedRole();
     if (Array.isArray(role)) {

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareText, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, property, value, options = DEFAULT_OPTIONS) {
     const { asString = false } = options;
     let prop = await el.getProperty(property);

package/lib/matchers/element/toHaveHTML.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, html, options) {
     const actualHTML = await el.getHTML(options.includeSelectorTag);
     if (Array.isArray(html)) {

package/lib/matchers/element/toHaveHeight.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, height) {
     const actualHeight = await el.getSize('height');
     return {

package/lib/matchers/element/toHaveSize.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray, compareObject, } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareObject, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray, } from '../../utils.js';
 async function condition(el, size) {
     const actualSize = await el.getSize();
     return compareObject(actualSize, size);

package/lib/matchers/element/toHaveStyle.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, compareStyle, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareStyle, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, style, options) {
     return compareStyle(el, style, options);
 }

package/lib/matchers/element/toHaveText.js

@@ -1,11 +1,31 @@
-import { waitUntil, enhanceError, compareText, compareTextWithArray, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { compareText, compareTextWithArray, enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, text, options) {
-    const actualText = await el.getText();
-    if (Array.isArray(text)) {
-        return compareTextWithArray(actualText, text, options);
+    const actualTextArray = [];
+    const resultArray = [];
+    let checkAllValuesMatchCondition;
+    if (Array.isArray(el)) {
+        for (const element of el) {
+            const actualText = await element.getText();
+            actualTextArray.push(actualText);
+            const result = Array.isArray(text)
+                ? compareTextWithArray(actualText, text, options).result
+                : compareText(actualText, text, options).result;
+            resultArray.push(result);
+        }
+        checkAllValuesMatchCondition = resultArray.every(result => result);
     }
-    return compareText(actualText, text, options);
+    else {
+        const actualText = await el.getText();
+        actualTextArray.push(actualText);
+        checkAllValuesMatchCondition = Array.isArray(text)
+            ? compareTextWithArray(actualText, text, options).result
+            : compareText(actualText, text, options).result;
+    }
+    return {
+        value: actualTextArray.length === 1 ? actualTextArray[0] : actualTextArray,
+        result: checkAllValuesMatchCondition
+    };
 }
 export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
     const isNot = this.isNot;

package/lib/matchers/element/toHaveWidth.js

@@ -1,5 +1,5 @@
-import { waitUntil, enhanceError, executeCommand, wrapExpectedWithArray } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { enhanceError, executeCommand, waitUntil, wrapExpectedWithArray } from '../../utils.js';
 async function condition(el, width) {
     const actualWidth = await el.getSize('width');
     return {

package/lib/util/formatMessage.js

@@ -1,4 +1,4 @@
-import { printExpected, printReceived, printDiffOrStringify } from 'jest-matcher-utils';
+import { printDiffOrStringify, printExpected, printReceived } from 'jest-matcher-utils';
 import { equals } from '../jasmineUtils.js';
 const EXPECTED_LABEL = 'Expected';
 const RECEIVED_LABEL = 'Received';

package/lib/utils.js

@@ -1,8 +1,8 @@
 import isEqual from 'lodash.isequal';
-import { executeCommand } from './util/executeCommand.js';
+import { DEFAULT_OPTIONS } from './constants.js';
 import { wrapExpectedWithArray } from './util/elementsUtil.js';
+import { executeCommand } from './util/executeCommand.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 asymmetricMatcher = typeof Symbol === 'function' && Symbol.for
     ? Symbol.for('jest.asymmetricMatcher')
@@ -219,7 +219,7 @@ function aliasFn(fn, { verb, expectation, } = {}, ...args) {
     this.expectation = expectation;
     return fn.apply(this, args);
 }
-export { wrapExpectedWithArray, enhanceError, numberError, executeCommand, executeCommandBe, waitUntil, compareNumbers, aliasFn, };
+export { aliasFn, compareNumbers, enhanceError, executeCommand, executeCommandBe, numberError, waitUntil, wrapExpectedWithArray };
 function replaceActual(replace, actual) {
     const hasMultipleReplacers = replace.every((r) => Array.isArray(r));
     const replacers = hasMultipleReplacers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "4.14.0",
+  "version": "4.15.1",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -76,7 +76,7 @@
     "shelljs": "^0.8.5",
     "typescript": "^5.3.3",
     "vitest": "1.6.0",
-    "webdriverio": "8.38.0"
+    "webdriverio": "8.38.2"
   },
   "optionalDependencies": {
     "@wdio/globals": "^8.29.3",

package/types/expect-webdriverio.d.ts

@@ -214,8 +214,21 @@ declare namespace ExpectWebdriverIO {
 
         /**
          * `WebdriverIO.Element` -> `getAttribute` class
+         *
+         * Checks if an element has the specified class or matches any of the provided class patterns.
+         * @param className - The class name(s) or pattern(s) to match against.
+         * @param options - Optional settings that can be passed to the function.
+         *
+         * **Usage**
+         * ```js
+         * // Check if an element has the class 'btn'
+         * await expect(element).toHaveElementClass('btn');
+         *
+         * // Check if an element has any of the specified classes
+         * await expect(element).toHaveElementClass(['btn', 'btn-large']);
+         * ```
          */
-        toHaveElementClass(className: string | RegExp | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
+        toHaveElementClass(className: string | RegExp | Array<string | RegExp> | ExpectWebdriverIO.PartialMatcher, options?: ExpectWebdriverIO.StringOptions): R
 
         /**
          * `WebdriverIO.Element` -> `getAttribute` class
@@ -330,6 +343,21 @@ declare namespace ExpectWebdriverIO {
         /**
          * `WebdriverIO.Element` -> `getText`
          * Element's text equals the text provided
+         *
+         * @param text - The expected text to match.
+         * @param options - Optional settings that can be passed to the function.
+         *
+         * **Usage**
+         *
+         * ```js
+         * // Check if an element has the text
+         * const elem = await $('.container')
+         * await expect(elem).toHaveText('Next-gen browser and mobile automation test framework for Node.js')
+         *
+         * // Check if an element array contains the specified text
+         * const elem = await $$('ul > li')
+         * await expect(elem).toHaveText(['Coffee', 'Tea', 'Milk'])
+         * ```
          */
         toHaveText(
             text: string | RegExp | ExpectWebdriverIO.PartialMatcher | Array<string | RegExp>,