expect-webdriverio 6.1.0 → 7.0.0

package/lib/matchers/element/toHaveText.js

@@ -1,11 +1,11 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareTextOrArray, enhanceError, getFeatureFlagValue, isArrayContainingMatcher, waitUntil, } from '../../utils.js';
+import { compareTextOrOneOf, 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';
 async function compareElement(el, expectedText, options) {
     const actualText = await el.getText();
-    return compareTextOrArray(actualText, expectedText, options);
+    return compareTextOrOneOf(actualText, expectedText, options);
 }
 export async function toHaveText(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'text', verb = 'have', isNot, matcherName = 'toHaveText' } = this;
@@ -16,7 +16,7 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
     });
     expectedValue = buildWdioAsymmetricMatchersWithOptions(expectedValue, options);
     const isNewStrictCompare = getFeatureFlagValue(options, 'useToHaveTextStrictMultiElementsCompareStrategy');
-    const { success: pass, actual: actualText, subject: subject, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualText, subject: subject, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedValue,
@@ -32,8 +32,8 @@ export async function toHaveText(received, expectedValue, options = DEFAULT_OPTI
     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 finalExpected = expected ?? fillSingleExpectedForElementArray(subject, expectedValue);
+    const message = enhanceError(subject, finalExpected, actualText, { isNot, isSome }, verb, expectation, '', options);
     const result = {
         pass,
         message: () => message

package/lib/matchers/element/toHaveValue.js

@@ -1,5 +1,5 @@
 import { toHaveElementProperty } from './toHaveElementProperty.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 export function toHaveValue(el, value, options = DEFAULT_OPTIONS) {
-    return toHaveElementProperty.call(this, el, 'value', value, options);
+    return toHaveElementProperty.call({ ...this, allowObjectExpectedValue: false }, el, 'value', value, options);
 }

package/lib/matchers/element/toHaveWidth.js

@@ -18,7 +18,7 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
         options,
     });
     const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
-    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {}, expected } = await waitUntil(async (iteration) => {
         return await executeCommandWithStrategy({
             unresolvedElements: received,
             expectedValues: expectedNumber,
@@ -28,7 +28,7 @@ export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPT
             strictConfiguration: { allowArrayWithSingleElement: false }
         });
     }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
-    const expectedValues = wrapExpectedWithArray(elements, actualWidth, expectedNumber);
+    const expectedValues = expected ?? wrapExpectedWithArray(elements, actualWidth, expectedNumber);
     const message = enhanceError(elements, expectedValues, actualWidth, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,8 +1,9 @@
 import { waitUntil, enhanceError, } from '../../utils.js';
-import { refetchElements, syncronizeElements } from '../../util/refetchElements.js';
+import { refetchElements, synchronizeElementArray, syncronizeElements } from '../../util/refetchElements.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
-import { awaitElementArray, isStrictlyElementArray } from '../../util/elementsUtil.js';
+import { awaitElementArray, isMultiRemoteElementArray, isMultiRemoteElements, isMultiRemoteElementsLike, isStrictlyElementArray } from '../../util/elementsUtil.js';
+import { getElementsPerInstance, getGlobalMultiRemoteInstanceNames, hasSameInstanceNames, isGlobalBrowserSingleRemote, isMultiRemoteMatcher } from '../../util/multiRemoteUtils.js';
 export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { expectation = 'elements array of size', verb = 'be', isNot, matcherName = 'toBeElementsArrayOfSize' } = this;
     await options.beforeAssertion?.({
@@ -10,8 +11,17 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
         expectedValue,
         options,
     });
-    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
     let { elements, other } = await awaitElementArray(received);
+    const awaitedMultiRemote = other ?? elements;
+    const isEmptyWithPerInstanceSizes = Array.isArray(awaitedMultiRemote) && awaitedMultiRemote.length === 0
+        && !isStrictlyElementArray(awaitedMultiRemote) && !isGlobalBrowserSingleRemote()
+        && getPerInstanceSizes(expectedValue) !== undefined;
+    if (isMultiRemoteElementsLike(awaitedMultiRemote) || isEmptyWithPerInstanceSizes) {
+        const result = await multiRemoteElementsArrayOfSize(awaitedMultiRemote, expectedValue, options, { context: this, verb, expectation });
+        await options.afterAssertion?.({ matcherName, expectedValue, options, result });
+        return result;
+    }
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
     const originalLength = elements ? elements.length : undefined;
     const { success: pass } = await waitUntil(async (iteration) => {
         if (!elements) {
@@ -43,3 +53,60 @@ export async function toBeElementsArrayOfSize(received, expectedValue, options =
     });
     return result;
 }
+const multiRemoteElementsArrayOfSize = async (received, expectedValue, options, { context, verb, expectation }) => {
+    const { isNot } = context;
+    const perInstanceSizes = getPerInstanceSizes(expectedValue);
+    const instances = getMultiRemoteInstanceNames(received)
+        ?? getGlobalMultiRemoteInstanceNames()
+        ?? (perInstanceSizes ? Object.keys(perInstanceSizes) : []);
+    let commandOptions = options;
+    let expected;
+    let instanceMismatch = false;
+    if (perInstanceSizes) {
+        instanceMismatch = !hasSameInstanceNames(perInstanceSizes, instances);
+        expected = Object.fromEntries(Object.entries(perInstanceSizes).map(([name, value]) => [name, validateNumberAndExtractOptions(value, options).numberMatcher]));
+    }
+    else {
+        const validated = validateNumberAndExtractOptions(expectedValue, options);
+        commandOptions = validated.commandOptions;
+        expected = Object.fromEntries(instances.map((name) => [name, validated.numberMatcher]));
+    }
+    let refetchSource = received;
+    let elements = received;
+    let actual = countElementsPerInstance(elements, instances);
+    const { success: pass } = await waitUntil(async (iteration) => {
+        if (iteration > 0) {
+            elements = await refetchElements(refetchSource);
+            if (elements.length > 0 || !isMultiRemoteElements(refetchSource)) {
+                refetchSource = elements;
+            }
+            actual = countElementsPerInstance(elements, instances);
+        }
+        if (instanceMismatch) {
+            return { success: !!isNot, subject: refetchSource, actual, abort: true };
+        }
+        const matches = (name) => expected[name].asymmetricMatch(actual[name]);
+        const success = isNot ? instances.some(matches) : instances.every(matches);
+        return { success, subject: refetchSource, actual };
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    if (pass && elements !== received) {
+        synchronizeElementArray(received, elements);
+    }
+    const message = enhanceError(refetchSource, expected, actual, { isNot }, verb, expectation, '', commandOptions);
+    return { pass, message: () => message };
+};
+const getPerInstanceSizes = (value) => {
+    return isMultiRemoteMatcher(value) ? value.sample : undefined;
+};
+const getMultiRemoteInstanceNames = (elements) => {
+    const first = elements[0];
+    if (first) {
+        return first.instances;
+    }
+    const parent = isMultiRemoteElementArray(elements) ? elements.parent : undefined;
+    return parent?.instances;
+};
+const countElementsPerInstance = (elements, instances) => {
+    const elementsPerInstance = getElementsPerInstance(elements, instances);
+    return Object.fromEntries(instances.map((name) => [name, elementsPerInstance[name].length]));
+};

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,6 +1,8 @@
 import { waitUntil, enhanceError } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
 import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { awaitMocks, getMockInstanceNames, isMockArray } from '../../util/multiRemoteUtils.js';
+import { formatMultiRemoteMocks, labelMultiRemoteValues } from '../../util/formatMessage.js';
 export async function toBeRequestedTimes(received, expectedValue, options = DEFAULT_OPTIONS) {
     const { verb = 'be', isNot, matcherName = 'toBeRequestedTimes', expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, } = this;
     await options.beforeAssertion?.({
@@ -9,11 +11,32 @@ export async function toBeRequestedTimes(received, expectedValue, options = DEFA
         options,
     });
     const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
-    const { success: pass, actual } = await waitUntil(async () => {
-        const actual = received.calls.length;
-        return { success: expectedNumber.asymmetricMatch(actual), subject: received, actual };
-    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
-    const message = enhanceError('mock', expectedNumber, actual, this, verb, expectation, '', commandOptions);
+    const mocks = await awaitMocks(received);
+    let message;
+    let pass;
+    if (isMockArray(mocks)) {
+        const instanceNames = getMockInstanceNames(mocks);
+        const { names } = instanceNames;
+        const label = (value) => instanceNames.isNamedByInstance ? labelMultiRemoteValues(value) : value;
+        const result = await waitUntil(async () => {
+            const actual = Object.fromEntries(mocks.map((mock, index) => [names[index], mock.calls.length]));
+            const matches = (name) => expectedNumber.asymmetricMatch(actual[name]);
+            const success = isNot ? names.some(matches) : names.every(matches);
+            return { success, subject: mocks, actual };
+        }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+        pass = result.success;
+        const expected = Object.fromEntries(names.map((name) => [name, expectedNumber]));
+        message = enhanceError(formatMultiRemoteMocks(instanceNames), label(expected), label(result.actual), this, verb, expectation, '', commandOptions);
+    }
+    else {
+        const mock = mocks;
+        const result = await waitUntil(async () => {
+            const actual = mock.calls.length;
+            return { success: expectedNumber.asymmetricMatch(actual), subject: mock, actual };
+        }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+        pass = result.success;
+        message = enhanceError('mock', expectedNumber, result.actual, this, verb, expectation, '', commandOptions);
+    }
     const result = {
         pass,
         message: () => message

package/lib/matchers/mock/toBeRequestedWith.js

@@ -1,6 +1,8 @@
 import { waitUntil, enhanceError, isAsymmetricMatcher, getAsymmetricMatcherValue } from '../../utils.js';
 import { equals } from '../../jasmineUtils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { awaitMocks, getMockInstanceNames, isMockArray } from '../../util/multiRemoteUtils.js';
+import { formatMultiRemoteMocks, labelMultiRemoteValues } from '../../util/formatMessage.js';
 const STR_LIMIT = 80;
 const KEY_LIMIT = 12;
 function reduceHeaders(headers) {
@@ -16,9 +18,42 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
         expectedValue,
         options,
     });
+    const parseCache = new Map();
+    const mocks = await awaitMocks(received);
+    let pass;
+    let message;
+    if (isMockArray(mocks)) {
+        const instanceNames = getMockInstanceNames(mocks);
+        const { names } = instanceNames;
+        const label = (value) => instanceNames.isNamedByInstance ? labelMultiRemoteValues(value) : value;
+        const results = await Promise.all(mocks.map((mock) => checkRequestedWith(mock, expectedValue, options, !!isNot, parseCache)));
+        pass = isNot ? results.some((result) => result.pass) : results.every((result) => result.pass);
+        const expected = Object.fromEntries(names.map((name) => [name, minifyRequestedWith(expectedValue)]));
+        const actual = Object.fromEntries(results.map((result, index) => [names[index], result.actual]));
+        const payloadNeverCollected = results.some((result) => !result.pass && result.payloadNeverCollected);
+        message = enhanceError(formatMultiRemoteMocks(instanceNames), label(expected), label(actual), this, verb, expectation, '', options)
+            + (!pass && !isNot && payloadNeverCollected ? payloadCollectionHint(expectedValue) : '');
+    }
+    else {
+        const result = await checkRequestedWith(mocks, expectedValue, options, !!isNot, parseCache);
+        pass = result.pass;
+        message = enhanceError('mock', minifyRequestedWith(expectedValue), result.actual, this, verb, expectation, '', options) + (!pass && !isNot && result.payloadNeverCollected ? payloadCollectionHint(expectedValue) : '');
+    }
+    const result = {
+        pass,
+        message: () => message
+    };
+    await options.afterAssertion?.({
+        matcherName,
+        expectedValue,
+        options,
+        result
+    });
+    return result;
+}
+const checkRequestedWith = async (received, expectedValue, options, isNot, parseCache) => {
     const hasPayloadExpectation = expectedValue.postData !== undefined || expectedValue.response !== undefined;
     const waitForPayloadOnNot = isNot && hasPayloadExpectation;
-    const parseCache = new Map();
     let payloadNeverCollected = false;
     const { success: pass, actual } = await waitUntil(async () => {
         let lastCall;
@@ -50,19 +85,12 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
             abort: waitForPayloadOnNot && !hasPendingPayloadCandidate,
         };
     }, waitForPayloadOnNot ? false : isNot, { ...options, wait: (isNot && !waitForPayloadOnNot) ? 0 : options.wait });
-    const message = enhanceError('mock', minifyRequestedWith(expectedValue), minifyRequestMock(actual, expectedValue, parseCache) || 'was not called', this, verb, expectation, '', options) + (!pass && !isNot && payloadNeverCollected ? payloadCollectionHint(expectedValue) : '');
-    const result = {
+    return {
         pass,
-        message: () => message
+        actual: minifyRequestMock(actual, expectedValue, parseCache) || 'was not called',
+        payloadNeverCollected,
     };
-    await options.afterAssertion?.({
-        matcherName,
-        expectedValue,
-        options,
-        result
-    });
-    return result;
-}
+};
 const payloadCollectionHint = (expectedValue) => {
     const fields = [
         expectedValue.postData !== undefined ? 'postData' : undefined,

package/lib/matchers/snapshot.js

@@ -2,6 +2,8 @@ import path from 'node:path';
 import { expect } from 'expect';
 import { stripSnapshotIndentation } from '@vitest/snapshot';
 import { SnapshotService } from '../snapshot.js';
+import { awaitElementOrArray, isElementOrArrayOrMultiRemoteElementLike, isMultiRemoteElement, isMultiRemoteElementArray, isMultiRemoteElementsLike, isStrictlyElementArray } from '../util/elementsUtil.js';
+import { getElementsPerInstance } from '../util/multiRemoteUtils.js';
 function returnSnapshotError(snapshotError) {
     try {
         expect(snapshotError.actual).toBe(snapshotError.expected);
@@ -38,12 +40,41 @@ function toMatchSnapshotAssert(received, message, inlineOptions) {
         return returnSnapshotError(e);
     }
 }
+const isElementsToSnapshot = (received) => {
+    const isEmptyPlainArray = Array.isArray(received) && received.length === 0 && !isStrictlyElementArray(received) && !isMultiRemoteElementArray(received);
+    return isElementOrArrayOrMultiRemoteElementLike(received) && !isEmptyPlainArray;
+};
+const getOuterHTML = (element) => element.getHTML({ includeSelectorTag: true });
+const getMultiRemoteOuterHTML = async (multiRemoteElements) => {
+    const isSingleElement = isMultiRemoteElement(multiRemoteElements);
+    if (!isSingleElement && multiRemoteElements.length === 0) {
+        return [];
+    }
+    const instances = [...(isSingleElement ? multiRemoteElements : multiRemoteElements[0]).instances].sort();
+    const elementsPerInstance = isSingleElement ? undefined : getElementsPerInstance(multiRemoteElements, instances);
+    const htmlPerInstance = Object.fromEntries(await Promise.all(instances.map(async (instance) => [
+        instance,
+        elementsPerInstance
+            ? await Promise.all(elementsPerInstance[instance].map(getOuterHTML))
+            : await getOuterHTML(multiRemoteElements.getInstance(instance))
+    ])));
+    const htmls = Object.values(htmlPerInstance);
+    return htmls.every((html) => JSON.stringify(html) === JSON.stringify(htmls[0])) ? htmls[0] : htmlPerInstance;
+};
 async function toMatchSnapshotAsync(asyncReceived, message, inlineOptions) {
-    let received = await asyncReceived;
-    if (received && typeof received === 'object' && 'elementId' in received) {
-        received = await received.getHTML({
-            includeSelectorTag: true
-        });
+    const { element, elements, multiRemoteSelector, other } = await awaitElementOrArray(await asyncReceived);
+    let received = other;
+    if (multiRemoteSelector) {
+        received = await getMultiRemoteOuterHTML(multiRemoteSelector);
+    }
+    else if (elements && isMultiRemoteElementsLike(elements)) {
+        received = await getMultiRemoteOuterHTML(elements);
+    }
+    else if (elements) {
+        received = await Promise.all(Array.from(elements).map(getOuterHTML));
+    }
+    else if (element) {
+        received = await getOuterHTML(element);
     }
     return toMatchSnapshotAssert(received, message, inlineOptions);
 }
@@ -53,8 +84,8 @@ function toMatchSnapshotHelper(received, message, inlineOptions) {
         throw new Error('Snapshot service is not initialized');
     }
     if (received && typeof received === 'object' &&
-        ('elementId' in received ||
-            'then' in received)) {
+        ('then' in received ||
+            isElementsToSnapshot(received))) {
         return toMatchSnapshotAsync(received, message, inlineOptions);
     }
     return toMatchSnapshotAssert(received, message, inlineOptions);

package/lib/tsconfig.build.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/softAssert.ts","../src/softAssertService.ts","../src/softExpect.ts","../src/types.ts","../src/utils.ts","../src/api/index.ts","../src/matchers/snapshot.ts","../src/matchers/asymmetrics/asymmetricsUtils.ts","../src/matchers/asymmetrics/oneOf.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveLocalStorageItem.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementClass.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/matchers/modifiers/some.ts","../src/util/commandOptionsUtils.ts","../src/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/globalSingleton.ts","../src/util/numberOptionsUtil.ts","../src/util/refetchElements.ts","../src/util/stringUtil.ts","../src/util/waitUntil.ts"],"version":"5.9.3"}
+{"root":["../src/constants.ts","../src/index.ts","../src/jasmineUtils.ts","../src/matchers.ts","../src/snapshot.ts","../src/softAssert.ts","../src/softAssertService.ts","../src/softExpect.ts","../src/types.ts","../src/utils.ts","../src/api/index.ts","../src/matchers/snapshot.ts","../src/matchers/asymmetrics/asymmetricsUtils.ts","../src/matchers/asymmetrics/multiRemote.ts","../src/matchers/asymmetrics/oneOf.ts","../src/matchers/browser/toHaveClipboardText.ts","../src/matchers/browser/toHaveLocalStorageItem.ts","../src/matchers/browser/toHaveTitle.ts","../src/matchers/browser/toHaveUrl.ts","../src/matchers/element/toBeClickable.ts","../src/matchers/element/toBeDisabled.ts","../src/matchers/element/toBeDisplayed.ts","../src/matchers/element/toBeDisplayedInViewport.ts","../src/matchers/element/toBeEnabled.ts","../src/matchers/element/toBeExisting.ts","../src/matchers/element/toBeFocused.ts","../src/matchers/element/toBeSelected.ts","../src/matchers/element/toHaveAttribute.ts","../src/matchers/element/toHaveChildren.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.ts","../src/matchers/element/toHaveElementClass.ts","../src/matchers/element/toHaveElementProperty.ts","../src/matchers/element/toHaveHTML.ts","../src/matchers/element/toHaveHeight.ts","../src/matchers/element/toHaveHref.ts","../src/matchers/element/toHaveId.ts","../src/matchers/element/toHaveSize.ts","../src/matchers/element/toHaveStyle.ts","../src/matchers/element/toHaveText.ts","../src/matchers/element/toHaveValue.ts","../src/matchers/element/toHaveWidth.ts","../src/matchers/elements/toBeElementsArrayOfSize.ts","../src/matchers/mock/toBeRequested.ts","../src/matchers/mock/toBeRequestedTimes.ts","../src/matchers/mock/toBeRequestedWith.ts","../src/matchers/modifiers/some.ts","../src/util/commandOptionsUtils.ts","../src/util/elementsUtil.ts","../src/util/executeBrowserCommand.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/globalSingleton.ts","../src/util/multiRemoteUtils.ts","../src/util/numberOptionsUtil.ts","../src/util/refetchElements.ts","../src/util/stringUtil.ts","../src/util/waitUntil.ts"],"version":"5.9.3"}

package/lib/util/elementsUtil.js

@@ -22,27 +22,33 @@ const isSelector = (obj) => {
 };
 export const isElementArray = (obj) => {
     return isSelector(obj)
-        && 'foundWith' in obj;
+        && 'foundWith' in obj
+        && !isMultiRemote(obj);
 };
 export const isStrictlyElementArray = (obj) => {
     return isElementArray(obj)
         && Array.isArray(obj)
-        && 'getElements' in obj;
+        && 'getElements' in obj
+        && !isMultiRemote(obj);
 };
 export const isElement = (obj) => {
     return isSelector(obj)
         && !Array.isArray(obj)
-        && 'getElement' in obj;
+        && 'getElement' in obj
+        && !isMultiRemote(obj);
 };
 export const isElementArrayLike = (obj) => {
-    return !!obj && (isStrictlyElementArray(obj) || (Array.isArray(obj) && obj.every(isElement)));
+    return !!obj && (isStrictlyElementArray(obj) || (Array.isArray(obj) && Array.prototype.every.call(obj, isElement)));
 };
 export const isArrayOfElement = (obj) => {
-    return Array.isArray(obj) && obj.every(isElement);
+    return Array.isArray(obj) && !isMultiRemote(obj) && Array.prototype.every.call(obj, isElement);
 };
 export const isElementOrArrayLike = (obj) => {
     return !!obj && (isElement(obj) || isElementArrayLike(obj));
 };
+export const isElementOrArrayOrMultiRemoteElementLike = (obj) => {
+    return !!obj && (isElement(obj) || isElementArrayLike(obj) || isMultiRemoteElementLike(obj));
+};
 export const awaitElementOrArray = async (received) => {
     if (!received || typeof received !== 'object') {
         return { other: received };
@@ -51,9 +57,12 @@ export const awaitElementOrArray = async (received) => {
     if (awaitedElements instanceof Promise) {
         awaitedElements = await awaitedElements;
     }
-    if (!isElementOrArrayLike(awaitedElements)) {
+    if (!isElementOrArrayOrMultiRemoteElementLike(awaitedElements)) {
         return { other: awaitedElements };
     }
+    if (isMultiRemoteElement(awaitedElements)) {
+        return { selector: awaitedElements, multiRemoteSelector: awaitedElements };
+    }
     if ('getElement' in awaitedElements) {
         const element = await awaitedElements.getElement();
         return { selector: element, element };
@@ -77,3 +86,22 @@ export const awaitElementArray = async (received) => {
     }
     return { elements: awaitedElements };
 };
+const isMultiRemote = (obj) => {
+    return !!obj && typeof obj === 'object' && ('isMultiremote' in obj && obj.isMultiremote === true || 'isMultiRemote' in obj && obj.isMultiRemote === true);
+};
+export const isMultiRemoteElement = (obj) => {
+    return isMultiRemote(obj) && !Array.isArray(obj) && 'selector' in obj;
+};
+export const isMultiRemoteElements = (obj) => {
+    return Array.isArray(obj) && obj.length > 0 && !isMultiRemoteElementArray(obj)
+        && Array.prototype.every.call(obj, isMultiRemoteElement);
+};
+export const isMultiRemoteElementArray = (obj) => {
+    return !!obj && typeof obj === 'object' && 'isMultiremote' in obj && obj.isMultiremote === true && 'parent' in obj && 'foundWith' in obj && 'selector' in obj;
+};
+export const isMultiRemoteElementLike = (obj) => {
+    return isMultiRemoteElement(obj) || isMultiRemoteElementsLike(obj);
+};
+export const isMultiRemoteElementsLike = (obj) => {
+    return isMultiRemoteElementArray(obj) || isMultiRemoteElements(obj);
+};

package/lib/util/executeBrowserCommand.js

@@ -0,0 +1,37 @@
+import { getPerInstanceValues, hasSameInstanceNames } from './multiRemoteUtils.js';
+export async function executeBrowserCommand({ browser, expectedValue, compare, isNot = false, }) {
+    if (browser.isMultiremote) {
+        const { instances } = browser;
+        const perInstanceValues = getPerInstanceValues(expectedValue);
+        const expected = perInstanceValues ?? Object.fromEntries(instances.map((name) => [name, expectedValue]));
+        const forceFailure = (!!perInstanceValues && !hasSameInstanceNames(perInstanceValues, instances))
+            || Object.values(expected).some(Array.isArray);
+        const arrayResults = await Promise.all(instances.map(async (name) => {
+            let singleBrowser;
+            try {
+                singleBrowser = browser.getInstance(name);
+            }
+            catch {
+                return { success: false, actual: undefined, multiRemoteBrowserName: name };
+            }
+            const isExpected = name in expected;
+            const results = await compare(singleBrowser, forceFailure || !isExpected ? undefined : expected[name]);
+            return { ...results, multiRemoteBrowserName: name };
+        }));
+        const actual = arrayResults.reduce((acc, result) => {
+            acc[result.multiRemoteBrowserName] = result.actual;
+            return acc;
+        }, {});
+        if (forceFailure) {
+            return { actual, success: isNot, abort: true, subject: browser, expected };
+        }
+        const success = isNot ? arrayResults.some(result => result.success) : arrayResults.every(result => result.success);
+        return { actual, success, subject: browser, expected };
+    }
+    const forceFailure = getPerInstanceValues(expectedValue) !== undefined || Array.isArray(expectedValue);
+    const results = await compare(browser, forceFailure ? undefined : expectedValue);
+    if (forceFailure) {
+        return { ...results, success: isNot, abort: true, subject: browser, expected: expectedValue };
+    }
+    return { ...results, subject: browser, expected: expectedValue };
+}