fix(ClientRequest): allow GET requests with body (#715)

Co-authored-by: Michael Solomon <github@tltv.co.il>

Author: kettanaito

src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -488,22 +488,20 @@ export class MockHttpSocket extends MockSocket {
     // If this Socket is reused for multiple requests,
     // this ensures that each request gets its own stream.
     // One Socket instance can only handle one request at a time.
-    if (canHaveBody) {
-      this.requestStream = new Readable({
-        /**
-         * @note Provide the `read()` method so a `Readable` could be
-         * used as the actual request body (the stream calls "read()").
-         * We control the queue in the onRequestBody/End functions.
-         */
-        read: () => {
-          // If the user attempts to read the request body,
-          // flush the write buffer to trigger the callbacks.
-          // This way, if the request stream ends in the write callback,
-          // it will indeed end correctly.
-          this.flushWriteBuffer()
-        },
-      })
-    }
+    this.requestStream = new Readable({
+      /**
+       * @note Provide the `read()` method so a `Readable` could be
+       * used as the actual request body (the stream calls "read()").
+       * We control the queue in the onRequestBody/End functions.
+       */
+      read: () => {
+        // If the user attempts to read the request body,
+        // flush the write buffer to trigger the callbacks.
+        // This way, if the request stream ends in the write callback,
+        // it will indeed end correctly.
+        this.flushWriteBuffer()
+      },
+    })
 
     const requestId = createRequestId()
     this.request = new Request(url, {

test/modules/WebSocket/compliance/websocket.events.test.ts

@@ -236,13 +236,13 @@ it('emits "error" event on passthrough client connection failure', async () => {
     expect(errorListener).toHaveBeenCalledTimes(1)
   })
 
+  expect(ws.readyState).toBe(ws.CLOSED)
   expect(openListener).not.toHaveBeenCalled()
   /**
    * @note The update in `ws` makes it dispatch the "close" event
    * if the handshake receives a network error (or non-101 response).
    */
   expect(closeListener).toHaveBeenCalledOnce()
-  expect(ws.readyState).toBe(ws.CLOSED)
 })
 
 it('does not emit "error" event on mocked error code closures', async () => {

test/modules/http/compliance/http-req-get-with-body.test.ts

@@ -0,0 +1,76 @@
+/**
+ * @see https://github.com/nock/nock/issues/2826
+ */
+import { it, expect, beforeAll, afterAll } from 'vitest'
+import http from 'node:http'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { waitForClientRequest } from '../../../helpers'
+import { ClientRequestInterceptor } from '../../../../src/interceptors/ClientRequest'
+
+const interceptor = new ClientRequestInterceptor()
+
+const httpServer = new http.Server((req, res) => {
+  if (req.url === '/resource') {
+    req.pipe(res)
+    return
+  }
+
+  res.statusCode = 404
+  res.end()
+})
+
+beforeAll(async () => {
+  interceptor.apply()
+  const serverListenPromise = new DeferredPromise<void>()
+  httpServer.listen(52203, '127.0.0.1', () => {
+    serverListenPromise.resolve()
+  })
+  await serverListenPromise
+})
+
+afterAll(() => {
+  interceptor.removeAllListeners()
+})
+
+afterAll(async () => {
+  interceptor.dispose()
+  const serverClosePromise = new DeferredPromise<void>()
+  httpServer.close((error) => {
+    if (error) {
+      serverClosePromise.reject(error)
+    }
+    serverClosePromise.resolve()
+  })
+  await serverClosePromise
+})
+
+it('allows an HTTP GET request with a body', async () => {
+  const interceptedRequestPromise = new DeferredPromise<Request>()
+
+  interceptor.on('request', ({ request }) => {
+    interceptedRequestPromise.resolve(request)
+  })
+
+  const request = http.request('http://127.0.0.1:52203/resource', {
+    method: 'GET',
+    headers: {
+      'content-type': 'text/plain',
+      'content-length': '11',
+    },
+  })
+
+  /**
+   * @note Although it is invalid to have GET requests with a body
+   * per Fetch API specification, you should still be able to perform
+   * such requests in Node.js without the library throwing an error.
+   */
+  request.write('hello world')
+  request.end()
+
+  const { text } = await waitForClientRequest(request)
+  await expect(text()).resolves.toBe('hello world')
+
+  const interceptedRequest = await interceptedRequestPromise
+  // The Fetch API representation of this request must NOT have any body.
+  expect(interceptedRequest.body).toBeNull()
+})