expect-webdriverio 6.1.0-alpha.0 → 6.1.0

package/lib/jasmineUtils.js

@@ -11,7 +11,10 @@ function asymmetricMatch(a, b) {
     if (asymmetricA && asymmetricB) {
         return undefined;
     }
-    const matchersUtil = { equals, contains: equals };
+    const matchersUtil = {
+        equals,
+        contains: (actual, expected) => actual.some(value => equals(value, expected)),
+    };
     if (asymmetricA) {
         return a.asymmetricMatch(b, matchersUtil);
     }

package/lib/matchers/element/toHaveAttribute.js

@@ -23,6 +23,7 @@ export async function toHaveAttributeAndValue(received, attribute, expectedValue
     const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, values) => {
                 return conditionAttributeValueMatchWithExpected(element, attribute, values, options);

package/lib/matchers/element/toHaveComputedLabel.js

@@ -17,6 +17,7 @@ export async function toHaveComputedLabel(received, expectedValue, options = DEF
     const { success: pass, actual: actualLabel, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveComputedRole.js

@@ -17,6 +17,7 @@ export async function toHaveComputedRole(received, expectedValue, options = DEFA
     const { success: pass, actual: actualRole, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveElementClass.js

@@ -35,6 +35,7 @@ export async function toHaveElementClass(received, expectedValue, options = DEFA
     const { success: pass, actual: attr, subject: el, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, attribute, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveElementProperty.js

@@ -1,3 +1,4 @@
+import { equals } from '../../jasmineUtils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
 import { expect } from 'expect';
@@ -9,7 +10,7 @@ async function condition(el, property, expectedValue, options = DEFAULT_OPTIONS)
     const propertyValue = await el.getProperty(property);
     if (propertyValue === null || propertyValue === undefined || (!(expectedValue instanceof RegExp) && typeof propertyValue !== 'string' && !asString)) {
         if (isAsymmetricMatcher(expectedValue)) {
-            return { success: expectedValue.asymmetricMatch(propertyValue), actual: propertyValue };
+            return { success: equals(propertyValue, expectedValue), actual: propertyValue };
         }
         return { success: propertyValue === expectedValue, actual: propertyValue };
     }
@@ -36,6 +37,7 @@ export async function toHaveElementProperty(received, property, value, options =
     const { success: pass, actual: actualProppertyValue, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: value,
             singleElementCompare: (element, expectedValue) => {
                 return condition(element, property, expectedValue, options);

package/lib/matchers/element/toHaveHTML.js

@@ -17,6 +17,7 @@ export async function toHaveHTML(received, expectedValue, options = DEFAULT_OPTI
     const { success: pass, actual: actualHTML, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
         const result = await executeCommandWithStrategy({
             unresolvedElements: received,
+            supportsArrayContaining: true,
             expectedValues: expectedValue,
             singleElementCompare: (element, expectedValue) => singleElementCompare(element, expectedValue, options),
             context: { isNot, iteration },

package/lib/matchers/element/toHaveText.js

@@ -1,5 +1,5 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareTextOrArray, enhanceError, getFeatureFlagValue, waitUntil, } from '../../utils.js';
+import { compareTextOrArray, enhanceError, getFeatureFlagValue, isArrayContainingMatcher, waitUntil, } from '../../utils.js';
 import { executeCommandWithStrategy } from '../../util/executeCommand.js';
 import { fillSingleExpectedForElementArray } from '../../util/elementsUtil.js';
 import { buildWdioAsymmetricMatchersWithOptions } from '../asymmetrics/asymmetricsUtils.js';
@@ -20,6 +20,7 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
+            supportsArrayContaining: 'arrayOnly',
             singleElementCompare: (element, values) => {
                 return compareElement(element, values, options);
             },
@@ -28,6 +29,9 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
             strictConfiguration: { allowArrayWithSingleElement: true }
         });
     }, isNot, { wait: options.wait, interval: options.interval });
+    if (isArrayContainingMatcher(expectedValue) && actualText === undefined) {
+        throw new Error('toHaveText with arrayContaining requires an array of elements');
+    }
     const expected = fillSingleExpectedForElementArray(subject, expectedValue);
     const message = enhanceError(subject, expected, actualText, { isNot, isSome }, verb, expectation, '', options);
     const result = {

package/lib/util/elementsUtil.js

@@ -1,11 +1,12 @@
+import { isArrayContainingMatcher } from '../utils.js';
 export const wrapExpectedWithArray = (elements, actual, expected) => {
-    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected)) {
+    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected) && !isArrayContainingMatcher(expected)) {
         expected = Array(actual.length).fill(expected);
     }
     return expected;
 };
 export const fillSingleExpectedForElementArray = (subject, value) => {
-    if (isElementArrayLike(subject) && !Array.isArray(value)) {
+    if (isElementArrayLike(subject) && !Array.isArray(value) && !isArrayContainingMatcher(value)) {
         const fillerlength = subject.length > 0 ? subject.length : 1;
         return Array(fillerlength).fill(value);
     }

package/lib/util/executeCommand.js

@@ -1,15 +1,44 @@
+import { equals } from '../jasmineUtils.js';
+import { isArrayContainingMatcher } from '../utils.js';
 import { isSomeWrapper } from '../matchers/modifiers/some.js';
 import { awaitElementOrArray, isElement, isStrictlyElementArray } from './elementsUtil.js';
 import { refreshElementArray } from './refetchElements.js';
-export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot, iteration }, strategy = 'NewStrictMultipleElements', strictConfiguration = { allowEmptyElements: false, allowArrayWithSingleElement: false } }) {
+export async function executeCommandWithStrategy({ unresolvedElements, expectedValues, singleElementCompare, context: { isNot, iteration }, strategy = 'NewStrictMultipleElements', supportsArrayContaining = false, strictConfiguration = { allowEmptyElements: false, allowArrayWithSingleElement: false } }) {
     const isSome = isSomeWrapper(unresolvedElements);
+    const actualReceived = isSome ? unresolvedElements.elements : unresolvedElements;
+    if (supportsArrayContaining && !isSome && isArrayContainingMatcher(expectedValues)) {
+        const { selector, elements, other } = await awaitElementOrArray(unresolvedElements);
+        if (elements) {
+            if (iteration > 0 && isStrictlyElementArray(elements)) {
+                await refreshElementArray(elements);
+            }
+            const settled = await Promise.allSettled(Array.from(elements).map(async (element, index) => {
+                return singleElementCompare(element, undefined, index);
+            }));
+            const actual = settled.map((result) => {
+                if (result.status === 'rejected') {
+                    throw result.reason;
+                }
+                return result.value.actual;
+            });
+            return {
+                subject: elements,
+                actual,
+                success: equals(actual, expectedValues),
+                abort: elements.length === 0 && !isStrictlyElementArray(elements),
+            };
+        }
+        if (!isElement(selector) || supportsArrayContaining === 'arrayOnly') {
+            return { subject: selector ?? other, actual: undefined, success: !!isNot, abort: true };
+        }
+        return { subject: selector, ...await singleElementCompare(selector, expectedValues) };
+    }
     if (strategy === 'LegacyLooseMultipleElements') {
         if (isSome) {
             throw new Error('some(elements) works only when enabling `useToHaveTextStrictMultiElementsCompareStrategy`');
         }
-        return legacyMultipleElementResultsStrategy(unresolvedElements, expectedValues, singleElementCompare, isNot);
+        return legacyMultipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, isNot);
     }
-    const actualReceived = isSome ? unresolvedElements.elements : unresolvedElements;
     return multipleElementResultsStrategy(actualReceived, expectedValues, singleElementCompare, { isNot, isSome, iteration }, strictConfiguration);
 }
 export const legacyMultipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, _isNot) => {

package/lib/util/formatMessage.js

@@ -56,10 +56,10 @@ export const enhanceError = (subject, expected, actual, context, verb, expectati
     };
     let diffString = '';
     if (isJasmineStringAsymmetricMatcher(expected)) {
-        expected = expected.jasmineToString();
+        expected = expected.jasmineToString(stringify);
     }
     else if (isElementOrArrayLike(subject) && Array.isArray(expected)) {
-        expected = expected.map(item => isJasmineStringAsymmetricMatcher(item) ? item.jasmineToString() : item);
+        expected = expected.map(item => isJasmineStringAsymmetricMatcher(item) ? item.jasmineToString(stringify) : item);
     }
     if (isNotInLabel && isElementOrArrayLike(subject) && Array.isArray(expected) && Array.isArray(actual) && expected.length === actual.length) {
         const { expectedFormatted, receivedFormatted } = printArrayWithMatchingItemInRed(expected, actual);

package/lib/utils.js

@@ -15,6 +15,19 @@ export function isAsymmetricMatcher(expected) {
         'asymmetricMatch' in expected &&
         !!expected.asymmetricMatch);
 }
+export function isArrayContainingMatcher(expected) {
+    if (!isAsymmetricMatcher(expected) || typeof expected.asymmetricMatch !== 'function') {
+        return false;
+    }
+    if (typeof expected.toString === 'function' && /^Array(Not)?Containing$/.test(expected.toString())) {
+        return true;
+    }
+    if ('jasmineToString' in expected && typeof expected.jasmineToString === 'function') {
+        const description = expected.jasmineToString(() => '');
+        return description === '<jasmine.arrayContaining()>';
+    }
+    return false;
+}
 export function isStringContainingMatcherLike(expected) {
     return !!expected && expected.constructor.name === 'StringContaining';
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "6.1.0-alpha.0",
+  "version": "6.1.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",

package/types/expect-webdriverio.d.ts

@@ -550,6 +550,7 @@ interface WdioElementOrArrayMatchers<_R, ActualT = unknown> {
      * // Check if an element array contains the specified text
      * const elem = await $$('ul > li')
      * await expect(elem).toHaveText(['Coffee', 'Tea', 'Milk'])
+     * await expect(elem).toHaveText(expect.arrayContaining(['Tea', 'Coffee']))
      * ```
      */
     toHaveText: FnWhenElementOrArrayLike<ActualT, {
@@ -853,7 +854,7 @@ type WdioOneOfAsymmetricMatcher<R> = ExpectWebdriverIO.PartialMatcher<R> & {
 }
 
 type JasmineBaseAsymmetricMatcher = {
-    jasmineToString(): string;
+    jasmineToString(pp?: (value: unknown) => string): string;
     asymmetricMatch(other: unknown): boolean;
 }