fix(toBeRequestedWith): restore postData/response body matching (#2184)

* fix(toBeRequestedWith): restore postData/response body matching

* fix(toBeRequestedWith): require webdriverio ^9.28.0 and explain uncollected bodies

* test(playgrounds): cover postData/response assertions in mocha e2e

Author: mccmrunal

docs/API.md

@@ -871,6 +871,18 @@ await expect(mock).toBeRequestedWith({
 })
 ```
 
+> **Note on `postData`/`response` timing:** unlike the other options, the request/response body is
+> collected asynchronously (an extra round-trip after the request/response headers are already
+> available), so it may not be attached to a call yet at the very first check. Regular assertions
+> retry within their `wait` timeout and pick it up once it arrives. `.not.toBeRequestedWith({ postData
+> / response })` also retries within `wait` - but only while there's a call that already matches every
+> other criterion and is just waiting on its body to attach; if nothing matches at all (wrong URL, no
+> call made, etc.) it still resolves immediately, same as any other `.not` assertion. The one residual
+> case this can't close: if the body genuinely takes longer to arrive than your configured `wait`, a
+> `.not` assertion can still report a false pass. If you rely on `.not` with `postData`/`response` and
+> see intermittent false passes, increase `wait` (or await a signal that the request has fully
+> completed) before asserting.
+
 ## Snapshot Matcher
 
 WebdriverIO supports basic snapshot tests as well as DOM snapshot testing.

package.json

@@ -113,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": {

playgrounds/jasmine/wdio.conf.ts

@@ -67,7 +67,8 @@ export const config: WebdriverIO.Config = {
     //
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     before: function (_capabilities, _specs) {
-        setOptions({ wait: 500 })
+        // 500ms wasn't enough headroom for `postData`/`response` collection (an async
+        setOptions({ wait: 2000 })
     },
     afterTest: function (_test, _context, { error }) {
         if (error) {

playgrounds/mocha/test/specs/network-matchers.test.ts

@@ -96,4 +96,58 @@ describe('Network Matchers', () => {
     it('should throw an error when asserting not be requested', async () => {
         await expect(expect(mock).not.toBeRequested()).rejects.toThrow()
     })
+
+    /**
+     * `postData`/`response` were silently ignored before #2184 - any assertion on them passed
+     * regardless of the real payload. These cover the restored comparison end-to-end.
+     *
+     * Note: `mock.calls[n].body` is the *upstream* response, not `mock.respond()`'s override
+     * (respond changes what the page receives; the collector still records what the server sent).
+     * So `response` is asserted structurally rather than against the mocked value.
+     */
+    it('should assert on postData', async () => {
+        await expect(mock).toBeRequestedWith({
+            method: 'POST',
+            postData: { title: 'foo', description: 'bar' }
+        })
+    })
+
+    it('should assert on postData with an asymmetric matcher', async () => {
+        await expect(mock).toBeRequestedWith({
+            postData: expect.objectContaining({ title: 'foo' })
+        })
+    })
+
+    it('should assert on postData with a function matcher', async () => {
+        await expect(mock).toBeRequestedWith({
+            postData: (postData) => typeof postData === 'string' && postData.includes('description')
+        })
+    })
+
+    it('should FAIL when postData does not match', async () => {
+        // the regression guard: this silently passed before the fix
+        await expect(
+            expect(mock).toBeRequestedWith({ postData: { title: 'WRONG' } })
+        ).rejects.toThrow()
+    })
+
+    it('should FAIL when postData is expected but the request had none', async () => {
+        const getMock = await browser.mock('https://webdriver.io/**', { method: 'GET' })
+        await browser.url('https://webdriver.io/')
+        await expect(
+            expect(getMock).toBeRequestedWith({ postData: { any: 'thing' } })
+        ).rejects.toThrow()
+    })
+
+    it('should assert that a response body was collected', async () => {
+        await expect(mock).toBeRequestedWith({
+            response: (response) => typeof response === 'string' && response.length > 0
+        })
+    })
+
+    it('should FAIL when response does not match', async () => {
+        await expect(
+            expect(mock).toBeRequestedWith({ response: { definitely: 'not-this' } })
+        ).rejects.toThrow()
+    })
 })