expect-webdriverio 6.0.6 → 6.0.8

package/lib/matchers/mock/toBeRequestedWith.js

@@ -16,21 +16,41 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
         expectedValue,
         options,
     });
+    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;
+        let hasPendingPayloadCandidate = false;
         for (const call of received.calls) {
             lastCall = call;
-            if (methodMatcher(call.request.method, expectedValue.method) &&
+            const matchesNonPayloadCriteria = 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)) {
+                headersMatcher(reduceHeaders(call.response.headers), expectedValue.responseHeaders);
+            if (!matchesNonPayloadCriteria) {
+                continue;
+            }
+            if (bodyMatcher(call.postData, expectedValue.postData, parseCache) &&
+                bodyMatcher(call.body, expectedValue.response, parseCache)) {
                 return { success: true, subject: call, actual: call };
             }
+            if ((expectedValue.postData !== undefined && call.postData === undefined) ||
+                (expectedValue.response !== undefined && call.body === undefined)) {
+                hasPendingPayloadCandidate = true;
+            }
         }
-        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);
+        payloadNeverCollected = hasPendingPayloadCandidate;
+        return {
+            success: false,
+            subject: lastCall,
+            actual: lastCall,
+            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 = {
         pass,
         message: () => message
@@ -43,6 +63,18 @@ export async function toBeRequestedWith(received, expectedValue = {}, options =
     });
     return result;
 }
+const payloadCollectionHint = (expectedValue) => {
+    const fields = [
+        expectedValue.postData !== undefined ? 'postData' : undefined,
+        expectedValue.response !== undefined ? 'response' : undefined,
+    ].filter(Boolean).join(' and ');
+    return `
+
+A request matched every other criterion, but its body was never collected, so ${fields} could not be compared.
+This usually means either:
+  - webdriverio is older than v9.28.0, which did not populate \`mock.calls[].postData\` (upgrade to v9.28.0 or later), or
+  - body collection is turned off via \`maxSpyCollectedBodySize: 0\` in your config (it defaults to 10MB - remove the override or raise it).`;
+};
 const methodMatcher = (method, expected) => {
     if (expected === undefined) {
         return true;
@@ -87,7 +119,69 @@ const headersMatcher = (headers, expected) => {
     }
     return equals(headers, expected);
 };
-const minifyRequestMock = (requestMock, requestedWith) => {
+const bodyMatcher = (body, expected, parseCache) => {
+    if (typeof expected === 'undefined') {
+        return true;
+    }
+    if (typeof expected === 'function') {
+        return expected(body);
+    }
+    if (typeof body === 'undefined') {
+        return false;
+    }
+    let parsedBody = body;
+    if (body instanceof Buffer) {
+        parsedBody = body.toString();
+    }
+    if (typeof parsedBody === 'string' && isExpectedJsonLike(expected)) {
+        const parsed = parseJsonOnce(parsedBody, parseCache);
+        if (!parsed.ok) {
+            return false;
+        }
+        parsedBody = parsed.value;
+    }
+    return equals(parsedBody, expected);
+};
+const JSON_LIKE_ANY_CONSTRUCTORS = new Set([Number, Boolean, Array, Object]);
+const isExpectedJsonLike = (expected) => {
+    if (typeof expected === 'undefined') {
+        return false;
+    }
+    const actualSample = isAsymmetricMatcher(expected)
+        ? getAsymmetricMatcherValue(expected)
+        : expected;
+    return (actualSample === null ||
+        typeof actualSample === 'boolean' ||
+        typeof actualSample === 'number' ||
+        Array.isArray(actualSample) ||
+        JSON_LIKE_ANY_CONSTRUCTORS.has(actualSample) ||
+        (typeof actualSample === 'object' &&
+            actualSample !== null &&
+            actualSample instanceof RegExp === false));
+};
+const parseJsonOnce = (jsonString, cache) => {
+    const cached = cache.get(jsonString);
+    if (cached) {
+        return cached;
+    }
+    let result;
+    try {
+        result = { ok: true, value: JSON.parse(jsonString) };
+    }
+    catch {
+        result = { ok: false };
+    }
+    cache.set(jsonString, result);
+    return result;
+};
+const resolveBodyForDisplay = (raw, expectedForField, parseCache) => {
+    if (typeof raw !== 'string' || !isExpectedJsonLike(expectedForField)) {
+        return raw;
+    }
+    const parsed = parseJsonOnce(raw, parseCache);
+    return parsed.ok ? parsed.value : raw;
+};
+const minifyRequestMock = (requestMock, requestedWith = {}, parseCache = new Map()) => {
     if (requestMock === undefined) {
         return requestMock;
     }
@@ -96,6 +190,8 @@ const minifyRequestMock = (requestMock, requestedWith) => {
         method: requestMock.request.method,
         requestHeaders: requestMock.request.headers,
         responseHeaders: requestMock.response.headers,
+        postData: resolveBodyForDisplay(requestMock.postData, requestedWith.postData, parseCache),
+        response: resolveBodyForDisplay(requestMock.body, requestedWith.response, parseCache),
     };
     deleteUndefinedValues(r, requestedWith);
     return minifyRequestedWith(r);

package/lib/utils.js

@@ -21,6 +21,12 @@ export function isStringContainingMatcherLike(expected) {
 export function isInversedStringContainingMatcher(expected) {
     return isStringContainingMatcherLike(expected) && expected.inverse === true;
 }
+export function isStringMatchingMatcherLike(expected) {
+    return !!expected && expected.constructor.name === 'StringMatching';
+}
+export function isInversedStringMatchingMatcher(expected) {
+    return isStringMatchingMatcherLike(expected) && expected.inverse === true;
+}
 export function getStringAsymmetricMatcherValue(expected) {
     if ('expected' in expected) {
         return expected.expected;
@@ -116,16 +122,30 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
         actual = replaceActual(replace, actual);
     }
     if (ignoreCase) {
-        actual = actual.toLowerCase();
         if (typeof expected === 'string') {
+            actual = actual.toLowerCase();
             expected = expected.toLowerCase();
         }
+        else if (expected instanceof RegExp) {
+            expected = withIgnoreCaseFlag(expected);
+        }
         else if (isStringContainingMatcherLike(expected)) {
+            actual = actual.toLowerCase();
             const sample = getStringAsymmetricMatcherValue(expected).toString().toLocaleLowerCase();
             expected = (isInversedStringContainingMatcher(expected)
                 ? expect.not.stringContaining(sample)
                 : expect.stringContaining(sample));
         }
+        else if (isStringMatchingMatcherLike(expected)) {
+            const sample = getStringAsymmetricMatcherValue(expected);
+            const caseInsensitiveSample = withIgnoreCaseFlag(sample instanceof RegExp ? sample : new RegExp(sample));
+            expected = (isInversedStringMatchingMatcher(expected)
+                ? expect.not.stringMatching(caseInsensitiveSample)
+                : expect.stringMatching(caseInsensitiveSample));
+        }
+        else {
+            actual = actual.toLowerCase();
+        }
     }
     if (isAsymmetricMatcher(expected)) {
         const result = expected.asymmetricMatch(actual);
@@ -158,7 +178,7 @@ export const compareText = (actual, expected, { ignoreCase = false, trim = true,
             success: actual.endsWith(expected),
         };
     }
-    if (atIndex) {
+    if (atIndex !== undefined) {
         return {
             actual,
             success: actual.substring(atIndex, actual.length).startsWith(expected),
@@ -182,24 +202,38 @@ export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false
     if (Array.isArray(replace)) {
         actual = replaceActual(replace, actual);
     }
+    const actualOriginalCase = actual;
     if (ignoreCase) {
         actual = actual.toLowerCase();
         expectedArray = expectedArray.map((item) => {
             if (typeof item === 'string') {
                 return item.toLowerCase();
             }
+            if (item instanceof RegExp) {
+                return withIgnoreCaseFlag(item);
+            }
             if (isStringContainingMatcherLike(item)) {
                 const sample = getStringAsymmetricMatcherValue(item).toString().toLocaleLowerCase();
                 return (isInversedStringContainingMatcher(item)
                     ? expect.not.stringContaining(sample)
                     : expect.stringContaining(sample));
             }
+            if (isStringMatchingMatcherLike(item)) {
+                const sample = getStringAsymmetricMatcherValue(item);
+                const caseInsensitiveSample = withIgnoreCaseFlag(sample instanceof RegExp ? sample : new RegExp(sample));
+                return (isInversedStringMatchingMatcher(item)
+                    ? expect.not.stringMatching(caseInsensitiveSample)
+                    : expect.stringMatching(caseInsensitiveSample));
+            }
             return item;
         });
     }
     const hasFoundTextInArray = expectedArray.some((expected) => {
         if (expected instanceof RegExp) {
-            return !!actual.match(expected);
+            return !!actualOriginalCase.match(expected);
+        }
+        if (isStringMatchingMatcherLike(expected) && getStringAsymmetricMatcherValue(expected) instanceof RegExp) {
+            return expected.asymmetricMatch(actualOriginalCase);
         }
         if (isAsymmetricMatcher(expected)) {
             return expected.asymmetricMatch(actual);
@@ -213,13 +247,13 @@ export const compareTextWithArray = (actual, expectedArray, { ignoreCase = false
         if (atEnd) {
             return actual.endsWith(expected);
         }
-        if (atIndex) {
+        if (atIndex !== undefined) {
             return actual.substring(atIndex, actual.length).startsWith(expected);
         }
         return actual === expected;
     });
     return {
-        actual,
+        actual: actualOriginalCase,
         success: hasFoundTextInArray,
     };
 };
@@ -250,31 +284,33 @@ export const compareStyle = async (actualEl, style, { ignoreCase = false, trim =
             actualVal = actualVal.toLowerCase();
             expectedVal = expectedVal.toLowerCase();
         }
+        let matches;
         if (containing) {
-            success = actualVal.includes(expectedVal);
+            matches = actualVal.includes(expectedVal);
             actual[key] = actualVal;
         }
         else if (atStart) {
-            success = actualVal.startsWith(expectedVal);
+            matches = actualVal.startsWith(expectedVal);
             actual[key] = actualVal;
         }
         else if (atEnd) {
-            success = actualVal.endsWith(expectedVal);
+            matches = actualVal.endsWith(expectedVal);
             actual[key] = actualVal;
         }
-        else if (atIndex) {
-            success = actualVal.substring(atIndex, actualVal.length).startsWith(expectedVal);
+        else if (atIndex !== undefined) {
+            matches = actualVal.substring(atIndex, actualVal.length).startsWith(expectedVal);
             actual[key] = actualVal;
         }
         else if (replace) {
             const replacedActual = replaceActual(replace, actualVal);
-            success = replacedActual === expectedVal;
+            matches = replacedActual === expectedVal;
             actual[key] = replacedActual;
         }
         else {
-            success = success && actualVal === expectedVal;
+            matches = actualVal === expectedVal;
             actual[key] = css.value;
         }
+        success = success && matches;
     }
     return {
         actual,
@@ -282,6 +318,13 @@ export const compareStyle = async (actualEl, style, { ignoreCase = false, trim =
     };
 };
 export { compareNumbers, enhanceError, executeCommandBe, waitUntil, wrapExpectedWithArray };
+function withIgnoreCaseFlag(expected) {
+    const cloned = expected.ignoreCase
+        ? new RegExp(expected.source, expected.flags)
+        : new RegExp(expected.source, `${expected.flags}i`);
+    cloned.lastIndex = expected.lastIndex;
+    return cloned;
+}
 function replaceActual(replace, actual) {
     const hasMultipleReplacers = replace.every((r) => Array.isArray(r));
     const replacers = hasMultipleReplacers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expect-webdriverio",
-  "version": "6.0.6",
+  "version": "6.0.8",
   "author": "Mykola Grybyk <mykola.grybyk@gmail.com>",
   "description": "WebdriverIO Assertion Library",
   "license": "MIT",
@@ -45,7 +45,10 @@
     ],
     "./types": "./types/expect-global.d.ts",
     "./expect-global": "./types/expect-global.d.ts",
-    "./api": "./lib/api/index.js"
+    "./api": {
+      "types": "./types/expect-webdriverio.d.ts",
+      "import": "./lib/api/index.js"
+    }
   },
   "types": "./types/expect-webdriverio.d.ts",
   "typeScriptVersion": "3.8.3",
@@ -70,6 +73,7 @@
     "ts:jasmine-global-expect-async": "cd test-types/jasmine-global-expect-async && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
     "ts:jest:@types-jest": "cd test-types/jest-@types_jest && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
     "ts:mocha": "cd test-types/mocha && vitest --typecheck --typecheck.tsconfig ./tsconfig.json --run",
+    "ts:arethetypeswrong": "npx @arethetypeswrong/cli --pack . --profile esm-only",
     "checks:all": "npm run build && npm run compile && npm run tsc:root-types && npm run test && npm run ts",
     "watch": "npm run compile -- --watch",
     "prepare": "husky",
@@ -85,6 +89,7 @@
     "jest-matcher-utils": "^30.4.1"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
     "@jest/globals": "^30.4.1",
     "@types/debug": "^4.1.13",
     "@types/jasmine": "^5.1.15",
@@ -108,7 +113,7 @@
   "peerDependencies": {
     "@wdio/globals": "^9.0.0",
     "@wdio/logger": "^9.0.0",
-    "webdriverio": "^9.0.0"
+    "webdriverio": "^9.28.0"
   },
   "peerDependenciesMeta": {
     "@wdio/globals": {

package/types/expect-webdriverio.d.ts

@@ -22,7 +22,6 @@ type ExpectLibExpectationResult = import('expect').ExpectationResult
 type ExpectLibMatcherContext = import('expect').MatcherContext
 type MatchersObject = Parameters<typeof import('expect').expect.extend>[0]
 type ExpectLibAnything = ReturnType<typeof expect.any> | ReturnType<typeof expect.anything>
-type WdioSome<T> = import('expect-webdriverio/api').WdioSome<T>
 
 // Extracted from the expect library, this is the type of the matcher function used in the expect library.
 type RawMatcherFn<Context extends ExpectLibMatcherContext = ExpectLibMatcherContext> = {
@@ -30,6 +29,10 @@ type RawMatcherFn<Context extends ExpectLibMatcherContext = ExpectLibMatcherCont
     (this: Context, actual: any, ...expected: Array<any>): ExpectLibExpectationResult;
 }
 
+interface WdioSome<T> {
+    readonly elements: T
+}
+
 /**
  * Indicates that a value can be either one T or an array of T.
  */
@@ -1233,11 +1236,17 @@ declare namespace ExpectWebdriverIO {
             | ((headers: Record<string, string>) => boolean)
         postData?:
             | string
+            | boolean
+            | number
+            | null
             | ExpectWebdriverIO.JsonCompatible
             | ExpectWebdriverIO.PartialMatcher<string | ExpectWebdriverIO.JsonCompatible>
             | ((postData: string | undefined) => boolean)
         response?:
             | string
+            | boolean
+            | number
+            | null
             | ExpectWebdriverIO.JsonCompatible
             | ExpectWebdriverIO.PartialMatcher<string | ExpectWebdriverIO.JsonCompatible>
             | ((response: unknown) => boolean)
@@ -1274,9 +1283,6 @@ declare module 'expect-webdriverio' {
  * Required since importing from 'expect-webdriverio' can trigger double initialization.
  */
 declare module 'expect-webdriverio/api' {
-    export interface WdioSome<T> {
-        readonly elements: T
-    }
     /**
      * Quantifier modifier. Wraps a `$$()` result so that the matcher passes
      * when at least one element satisfies the condition (∃ semantics).