expect-webdriverio 6.1.0-alpha.0 → 7.0.0

package/lib/util/executeCommand.js

@@ -1,19 +1,74 @@
+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 { awaitElementOrArray, isElement, isMultiRemoteElement, isMultiRemoteElementArray, isMultiRemoteElementLike, isMultiRemoteElements, isMultiRemoteElementsLike, isStrictlyElementArray } from './elementsUtil.js';
+import { getElementsPerInstance, getPerInstanceValues, hasSameInstanceNames } from './multiRemoteUtils.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 (isMultiRemoteElementsLike(elements)) {
+            return multiRemoteArrayContainingStrategy(elements, expectedValues, singleElementCompare, iteration);
+        }
+        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);
 }
+const multiRemoteArrayContainingStrategy = async (elements, expectedValues, singleElementCompare, iteration) => {
+    const currentElements = iteration > 0 ? await refreshElementArray(elements) : elements;
+    const multiRemoteElements = currentElements;
+    if (multiRemoteElements.length === 0) {
+        return { subject: elements, actual: undefined, success: false, abort: !isMultiRemoteElementArray(elements) && !isMultiRemoteElements(elements) };
+    }
+    const { instances } = multiRemoteElements[0];
+    const elementsPerInstance = getElementsPerInstance(multiRemoteElements, instances);
+    const actual = Object.fromEntries(await Promise.all(instances.map(async (instance) => {
+        const results = await Promise.all(elementsPerInstance[instance].map((element, index) => singleElementCompare(element, undefined, index)));
+        return [instance, results.map((result) => result.actual)];
+    })));
+    return {
+        subject: elements,
+        actual,
+        success: instances.every((instance) => equals(actual[instance], expectedValues)),
+        expected: Object.fromEntries(instances.map((instance) => [instance, expectedValues])),
+    };
+};
 export const legacyMultipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, _isNot) => {
     const { selector, other, isEmptyElements } = await awaitElementOrArray(unresolvedElements);
+    if (isMultiRemoteElementLike(selector)) {
+        throw new Error('Multi-remote elements works only when enabling `useToHaveTextStrictMultiElementsCompareStrategy`');
+    }
     const subject = selector ?? other;
     if (!selector || isEmptyElements) {
         return {
@@ -42,29 +97,41 @@ export const legacyMultipleElementResultsStrategy = async (unresolvedElements, e
         actual: results.map(({ actual: value }) => value),
     };
 };
-export const multipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, { isNot, isSome, iteration }, { allowEmptyElements = false, allowArrayWithSingleElement = false } = {}) => {
-    const { selector, other } = await awaitElementOrArray(unresolvedElements);
-    if (iteration > 0 && isStrictlyElementArray(selector)) {
-        await refreshElementArray(selector);
+export const multipleElementResultsStrategy = async (unresolvedElements, expectedValues, singleElementCompare, { isNot, isSome, iteration }, { allowEmptyElements = false, allowArrayWithSingleElement = false, allowObjectExpectedValue = false } = {}) => {
+    const { selector, other, multiRemoteSelector } = await awaitElementOrArray(unresolvedElements);
+    const isRefetchable = isStrictlyElementArray(selector) || isMultiRemoteElementArray(selector) || isMultiRemoteElements(selector);
+    let currentElements = selector;
+    if (iteration > 0 && (isStrictlyElementArray(selector) || isMultiRemoteElementsLike(selector))) {
+        currentElements = await refreshElementArray(selector);
     }
-    const subject = selector ?? other;
-    if (!selector || (Array.isArray(selector) && selector.length === 0)) {
+    const subject = multiRemoteSelector ?? selector ?? other;
+    if (!currentElements || (Array.isArray(currentElements) && currentElements.length === 0)) {
         return {
             subject,
             success: isNot ? !allowEmptyElements : false,
             actual: undefined,
-            abort: !allowEmptyElements && !isStrictlyElementArray(selector),
+            abort: !allowEmptyElements && !isRefetchable,
             context: { isSome },
         };
     }
+    const isUnexpectedPerInstanceValues = !multiRemoteSelector && !isMultiRemoteElementsLike(selector)
+        && getPerInstanceValues(expectedValues, { allowObjectExpectedValue }) !== undefined;
     if (isElement(selector)) {
-        const forceFailure = !allowArrayWithSingleElement && Array.isArray(expectedValues);
+        const forceFailure = (!allowArrayWithSingleElement && Array.isArray(expectedValues)) || isUnexpectedPerInstanceValues;
         const compareResult = await singleElementCompare(selector, forceFailure ? undefined : expectedValues);
         const success = forceFailure ? !!isNot : compareResult.success;
         return { subject, success, actual: compareResult.actual, abort: forceFailure, context: { isSome } };
     }
-    const lengthMismatch = Array.isArray(expectedValues) && expectedValues.length !== selector.length;
-    const settled = await Promise.allSettled(Array.from(selector).map(async (element, index) => {
+    if (multiRemoteSelector || isMultiRemoteElementsLike(selector)) {
+        return multiRemoteElementsResultsStrategy(subject, multiRemoteSelector ?? selector, expectedValues, singleElementCompare, { isNot, isSome }, { allowArrayWithSingleElement, allowObjectExpectedValue });
+    }
+    const elementsSelector = selector;
+    const lengthMismatch = Array.isArray(expectedValues) && expectedValues.length !== elementsSelector.length;
+    if (isUnexpectedPerInstanceValues) {
+        const results = await Promise.all(Array.from(elementsSelector).map((element, index) => singleElementCompare(element, undefined, index)));
+        return { subject, success: !!isNot, abort: true, actual: results.map(({ actual }) => actual), context: { isSome } };
+    }
+    const settled = await Promise.allSettled(Array.from(elementsSelector).map(async (element, index) => {
         const indexedExpected = Array.isArray(expectedValues) ? expectedValues[index] : expectedValues;
         const forceElementFailure = Array.isArray(indexedExpected)
             || (lengthMismatch && Array.isArray(expectedValues) && index >= expectedValues.length);
@@ -76,19 +143,69 @@ export const multipleElementResultsStrategy = async (unresolvedElements, expecte
         throw firstRejection.reason;
     }
     const results = settled.map((r) => r.value);
-    if (Array.isArray(expectedValues) && expectedValues.length > selector.length) {
-        results.push(...Array(expectedValues.length - selector.length).fill({ success: false, actual: undefined }));
+    if (Array.isArray(expectedValues) && expectedValues.length > elementsSelector.length) {
+        results.push(...Array(expectedValues.length - elementsSelector.length).fill({ success: false, actual: undefined }));
     }
+    const actual = results.map(({ actual }) => actual);
     if (lengthMismatch) {
-        return { subject, success: !!isNot, actual: results.map(({ actual }) => actual), context: { isSome } };
+        return { subject, success: !!isNot, actual, context: { isSome } };
     }
-    const isNotEmpty = results.length > 0;
+    return { subject, success: computeSuccess([results], { isNot, isSome }), actual, context: { isSome } };
+};
+const multiRemoteElementsResultsStrategy = async (subject, multiRemoteSelector, expectedValues, singleElementCompare, { isNot, isSome }, { allowArrayWithSingleElement, allowObjectExpectedValue }) => {
+    const isSingleElement = isMultiRemoteElement(multiRemoteSelector);
+    const multiRemoteElements = isSingleElement ? [multiRemoteSelector] : multiRemoteSelector;
+    const { instances } = multiRemoteElements[0];
+    const elementsPerInstance = getElementsPerInstance(multiRemoteElements, instances);
+    const perInstanceValues = getPerInstanceValues(expectedValues, { allowObjectExpectedValue });
+    const expectedPerInstance = perInstanceValues ?? Object.fromEntries(instances.map((name) => [name, expectedValues]));
+    const instanceNamesMismatch = !!perInstanceValues && !hasSameInstanceNames(perInstanceValues, instances);
+    const unsupportedArray = isSingleElement && !allowArrayWithSingleElement && Object.values(expectedPerInstance).some(Array.isArray);
+    const lengthMismatch = !isSingleElement && instances.some((name) => {
+        const value = expectedPerInstance[name];
+        return Array.isArray(value) && value.length !== elementsPerInstance[name].length;
+    });
+    const actualPerInstance = {};
+    const resultsPerInstance = await Promise.all(instances.map(async (instance) => {
+        const isExpected = instance in expectedPerInstance;
+        const instanceValue = expectedPerInstance[instance];
+        const elements = elementsPerInstance[instance];
+        const results = await Promise.all(elements.map(async (element, index) => {
+            const indexedExpected = isSingleElement || !Array.isArray(instanceValue) ? instanceValue : instanceValue[index];
+            const forceElementFailure = !isExpected || unsupportedArray
+                || (!isSingleElement && Array.isArray(instanceValue) && (index >= instanceValue.length || Array.isArray(indexedExpected)));
+            const elementExpected = forceElementFailure ? undefined : indexedExpected;
+            const result = isSingleElement ? await singleElementCompare(element, elementExpected) : await singleElementCompare(element, elementExpected, index);
+            return forceElementFailure ? { success: false, actual: result.actual } : result;
+        }));
+        const actuals = results.map(({ actual }) => actual);
+        if (isSingleElement) {
+            actualPerInstance[instance] = actuals[0];
+        }
+        else {
+            const expectedLength = Array.isArray(instanceValue) ? instanceValue.length : 0;
+            actualPerInstance[instance] = [...actuals, ...Array(Math.max(expectedLength - actuals.length, 0)).fill(undefined)];
+        }
+        return results;
+    }));
+    const expected = isSingleElement ? expectedPerInstance : Object.fromEntries(Object.entries(expectedPerInstance).map(([name, value]) => {
+        const count = elementsPerInstance[name]?.length ?? 0;
+        return [name, Array.isArray(value) || isArrayContainingMatcher(value) ? value : Array(Math.max(count, 1)).fill(value)];
+    }));
+    if (instanceNamesMismatch || unsupportedArray) {
+        return { subject, success: !!isNot, abort: true, actual: actualPerInstance, context: { isSome }, expected };
+    }
+    if (lengthMismatch) {
+        return { subject, success: !!isNot, actual: actualPerInstance, context: { isSome }, expected };
+    }
+    return { subject, success: computeSuccess(resultsPerInstance, { isNot, isSome }), actual: actualPerInstance, context: { isSome }, expected };
+};
+const computeSuccess = (groups, { isNot, isSome }) => {
     const checkFn = isSome ? isAtLeastOneTrue : isAllTrue;
     const checkNotFn = isSome ? isAtLeastOneFalse : isAllFalse;
-    const success = isNot
-        ? !(isNotEmpty && checkNotFn(results))
-        : isNotEmpty && checkFn(results);
-    return { subject, success, actual: results.map(({ actual }) => actual), context: { isSome } };
+    const isNotEmpty = groups.length > 0 && groups.every((results) => results.length > 0);
+    const assertionPasses = isNotEmpty && groups.every((results) => isNot ? checkNotFn(results) : checkFn(results));
+    return isNot ? !assertionPasses : assertionPasses;
 };
 const isAllTrue = (results) => results.every((res) => res.success === true);
 const isAllFalse = (results) => results.every((res) => res.success === false);

package/lib/util/formatMessage.js

@@ -1,8 +1,9 @@
 import { printDiffOrStringify, printExpected, printReceived, RECEIVED_COLOR, EXPECTED_COLOR, INVERTED_COLOR, stringify } from 'jest-matcher-utils';
 import { equals } from '../jasmineUtils.js';
-import { isArrayOfElement, isElementArrayLike, isElementOrArrayLike, isStrictlyElementArray } from './elementsUtil.js';
+import { isArrayOfElement, isElementArrayLike, isElementOrArrayLike, isElementOrArrayOrMultiRemoteElementLike, isMultiRemoteElement, isMultiRemoteElementArray, isMultiRemoteElementLike, isMultiRemoteElementsLike, isStrictlyElementArray } from './elementsUtil.js';
 import { toJsonString } from './stringUtil.js';
 import { isJasmineStringAsymmetricMatcher, toArray } from '../utils.js';
+import { isBrowser } from './multiRemoteUtils.js';
 export const isDefined = (value) => value !== null && value !== undefined;
 export const getSelector = (el) => {
     let result = typeof el.selector === 'string' ? el.selector : '<fn>';
@@ -17,7 +18,17 @@ export const getSelectors = (el) => {
     }
     const selectors = [];
     let parent;
-    if (isStrictlyElementArray(el)) {
+    if (isMultiRemoteElement(el)) {
+        const subject = formatMultiRemoteInstanceNames(el.instances);
+        return `${subject}.$(\`${getSelector(el)}\`)`;
+    }
+    else if (isMultiRemoteElementsLike(el)) {
+        const instances = isMultiRemoteElementArray(el) ? el.parent.instances : el[0].instances ?? [];
+        const selector = isMultiRemoteElementArray(el) ? getSelector(el) : el[0] ? getSelector(el[0]) : '';
+        const subject = formatMultiRemoteInstanceNames(instances);
+        return `${subject}.$$(\`${selector}\`)`;
+    }
+    else if (isStrictlyElementArray(el)) {
         selectors.push(`${(el).foundWith}(\`${getSelector(el)}\`)`);
         parent = el.parent;
     }
@@ -38,7 +49,23 @@ export const getSelectors = (el) => {
 const not = (isNot) => `${isNot ? 'not ' : ''}`;
 export const enhanceError = (subject, expected, actual, context, verb, expectation, expectedValueArgument2 = '', { message = '', containing = false } = {}) => {
     const { isNot, useNotInLabel = true } = context;
-    let subjectStr = (isElementOrArrayLike(subject) ? getSelectors(subject) : toJsonString(subject));
+    if ((isBrowser(subject) && subject.isMultiremote) || isMultiRemoteElementLike(subject)) {
+        expected = labelMultiRemoteValues(expected);
+        actual = labelMultiRemoteValues(actual);
+    }
+    if (isBrowser(subject)) {
+        if (subject.isMultiremote) {
+            subject = formatMultiRemoteInstanceNames(subject.instances);
+        }
+        else if (subject.isMobile) {
+            subject = context.browserTargetType === 'window' ? 'mobile screen' : 'mobile';
+        }
+        else {
+            const prefix = subject.requestedCapabilities?.browserName ?? 'browser';
+            subject = context.browserTargetType === 'window' ? `${prefix}'s window` : prefix;
+        }
+    }
+    let subjectStr = (isElementOrArrayOrMultiRemoteElementLike(subject) ? getSelectors(subject) : toJsonString(subject));
     if (subjectStr.length > 100) {
         subjectStr = `${subjectStr.substring(0, 100)}...`;
     }
@@ -56,10 +83,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);
@@ -114,15 +141,47 @@ const printArrayWithMatchingItemInRed = (expectedArray, actualArray) => {
         .join(', ')}]`;
     return { expectedFormatted, receivedFormatted };
 };
-export const enhanceErrorBe = (subject, results, context, options) => {
+export const enhanceErrorBe = (subject, actuals, context, options) => {
     const { isNot, verb, expectation } = context;
     let expected;
     let actual;
     const expectedValue = `${not(isNot)}${expectation}`;
     const actualValue = `${not(!isNot)}${expectation}`;
-    if (isElementArrayLike(subject)) {
+    if (isMultiRemoteElementLike(subject)) {
+        if (isMultiRemoteElement(subject)) {
+            const typedActuals = actuals;
+            actual = subject.instances.reduce((acc, instance) => {
+                acc[instance] = isSuccess(isNot, typedActuals[instance]) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`;
+                return acc;
+            }, {});
+            expected = subject.instances.reduce((acc, instance) => {
+                acc[instance] = expectedValue;
+                return acc;
+            }, {});
+        }
+        else if (isMultiRemoteElementsLike(subject) && subject.length === 0) {
+            expected = 'at least one result';
+            actual = actualValue;
+        }
+        else if (isMultiRemoteElementsLike(subject)) {
+            const { instances } = subject[0];
+            const typedActuals = actuals;
+            actual = instances.reduce((acc, instance) => {
+                acc[instance] = typedActuals[instance].map(actual => isSuccess(isNot, actual) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
+                return acc;
+            }, {});
+            expected = instances.reduce((acc, instance) => {
+                acc[instance] = Array(typedActuals[instance].length).fill(expectedValue);
+                return acc;
+            }, {});
+        }
+        else {
+            throw new Error('Unsupported Multi-remote object type for enhanceErrorBe');
+        }
+    }
+    else if (isElementArrayLike(subject)) {
         expected = subject.length === 0 ? 'at least one result' : Array(subject.length).fill(expectedValue);
-        actual = toArray(results).map(result => isSuccess(isNot, result) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
+        actual = toArray(actuals).map(actual => isSuccess(isNot, actual) ? `${not(isNot)}${expectation}` : `${not(!isNot)}${expectation}`);
     }
     else {
         expected = expectedValue;
@@ -133,3 +192,18 @@ export const enhanceErrorBe = (subject, results, context, options) => {
 const isSuccess = (isNot, success) => {
     return isNot ? !success : success;
 };
+class MultiRemoteValuesLabel {
+}
+Object.defineProperty(MultiRemoteValuesLabel, 'name', { value: 'Multi-remote values' });
+export const labelMultiRemoteValues = (value) => {
+    const isPlainObject = typeof value === 'object' && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+    return isPlainObject ? Object.assign(new MultiRemoteValuesLabel(), value) : value;
+};
+export const formatMultiRemoteMocks = ({ names, isNamedByInstance }) => {
+    return isNamedByInstance ? `${formatMultiRemoteInstanceNames(names)} mocks` : 'mocks';
+};
+const formatMultiRemoteInstanceNames = (instances) => {
+    let instanceNames = instances.join(', ');
+    instanceNames = instanceNames.length > 50 ? `${instanceNames.substring(0, 50)}...` : instanceNames;
+    return `multi-remote<${instanceNames}>`;
+};

package/lib/util/multiRemoteUtils.js

@@ -0,0 +1,85 @@
+import { isAsymmetricMatcher } from '../utils.js';
+export const isMultiRemoteValues = (value, existingInstanceNames) => {
+    if (value && typeof value === 'object' && !Array.isArray(value) && !isAsymmetricMatcher(value) && !(value instanceof RegExp) && Object.keys(value).length > 0) {
+        if (existingInstanceNames) {
+            return existingInstanceNames?.some(name => Object.keys(value).includes(name));
+        }
+        return true;
+    }
+    return false;
+};
+export const hasSameInstanceNames = (expected, instances) => {
+    const names = Object.keys(expected);
+    return names.length === instances.length && instances.every((name) => names.includes(name));
+};
+export const MULTI_REMOTE_MATCHER_SYMBOL = Symbol.for('expect-webdriverio.multiRemote');
+export const isMultiRemoteMatcher = (value) => {
+    return !!value && typeof value === 'object' && value[MULTI_REMOTE_MATCHER_SYMBOL] === true;
+};
+export const getPerInstanceValues = (value, { allowObjectExpectedValue = false } = {}) => {
+    if (isMultiRemoteMatcher(value)) {
+        return value.sample;
+    }
+    return !allowObjectExpectedValue && isMultiRemoteValues(value) ? value : undefined;
+};
+export const getElementsPerInstance = (multiRemoteElements, instances) => {
+    return Object.fromEntries(instances.map((name) => {
+        const elements = [];
+        for (let index = 0; index < multiRemoteElements.length; index++) {
+            const element = getInstanceOrUndefined(multiRemoteElements[index], name);
+            if (element) {
+                elements.push(element);
+            }
+        }
+        return [name, elements];
+    }));
+};
+const getInstanceOrUndefined = (element, name) => {
+    try {
+        return element.getInstance(name) || undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const getGlobalMultiRemoteInstanceNames = () => {
+    try {
+        const instances = typeof multiRemoteBrowser === 'undefined' ? undefined : multiRemoteBrowser.instances;
+        return Array.isArray(instances) ? instances : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const isMock = (obj) => {
+    return typeof obj === 'object' && obj !== null && Array.isArray(obj.calls);
+};
+export const isMockArray = (obj) => {
+    return Array.isArray(obj) && obj.length > 0 && obj.every(isMock);
+};
+export const awaitMocks = async (received) => {
+    const mocks = received instanceof Promise ? await received : received;
+    if (Array.isArray(mocks) && mocks.length === 0) {
+        throw new Error('Expected a mock or a non-empty array of mocks, received an empty array');
+    }
+    return mocks;
+};
+export const getMockInstanceNames = (mocks) => {
+    const instances = getGlobalMultiRemoteInstanceNames();
+    if (instances && instances.length === mocks.length) {
+        return { names: instances, isNamedByInstance: true };
+    }
+    return { names: mocks.map((_, index) => `mocks[${index}]`), isNamedByInstance: false };
+};
+export const isGlobalBrowserSingleRemote = () => {
+    try {
+        return typeof browser !== 'undefined' && isBrowser(browser) && !browser.isMultiremote;
+    }
+    catch {
+        return false;
+    }
+};
+export const isBrowser = (obj) => {
+    const name = obj?.constructor?.name?.replace(/^bound /, '');
+    return name === 'Browser' || !!name?.endsWith('MultiRemoteDriver');
+};

package/lib/util/numberOptionsUtil.js

@@ -1,5 +1,6 @@
 import { AsymmetricMatcher } from 'expect';
 import { isDefinedPlainObject } from './commandOptionsUtils.js';
+import { isMultiRemoteMatcher } from './multiRemoteUtils.js';
 export const isNumber = (value) => typeof value === 'number' && !isNaN(value);
 export const isDefinedNotNumber = (value) => value !== undefined && !isNumber(value);
 export const isDefinedNumberOrNonEmptyObject = (value) => typeof value === 'number' || (typeof value === 'object' && value !== null && !Array.isArray(value) && Object.keys(value).length > 0);
@@ -25,6 +26,11 @@ export function validateNumberAndExtractOptions(expectedValue, commandOptions, {
     };
 }
 export function validateNumberArrayAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 } = {}) {
+    if (isMultiRemoteMatcher(expectedValues)) {
+        const perInstanceValues = expectedValues.sample;
+        const numberMatcher = Object.fromEntries(Object.entries(perInstanceValues).map(([instance, value]) => [instance, validateNumberArrayAndExtractOptions(value, commandOptions).numberMatcher]));
+        return { numberMatcher, commandOptions };
+    }
     if (Array.isArray(expectedValues)) {
         const allNumbers = expectedValues.map((value) => validateNumberAndExtractOptions(value, commandOptions, { supportDefaultAsGteThen1 }));
         return { numberMatcher: allNumbers.map(({ numberMatcher }) => numberMatcher), commandOptions };

package/lib/util/refetchElements.js

@@ -1,14 +1,32 @@
-import { isStrictlyElementArray } from './elementsUtil.js';
+import { isMultiRemoteElementArray, isMultiRemoteElements, isStrictlyElementArray } from './elementsUtil.js';
 export const refetchElements = async (elements) => {
     if (elements
-        && isStrictlyElementArray(elements)
+        && (isStrictlyElementArray(elements) || isMultiRemoteElementArray(elements))
         && elements.parent && elements.foundWith && elements.foundWith in elements.parent) {
         const browser = elements.parent;
         const $$ = browser[elements.foundWith];
         return await $$.call(browser, elements.selector, ...elements.props);
     }
+    else if (isMultiRemoteElements(elements)) {
+        const selector = elements.find((element) => !!element.selector)?.selector;
+        if (selector) {
+            warnMultiRemoteRefetchFallbackOnce();
+            if (typeof multiRemoteBrowser === 'undefined') {
+                return elements;
+            }
+            return await multiRemoteBrowser.$$(selector);
+        }
+    }
     return elements;
 };
+let hasWarnedMultiRemoteRefetchFallback = false;
+const warnMultiRemoteRefetchFallbackOnce = () => {
+    if (hasWarnedMultiRemoteRefetchFallback) {
+        return;
+    }
+    hasWarnedMultiRemoteRefetchFallback = true;
+    console.warn('expect-webdriverio: refetching multi-remote elements between retries is best effort: they are re-queried from the global `multiRemoteBrowser`, ignoring any parent element or `select()` scope. Set `WDIO_ENABLE_MULTI_REMOTE_ELEMENT_ARRAY=true` for reliable retries.');
+};
 export const syncronizeElements = async (subject, refetchedElements) => {
     if (subject instanceof Promise) {
         await syncronizeChainableElementArray(subject, refetchedElements);
@@ -31,5 +49,9 @@ export const synchronizeElementArray = (subject, refetchedElements) => {
 };
 export const refreshElementArray = async (subject) => {
     const refetchedElements = await refetchElements(subject);
+    if (refetchedElements.length === 0 && isMultiRemoteElements(subject)) {
+        return refetchedElements;
+    }
     synchronizeElementArray(subject, refetchedElements);
+    return subject;
 };

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';
 }
@@ -89,7 +102,7 @@ const compareNumbers = (actual, options = {}) => {
     }
     return false;
 };
-export const compareTextOrArray = (actualText, expectedTexts, options) => {
+export const compareTextOrOneOf = (actualText, expectedTexts, options) => {
     if (expectedTexts === undefined) {
         return { actual: actualText, success: false };
     }
@@ -106,7 +119,7 @@ export const compareTextOrArray = (actualText, expectedTexts, options) => {
         return { success: expectedTexts.asymmetricMatch(actualText), actual: actualText };
     }
     const compareResults = compareText(actualText, expectedTexts, options);
-    return { success: compareResults.success, actual: actualText };
+    return { ...compareResults, actual: actualText };
 };
 export const compareText = (actual, expected, { ignoreCase = false, trim = true, containing = false, atStart = false, atEnd = false, atIndex, replace, }) => {
     if (typeof actual !== 'string' || expected === null || expected === undefined) {
@@ -276,6 +289,11 @@ export const compareStyle = async (actualEl, style, { ignoreCase = false, trim =
         const css = await actualEl.getCSSProperty(key);
         let actualVal = String(css.value || '');
         let expectedVal = style[key];
+        if (typeof expectedVal !== 'string') {
+            actual[key] = css.value;
+            success = false;
+            continue;
+        }
         if (trim) {
             actualVal = actualVal.trim();
             expectedVal = expectedVal.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "6.1.0-alpha.0",
+  "version": "7.0.0",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -114,9 +114,9 @@
     "webdriverio": "^9.32.0"
   },
   "peerDependencies": {
-    "@wdio/globals": "^9.0.0",
+    "@wdio/globals": "^9.23.0",
     "@wdio/logger": "^9.0.0",
-    "webdriverio": "^9.28.0"
+    "webdriverio": "^9.31.5"
   },
   "peerDependenciesMeta": {
     "@wdio/globals": {