expect-webdriverio 5.7.0 → 6.0.1

package/lib/matchers/element/toHaveWidth.js

@@ -1,46 +1,41 @@
 import { DEFAULT_OPTIONS } from '../../constants.js';
-import { compareNumbers, enhanceError, executeCommand, numberError, waitUntil, } from '../../utils.js';
-async function condition(el, width, options) {
+import { wrapExpectedWithArray } from '../../util/elementsUtil.js';
+import { executeCommandWithStrategy } from '../../util/executeCommand.js';
+import { validateNumberArrayAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { enhanceError, waitUntil, } from '../../utils.js';
+async function condition(el, expectedNumber) {
     const actualWidth = await el.getSize('width');
     return {
-        result: compareNumbers(actualWidth, options),
-        value: actualWidth
+        success: expectedNumber?.asymmetricMatch(actualWidth) ?? false,
+        actual: actualWidth
     };
 }
 export async function toHaveWidth(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'width', verb = 'have' } = this;
+    const { expectation = 'width', verb = 'have', isNot, matcherName = 'toHaveWidth' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toHaveWidth',
+        matcherName,
         expectedValue,
         options,
     });
-    let numberOptions;
-    if (typeof expectedValue === 'number') {
-        numberOptions = { eq: expectedValue };
-    }
-    else if (!expectedValue || (typeof expectedValue.eq !== 'number' && typeof expectedValue.gte !== 'number' && typeof expectedValue.lte !== 'number')) {
-        throw new Error('Invalid params passed to toHaveHeight.');
-    }
-    else {
-        numberOptions = expectedValue;
-    }
-    let el = await received?.getElement();
-    let actualWidth;
-    const pass = await waitUntil(async () => {
-        const result = await executeCommand.call(this, el, condition, numberOptions, [expectedValue, numberOptions]);
-        el = result.el;
-        actualWidth = result.values;
-        return result.success;
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError(el, error, actualWidth, this, verb, expectation, '', options);
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberArrayAndExtractOptions(expectedValue, options);
+    const { success: pass, actual: actualWidth, subject: elements, context: { isSome } = {} } = await waitUntil(async (iteration) => {
+        return await executeCommandWithStrategy({
+            unresolvedElements: received,
+            expectedValues: expectedNumber,
+            singleElementCompare: (element, expectedNumber) => condition(element, expectedNumber),
+            context: { isNot, iteration },
+            strategy: 'NewStrictMultipleElements',
+            strictConfiguration: { allowArrayWithSingleElement: false }
+        });
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    const expectedValues = wrapExpectedWithArray(elements, actualWidth, expectedNumber);
+    const message = enhanceError(elements, expectedValues, actualWidth, { isNot, isSome }, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toHaveWidth',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/elements/toBeElementsArrayOfSize.js

@@ -1,47 +1,42 @@
-import { waitUntil, enhanceError, compareNumbers, numberError } from '../../utils.js';
-import { refetchElements } from '../../util/refetchElements.js';
+import { waitUntil, enhanceError, } from '../../utils.js';
+import { refetchElements, syncronizeElements } from '../../util/refetchElements.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
+import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.js';
+import { awaitElementArray, isStrictlyElementArray } from '../../util/elementsUtil.js';
 export async function toBeElementsArrayOfSize(received, expectedValue, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot;
-    const { expectation = 'elements array of size', verb = 'be' } = this;
+    const { expectation = 'elements array of size', verb = 'be', isNot, matcherName = 'toBeElementsArrayOfSize' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeElementsArrayOfSize',
+        matcherName,
         expectedValue,
         options,
     });
-    let numberOptions;
-    if (typeof expectedValue === 'number') {
-        numberOptions = { eq: expectedValue };
-    }
-    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 = expectedValue;
-    }
-    let elements = await received;
-    const originalLength = elements.length;
-    const pass = await waitUntil(async () => {
-        const isPassing = compareNumbers(elements.length, numberOptions);
-        if (isPassing) {
-            return isPassing;
+    const { numberMatcher: expectedNumber, commandOptions } = validateNumberAndExtractOptions(expectedValue, options);
+    let { elements, other } = await awaitElementArray(received);
+    const originalLength = elements ? elements.length : undefined;
+    const { success: pass } = await waitUntil(async (iteration) => {
+        if (!elements) {
+            return { success: false, subject: elements, actual: undefined, abort: true };
+        }
+        else if (iteration > 0) {
+            elements = await refetchElements(elements);
         }
-        elements = await refetchElements(elements, numberOptions.wait, true);
-        return false;
-    }, isNot, { ...numberOptions, ...options });
-    if (Array.isArray(received) && pass) {
-        for (let index = originalLength; index < elements.length; index++) {
-            received.push(elements[index]);
+        const isPassing = expectedNumber.asymmetricMatch(elements.length);
+        if (isPassing) {
+            return { success: isPassing, subject: elements, actual: elements.length };
         }
+        return { success: false, subject: elements, actual: elements.length };
+    }, isNot, { wait: commandOptions.wait, interval: commandOptions.interval });
+    if (pass && originalLength !== undefined && elements !== received && (isStrictlyElementArray(received) || received instanceof Promise) && isStrictlyElementArray(elements)) {
+        await syncronizeElements(received, elements);
     }
-    const error = numberError(numberOptions);
-    const message = enhanceError(elements, error, originalLength, this, verb, expectation, '', numberOptions);
+    const actual = originalLength;
+    const message = enhanceError(elements ?? other, expectedNumber, actual, this, verb, expectation, '', commandOptions);
     const result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeElementsArrayOfSize',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/mock/toBeRequestedTimes.js

@@ -1,30 +1,25 @@
-import { waitUntil, enhanceError, compareNumbers } from '../../utils.js';
-import { numberError } from '../../util/formatMessage.js';
+import { waitUntil, enhanceError } from '../../utils.js';
 import { DEFAULT_OPTIONS } from '../../constants.js';
-export async function toBeRequestedTimes(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot || false;
-    const { expectation = `called${typeof expectedValue === 'number' ? ' ' + expectedValue : ''} time${expectedValue !== 1 ? 's' : ''}`, verb = 'be' } = this;
+import { validateNumberAndExtractOptions } from '../../util/numberOptionsUtil.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?.({
-        matcherName: 'toBeRequestedTimes',
+        matcherName,
         expectedValue,
         options,
     });
-    const numberOptions = typeof expectedValue === 'number'
-        ? { eq: expectedValue }
-        : expectedValue || {};
-    let actual;
-    const pass = await waitUntil(async () => {
-        actual = received.calls.length;
-        return compareNumbers(actual, numberOptions);
-    }, isNot, { ...numberOptions, ...options });
-    const error = numberError(numberOptions);
-    const message = enhanceError('mock', error, actual, this, verb, expectation, '', numberOptions);
+    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 result = {
         pass,
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeRequestedTimes',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/mock/toBeRequestedWith.js

@@ -10,26 +10,25 @@ function reduceHeaders(headers) {
     }, {});
 }
 export async function toBeRequestedWith(received, expectedValue = {}, options = DEFAULT_OPTIONS) {
-    const isNot = this.isNot || false;
-    const { expectation = 'called with', verb = 'be' } = this;
+    const { expectation = 'called with', verb = 'be', isNot, matcherName = 'toBeRequestedWith' } = this;
     await options.beforeAssertion?.({
-        matcherName: 'toBeRequestedWith',
+        matcherName,
         expectedValue,
         options,
     });
-    let actual;
-    const pass = await waitUntil(async () => {
+    const { success: pass, actual } = await waitUntil(async () => {
+        let lastCall;
         for (const call of received.calls) {
-            actual = call;
+            lastCall = call;
             if (methodMatcher(call.request.method, expectedValue.method) &&
                 statusCodeMatcher(call.response.status, expectedValue.statusCode) &&
                 urlMatcher(call.request.url, expectedValue.url) &&
                 headersMatcher(reduceHeaders(call.request.headers), expectedValue.requestHeaders) &&
                 headersMatcher(reduceHeaders(call.response.headers), expectedValue.responseHeaders)) {
-                return true;
+                return { success: true, subject: call, actual: call };
             }
         }
-        return false;
+        return { success: false, subject: lastCall, actual: lastCall };
     }, isNot, { ...options, wait: isNot ? 0 : options.wait });
     const message = enhanceError('mock', minifyRequestedWith(expectedValue), minifyRequestMock(actual, expectedValue) || 'was not called', this, verb, expectation, '', options);
     const result = {
@@ -37,7 +36,7 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
         message: () => message
     };
     await options.afterAssertion?.({
-        matcherName: 'toBeRequestedWith',
+        matcherName,
         expectedValue,
         options,
         result

package/lib/matchers/modifiers/some.js

@@ -0,0 +1,15 @@
+const SOME_TAG = 'expect-webdriverio.some';
+const SOME_SYMBOL = Symbol.for(SOME_TAG);
+export class SomeElementsWrapper {
+    elements;
+    [SOME_SYMBOL] = true;
+    constructor(elements) {
+        this.elements = elements;
+    }
+}
+export function some(elements) {
+    return new SomeElementsWrapper(elements);
+}
+export function isSomeWrapper(value) {
+    return value instanceof SomeElementsWrapper;
+}

package/lib/matchers.js

@@ -12,9 +12,9 @@ export * from './matchers/element/toBeFocused.js';
 export * from './matchers/element/toBeSelected.js';
 export * from './matchers/element/toHaveAttribute.js';
 export * from './matchers/element/toHaveChildren.js';
-export * from './matchers/element/toHaveClass.js';
 export * from './matchers/element/toHaveComputedLabel.js';
 export * from './matchers/element/toHaveComputedRole.js';
+export * from './matchers/element/toHaveElementClass.js';
 export * from './matchers/element/toHaveElementProperty.js';
 export * from './matchers/element/toHaveHeight.js';
 export * from './matchers/element/toHaveHref.js';

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/matchers/snapshot.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/toHaveClass.ts","../src/matchers/element/toHaveComputedLabel.ts","../src/matchers/element/toHaveComputedRole.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/util/elementsUtil.ts","../src/util/executeCommand.ts","../src/util/formatMessage.ts","../src/util/refetchElements.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/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/numberOptionsUtil.ts","../src/util/refetchElements.ts","../src/util/stringUtil.ts","../src/util/waitUntil.ts"],"version":"5.9.3"}

package/lib/util/commandOptionsUtils.js

@@ -0,0 +1,6 @@
+export const isDefinedPlainObject = (obj) => {
+    if (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) {
+        return true;
+    }
+    return false;
+};

package/lib/util/elementsUtil.js

@@ -1,9 +1,79 @@
-export const wrapExpectedWithArray = (el, actual, expected) => {
-    if (Array.isArray(el) && el.length > 1 && Array.isArray(actual)) {
-        expected = [expected];
+export const wrapExpectedWithArray = (elements, actual, expected) => {
+    if (Array.isArray(elements) && Array.isArray(actual) && !Array.isArray(expected)) {
+        expected = Array(actual.length).fill(expected);
     }
     return expected;
 };
+export const fillSingleExpectedForElementArray = (subject, value) => {
+    if (isElementArrayLike(subject) && !Array.isArray(value)) {
+        const fillerlength = subject.length > 0 ? subject.length : 1;
+        return Array(fillerlength).fill(value);
+    }
+    return value;
+};
+export const isArray = (obj) => {
+    return Array.isArray(obj);
+};
+export const isSelector = (obj) => {
+    return !!obj
+        && typeof obj === 'object'
+        && 'selector' in obj
+        && 'parent' in obj;
+};
 export const isElementArray = (obj) => {
-    return obj !== null && typeof obj === 'object' && 'selector' in obj && 'foundWith' in obj && 'parent' in obj;
+    return isSelector(obj)
+        && 'foundWith' in obj;
+};
+export const isStrictlyElementArray = (obj) => {
+    return isElementArray(obj)
+        && Array.isArray(obj)
+        && 'getElements' in obj;
+};
+export const isElement = (obj) => {
+    return isSelector(obj)
+        && !Array.isArray(obj)
+        && 'getElement' in obj;
+};
+export const isElementArrayLike = (obj) => {
+    return !!obj && (isStrictlyElementArray(obj) || (Array.isArray(obj) && obj.every(isElement)));
+};
+export const isArrayOfElement = (obj) => {
+    return Array.isArray(obj) && obj.every(isElement);
+};
+export const isElementOrArrayLike = (obj) => {
+    return !!obj && (isElement(obj) || isElementArrayLike(obj));
+};
+export const awaitElementOrArray = async (received) => {
+    if (!received || typeof received !== 'object') {
+        return { other: received };
+    }
+    let awaitedElements = received;
+    if (awaitedElements instanceof Promise) {
+        awaitedElements = await awaitedElements;
+    }
+    if (!isElementOrArrayLike(awaitedElements)) {
+        return { other: awaitedElements };
+    }
+    if ('getElement' in awaitedElements) {
+        const element = await awaitedElements.getElement();
+        return { selector: element, element };
+    }
+    if ('getElements' in awaitedElements) {
+        const elements = await awaitedElements.getElements();
+        return { selector: elements, elements, isEmptyElements: elements.length === 0 };
+    }
+    return { selector: awaitedElements, elements: awaitedElements, isEmptyElements: awaitedElements.length === 0 };
+};
+export const awaitElementArray = async (received) => {
+    let awaitedElements = received;
+    if (awaitedElements instanceof Promise) {
+        awaitedElements = await awaitedElements;
+    }
+    if (!isElementArrayLike(awaitedElements)) {
+        return { other: awaitedElements };
+    }
+    if ('getElements' in awaitedElements) {
+        return { elements: await awaitedElements.getElements() };
+    }
+    return { elements: awaitedElements };
 };

package/lib/util/executeCommand.js

@@ -1,8 +1,96 @@
-export async function executeCommand(el, condition, options = {}, params = []) {
-    const result = await condition(el, ...params, options);
+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 } }) {
+    const isSome = isSomeWrapper(unresolvedElements);
+    if (strategy === 'LegacyLooseMultipleElements') {
+        if (isSome) {
+            throw new Error('some(elements) works only when enabling `useToHaveTextStrictMultiElementsCompareStrategy`');
+        }
+        return legacyMultipleElementResultsStrategy(unresolvedElements, 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) => {
+    const { selector, other, isEmptyElements } = await awaitElementOrArray(unresolvedElements);
+    const subject = selector ?? other;
+    if (!selector || isEmptyElements) {
+        return {
+            subject: subject,
+            success: false,
+            actual: undefined,
+            abort: true,
+        };
+    }
+    if (isElement(selector)) {
+        const compareResult = await singleElementCompare(selector, expectedValues);
+        return {
+            subject,
+            ...compareResult,
+        };
+    }
+    const settled = await Promise.allSettled(Array.from(selector).map((element, index) => singleElementCompare(element, expectedValues, index)));
+    const firstRejection = settled.find((r) => r.status === 'rejected');
+    if (firstRejection) {
+        throw firstRejection.reason;
+    }
+    const results = settled.map((r) => r.value);
     return {
-        el,
-        success: result.result === true,
-        values: result.value
+        subject,
+        success: results.length > 0 && results.every((res) => res.success === true),
+        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);
+    }
+    const subject = selector ?? other;
+    if (!selector || (Array.isArray(selector) && selector.length === 0)) {
+        return {
+            subject,
+            success: isNot ? !allowEmptyElements : false,
+            actual: undefined,
+            abort: !allowEmptyElements && !isStrictlyElementArray(selector),
+            context: { isSome },
+        };
+    }
+    if (isElement(selector)) {
+        const forceFailure = !allowArrayWithSingleElement && Array.isArray(expectedValues);
+        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) => {
+        const indexedExpected = Array.isArray(expectedValues) ? expectedValues[index] : expectedValues;
+        const forceElementFailure = Array.isArray(indexedExpected)
+            || (lengthMismatch && Array.isArray(expectedValues) && index >= expectedValues.length);
+        const compareResult = await singleElementCompare(element, forceElementFailure ? undefined : indexedExpected, index);
+        return forceElementFailure ? { success: false, actual: compareResult.actual } : compareResult;
+    }));
+    const firstRejection = settled.find((r) => r.status === 'rejected');
+    if (firstRejection) {
+        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 (lengthMismatch) {
+        return { subject, success: !!isNot, actual: results.map(({ actual }) => actual), context: { isSome } };
+    }
+    const isNotEmpty = results.length > 0;
+    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 isAllTrue = (results) => results.every((res) => res.success === true);
+const isAllFalse = (results) => results.every((res) => res.success === false);
+const isAtLeastOneTrue = (results) => results.some((res) => res.success === true);
+const isAtLeastOneFalse = (results) => results.some((res) => res.success === false);

package/lib/util/formatMessage.js

@@ -1,6 +1,9 @@
-import { printDiffOrStringify, printExpected, printReceived } from 'jest-matcher-utils';
+import { printDiffOrStringify, printExpected, printReceived, RECEIVED_COLOR, EXPECTED_COLOR, INVERTED_COLOR, stringify } from 'jest-matcher-utils';
 import { equals } from '../jasmineUtils.js';
-import { isElementArray } from './elementsUtil.js';
+import { isArrayOfElement, isElementArrayLike, isElementOrArrayLike, isStrictlyElementArray } from './elementsUtil.js';
+import { toJsonString } from './stringUtil.js';
+import { isJasmineStringAsymmetricMatcher, toArray } from '../utils.js';
+export const isDefined = (value) => value !== null && value !== undefined;
 export const getSelector = (el) => {
     let result = typeof el.selector === 'string' ? el.selector : '<fn>';
     if (Array.isArray(el) && el.props.length > 0) {
@@ -9,27 +12,36 @@ export const getSelector = (el) => {
     return result;
 };
 export const getSelectors = (el) => {
+    if (!el || typeof el !== 'object') {
+        return '';
+    }
     const selectors = [];
     let parent;
-    if (isElementArray(el)) {
+    if (isStrictlyElementArray(el)) {
         selectors.push(`${(el).foundWith}(\`${getSelector(el)}\`)`);
         parent = el.parent;
     }
-    else if (!Array.isArray(el)) {
+    else if (isArrayOfElement(el)) {
+        return `[${el.map(getSelectors).join(',')}]`;
+    }
+    else {
         parent = el;
     }
-    while (parent && 'selector' in parent) {
+    while (!!parent && typeof parent === 'object' && 'selector' in parent) {
         const selector = getSelector(parent);
-        const index = parent.index ? `[${parent.index}]` : '';
-        selectors.push(`${parent.index ? '$' : ''}$(\`${selector}\`)${index}`);
+        const index = isDefined(parent.index) ? `[${parent.index}]` : '';
+        selectors.push(`${isDefined(parent.index) ? '$' : ''}$(\`${selector}\`)${index}`);
         parent = parent.parent;
     }
     return selectors.reverse().join('.');
 };
 const not = (isNot) => `${isNot ? 'not ' : ''}`;
 export const enhanceError = (subject, expected, actual, context, verb, expectation, expectedValueArgument2 = '', { message = '', containing = false } = {}) => {
-    const { isNot = false, useNotInLabel = true } = context;
-    subject = typeof subject === 'string' ? subject : getSelectors(subject);
+    const { isNot, useNotInLabel = true } = context;
+    let subjectStr = (isElementOrArrayLike(subject) ? getSelectors(subject) : toJsonString(subject));
+    if (subjectStr.length > 100) {
+        subjectStr = `${subjectStr.substring(0, 100)}...`;
+    }
     let contain = '';
     if (containing) {
         contain = ' containing';
@@ -37,44 +49,87 @@ export const enhanceError = (subject, expected, actual, context, verb, expectati
     if (verb) {
         verb += ' ';
     }
+    const isNotInLabel = useNotInLabel && isNot;
     const label = {
-        expected: isNot && useNotInLabel ? 'Expected [not]' : 'Expected',
-        received: isNot && useNotInLabel ? 'Received      ' : 'Received'
+        expected: isNotInLabel ? 'Expected [not]' : 'Expected',
+        received: isNotInLabel ? 'Received      ' : 'Received'
     };
-    const diffString = equals(actual, expected) ? `\
+    let diffString = '';
+    if (isJasmineStringAsymmetricMatcher(expected)) {
+        expected = expected.jasmineToString();
+    }
+    else if (isElementOrArrayLike(subject) && Array.isArray(expected)) {
+        expected = expected.map(item => isJasmineStringAsymmetricMatcher(item) ? item.jasmineToString() : item);
+    }
+    if (isNotInLabel && isElementOrArrayLike(subject) && Array.isArray(expected) && Array.isArray(actual) && expected.length === actual.length) {
+        const { expectedFormatted, receivedFormatted } = printArrayWithMatchingItemInRed(expected, actual);
+        diffString = `\
+${label.expected}: ${expectedFormatted}
+${label.received}: ${receivedFormatted}`;
+    }
+    else if (equals(actual, expected)) {
+        diffString =
+            `\
 ${label.expected}: ${printExpected(expected)}
-${label.received}: ${printReceived(actual)}`
-        : printDiffOrStringify(expected, actual, label.expected, label.received, true);
+${label.received}: ${printReceived(actual)}`;
+    }
+    else {
+        diffString = printDiffOrStringify(expected, actual, label.expected, label.received, true);
+    }
     if (message) {
         message += '\n';
     }
     if (expectedValueArgument2) {
         expectedValueArgument2 = ` ${expectedValueArgument2}`;
     }
+    const some = context.isSome ? 'some of ' : '';
     const msg = `\
-${message}Expect ${subject} ${not(isNot)}to ${verb}${expectation}${expectedValueArgument2}${contain}
+${message}Expect ${some}${subjectStr} ${not(isNot)}to ${verb}${expectation}${expectedValueArgument2}${contain}
 
 ${diffString}`;
     return msg;
 };
-export const enhanceErrorBe = (subject, context, options) => {
-    const { isNot, verb, expectation } = context;
-    const expected = `${not(isNot)}${expectation}`;
-    const actual = `${not(!isNot)}${expectation}`;
-    return enhanceError(subject, expected, actual, { ...context, useNotInLabel: false }, verb, expectation, '', options);
-};
-export const numberError = (options = {}) => {
-    if (typeof options.eq === 'number') {
-        return options.eq;
-    }
-    if (options.gte && options.lte) {
-        return `>= ${options.gte} && <= ${options.lte}`;
+const printArrayWithMatchingItemInRed = (expectedArray, actualArray) => {
+    const matchingIndices = [];
+    for (let i = 0; i < expectedArray.length; i++) {
+        if (equals(expectedArray[i], actualArray[i])) {
+            matchingIndices.push(i);
+        }
     }
-    if (options.gte) {
-        return `>= ${options.gte}`;
+    const expectedFormatted = `[${expectedArray
+        .map((item, i) => {
+        const stringified = stringify(item);
+        return matchingIndices.includes(i)
+            ? RECEIVED_COLOR(INVERTED_COLOR(stringified))
+            : EXPECTED_COLOR(stringified);
+    })
+        .join(', ')}]`;
+    const receivedFormatted = `[${actualArray
+        .map((item, i) => {
+        const stringified = stringify(item);
+        return matchingIndices.includes(i)
+            ? RECEIVED_COLOR(INVERTED_COLOR(stringified))
+            : EXPECTED_COLOR(stringified);
+    })
+        .join(', ')}]`;
+    return { expectedFormatted, receivedFormatted };
+};
+export const enhanceErrorBe = (subject, results, context, options) => {
+    const { isNot, verb, expectation } = context;
+    let expected;
+    let actual;
+    const expectedValue = `${not(isNot)}${expectation}`;
+    const actualValue = `${not(!isNot)}${expectation}`;
+    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}`);
     }
-    if (options.lte) {
-        return ` <= ${options.lte}`;
+    else {
+        expected = expectedValue;
+        actual = actualValue;
     }
-    return 'no params';
+    return enhanceError(subject, expected, actual, { ...context, useNotInLabel: false }, verb, expectation, '', options);
+};
+const isSuccess = (isNot, success) => {
+    return isNot ? !success : success;
 };