expect-webdriverio 5.6.9 → 6.0.0

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;
 };

package/lib/util/numberOptionsUtil.js

@@ -0,0 +1,92 @@
+import { AsymmetricMatcher } from 'expect';
+import { isDefinedPlainObject } from './commandOptionsUtils.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);
+export function validateNumberAndExtractOptions(expectedValue, commandOptions, { supportDefaultAsGteThen1 } = {}) {
+    let defaultExpectedValue = undefined;
+    if (supportDefaultAsGteThen1 && (expectedValue === undefined || (isDefinedPlainObject(expectedValue) && expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined))) {
+        defaultExpectedValue = new NumberMatcher({ gte: 1 });
+    }
+    else if (isNumber(expectedValue)) {
+        return { numberMatcher: new NumberMatcher({ eq: expectedValue }), commandOptions };
+    }
+    else if (!isDefinedNumberOrNonEmptyObject(expectedValue) || isDefinedNotNumber(expectedValue.eq) || isDefinedNotNumber(expectedValue.gte) || isDefinedNotNumber(expectedValue.lte)
+        || (expectedValue.eq === undefined && expectedValue.gte === undefined && expectedValue.lte === undefined)) {
+        throw new Error(`Invalid NumberMatcher. Received: ${JSON.stringify(expectedValue)}`);
+    }
+    const { eq, gte, lte, ...restCommandOptions } = expectedValue ?? {};
+    if (isNumber(gte) && isNumber(lte) && gte > lte) {
+        throw new Error(`Invalid NumberMatcher range: 'gte' (${gte}) cannot be greater than 'lte' (${lte}).`);
+    }
+    return {
+        numberMatcher: defaultExpectedValue ?? new NumberMatcher({ eq, gte, lte }),
+        commandOptions: { ...commandOptions, ...restCommandOptions }
+    };
+}
+export function validateNumberArrayAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 } = {}) {
+    if (Array.isArray(expectedValues)) {
+        const allNumbers = expectedValues.map((value) => validateNumberAndExtractOptions(value, commandOptions, { supportDefaultAsGteThen1 }));
+        return { numberMatcher: allNumbers.map(({ numberMatcher }) => numberMatcher), commandOptions };
+    }
+    return validateNumberAndExtractOptions(expectedValues, commandOptions, { supportDefaultAsGteThen1 });
+}
+export class NumberMatcher extends AsymmetricMatcher {
+    sample;
+    constructor(sample) {
+        super(sample);
+        this.sample = sample;
+    }
+    asymmetricMatch(actual) {
+        if (actual === undefined) {
+            return false;
+        }
+        if (isNumber(this.sample)) {
+            return actual === this.sample;
+        }
+        if (isNumber(this.sample.eq)) {
+            return actual === this.sample.eq;
+        }
+        if (isNumber(this.sample.gte) && isNumber(this.sample.lte)) {
+            return actual >= this.sample.gte && actual <= this.sample.lte;
+        }
+        if (isNumber(this.sample.gte)) {
+            return actual >= this.sample.gte;
+        }
+        if (isNumber(this.sample.lte)) {
+            return actual <= this.sample.lte;
+        }
+        return false;
+    }
+    toAsymmetricMatcher() {
+        if (isNumber(this.sample)) {
+            return `${this.sample}`;
+        }
+        if (isNumber(this.sample.eq)) {
+            return `${this.sample.eq}`;
+        }
+        if (isNumber(this.sample.gte) && isNumber(this.sample.lte)) {
+            return `>= ${this.sample.gte} && <= ${this.sample.lte}`;
+        }
+        if (isNumber(this.sample.gte)) {
+            return `>= ${this.sample.gte}`;
+        }
+        if (isNumber(this.sample.lte)) {
+            return `<= ${this.sample.lte}`;
+        }
+        return 'Incorrect number options provided';
+    }
+    toString() {
+        return this.toAsymmetricMatcher();
+    }
+    jasmineToString() {
+        return this.toString();
+    }
+}
+export const isEmptyOrLegacyNumberOptions = (value) => {
+    if (!isDefinedPlainObject(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    return keys.length === 0 || keys.filter((key) => !['eq', 'gte', 'lte'].includes(key)).length > 0;
+};

package/lib/util/refetchElements.js

@@ -1,10 +1,35 @@
-import { DEFAULT_OPTIONS } from '../constants.js';
-import { isElementArray } from './elementsUtil.js';
-export const refetchElements = async (elements, wait = DEFAULT_OPTIONS.wait, full = false) => {
-    if (elements && wait > 0 && (elements.length === 0 || full) && isElementArray(elements) && elements.parent && elements.foundWith && elements.foundWith in elements.parent) {
+import { isStrictlyElementArray } from './elementsUtil.js';
+export const refetchElements = async (elements) => {
+    if (elements
+        && isStrictlyElementArray(elements)
+        && elements.parent && elements.foundWith && elements.foundWith in elements.parent) {
         const browser = elements.parent;
         const $$ = browser[elements.foundWith];
-        elements = await $$.call(browser, elements.selector, ...elements.props);
+        return await $$.call(browser, elements.selector, ...elements.props);
     }
     return elements;
 };
+export const syncronizeElements = async (subject, refetchedElements) => {
+    if (subject instanceof Promise) {
+        await syncronizeChainableElementArray(subject, refetchedElements);
+    }
+    else if (isStrictlyElementArray(subject)) {
+        synchronizeElementArray(subject, refetchedElements);
+    }
+};
+export const syncronizeChainableElementArray = async (subject, refetchedElements) => {
+    const awaitedSubject = await subject;
+    if (isStrictlyElementArray(awaitedSubject) && refetchedElements) {
+        synchronizeElementArray(await awaitedSubject.getElements(), refetchedElements);
+    }
+};
+export const synchronizeElementArray = (subject, refetchedElements) => {
+    subject.length = refetchedElements.length;
+    for (let index = 0; index < refetchedElements.length; index++) {
+        subject[index] = refetchedElements[index];
+    }
+};
+export const refreshElementArray = async (subject) => {
+    const refetchedElements = await refetchElements(subject);
+    synchronizeElementArray(subject, refetchedElements);
+};

package/lib/util/stringUtil.js

@@ -0,0 +1,12 @@
+export const isString = (value) => typeof value === 'string';
+export const toJsonString = (value) => {
+    if (isString(value)) {
+        return value;
+    }
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+};

package/lib/util/waitUntil.js

@@ -0,0 +1,44 @@
+import { DEFAULT_OPTIONS } from '../constants.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export const waitUntil = async (condition, isNot = false, { wait = DEFAULT_OPTIONS.wait, interval = DEFAULT_OPTIONS.interval } = {}) => {
+    if (wait === 0) {
+        return await condition(0);
+    }
+    let error;
+    let result;
+    let iteration = 0;
+    try {
+        const start = Date.now();
+        while (true) {
+            if (Date.now() - start > wait) {
+                throw new Error('timeout');
+            }
+            try {
+                result = await condition(iteration++);
+                const passed = isNot !== result?.success;
+                error = undefined;
+                if (passed) {
+                    break;
+                }
+                else if (result?.abort) {
+                    return { ...result, success: isNot };
+                }
+                await sleep(interval);
+            }
+            catch (err) {
+                error = err;
+                await sleep(interval);
+            }
+        }
+        if (error) {
+            throw error;
+        }
+        return { ...result, success: !isNot };
+    }
+    catch {
+        if (error) {
+            throw error;
+        }
+        return { ...result, subject: result?.subject, success: isNot, actual: result?.actual };
+    }
+};