fix: unify server error response across interceptors

src/interceptors/ClientRequest/NodeClientRequest.ts

@@ -275,7 +275,10 @@ export class NodeClientRequest extends ClientRequest {
         // Treat them as request errors.
         if (isNodeLikeError(resolverResult.error)) {
           this.errorWith(resolverResult.error)
-        } else {
+          return this
+        }
+
+        if (resolverResult.error instanceof Error) {
           // Coerce unhandled exceptions in the "request" listeners
           // as 500 responses.
           this.respondWith(
@@ -294,8 +297,10 @@ export class NodeClientRequest extends ClientRequest {
               }
             )
           )
+          return this
         }
 
+        this.errorWith(resolverResult.error)
         return this
       }
 

src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts

@@ -99,31 +99,30 @@ export function createXMLHttpRequestProxy({
             return
           }
 
-          // Treat unhandled exceptions in the "request" listener
-          // as 500 server errors.
-          xhrRequestController.respondWith(
-            new Response(
-              JSON.stringify({
-                name: resolverResult.error.name,
-                message: resolverResult.error.message,
-                stack: resolverResult.error.stack,
-              }),
-              {
-                status: 500,
-                statusText: 'Unhandled Exception',
-                headers: {
-                  'Content-Type': 'application/json',
-                },
-              }
+          if (resolverResult.error instanceof Error) {
+            // Treat unhandled exceptions in the "request" listener
+            // as 500 server errors.
+            xhrRequestController.respondWith(
+              new Response(
+                JSON.stringify({
+                  name: resolverResult.error.name,
+                  message: resolverResult.error.message,
+                  stack: resolverResult.error.stack,
+                }),
+                {
+                  status: 500,
+                  statusText: 'Unhandled Exception',
+                  headers: {
+                    'Content-Type': 'application/json',
+                  },
+                }
+              )
             )
-          )
+            return
+          }
 
-          /**
-           * @todo Consider forwarding this error to the stderr as well
-           * since not all consumers are expecting to handle errors.
-           * If they don't, this error will be swallowed.
-           */
-          // xhrRequestController.errorWith(resolverResult.error)
+          // Otherwise, error the request with the thrown data.
+          xhrRequestController.errorWith(resolverResult.error)
           return
         }
 

src/interceptors/fetch/index.ts

@@ -142,23 +142,27 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
           return respondWith(resolverResult.error)
         }
 
-        // Treat unhandled exceptions from the "request" listeners
-        // as 500 errors from the server. Fetch API doesn't respect
-        // Node.js internal errors so no special treatment for those.
-        return new Response(
-          JSON.stringify({
-            name: resolverResult.error.name,
-            message: resolverResult.error.message,
-            stack: resolverResult.error.stack,
-          }),
-          {
-            status: 500,
-            statusText: 'Unhandled Exception',
-            headers: {
-              'Content-Type': 'application/json',
-            },
-          }
-        )
+        if (resolverResult.error instanceof Error) {
+          // Treat unhandled exceptions from the "request" listeners
+          // as 500 errors from the server. Fetch API doesn't respect
+          // Node.js internal errors so no special treatment for those.
+          return new Response(
+            JSON.stringify({
+              name: resolverResult.error.name,
+              message: resolverResult.error.message,
+              stack: resolverResult.error.stack,
+            }),
+            {
+              status: 500,
+              statusText: 'Unhandled Exception',
+              headers: {
+                'Content-Type': 'application/json',
+              },
+            }
+          )
+        }
+
+        return Promise.reject(createNetworkError(resolverResult.error))
       }
 
       const mockedResponse = resolverResult.data
@@ -177,7 +181,7 @@ export class FetchInterceptor extends Interceptor<HttpRequestEventMap> {
 
           /**
            * Set the cause of the request promise rejection to the
-           * network error Response instance. This different from Undici.
+           * network error Response instance. This differs from Undici.
            * Undici will forward the "response.error" custom property
            * as the rejection reason but for "Response.error()" static method
            * "response.error" will equal to undefined, making "cause" an empty Error.

test/modules/XMLHttpRequest/compliance/xhr-middleware-exception.test.ts

@@ -2,7 +2,7 @@
 /**
  * @see https://github.com/mswjs/msw/issues/355
  */
-import { it, expect, beforeAll, afterEach, afterAll } from 'vitest'
+import { vi, it, expect, beforeAll, afterEach, afterAll } from 'vitest'
 import axios from 'axios'
 import { XMLHttpRequestInterceptor } from '../../../../src/interceptors/XMLHttpRequest'
 import { createXMLHttpRequest } from '../../../helpers'
@@ -77,3 +77,20 @@ it('treats a thrown Response instance as a mocked response', async () => {
   expect(request.response).toBe('hello world')
   expect(request.responseText).toBe('hello world')
 })
+
+it('forwards thrown non-errors as request errors', async () => {
+  interceptor.on('request', () => {
+    throw 123
+  })
+
+  const requestErrorListener = vi.fn()
+  const request = await createXMLHttpRequest((request) => {
+    request.responseType = 'text'
+    request.open('GET', 'http://localhost/api')
+    request.addEventListener('error', requestErrorListener)
+    request.send()
+  })
+
+  expect(request.status).toBe(0)
+  expect(requestErrorListener).toHaveBeenCalledTimes(1)
+})

test/modules/fetch/fetch-exception.test.ts

@@ -45,3 +45,19 @@ it('treats a thrown Response as a mocked response', async () => {
   expect(response.status).toBe(200)
   expect(await response.text()).toBe('hello world')
 })
+
+it('treats thrown non-errors a network error', async () => {
+  interceptor.on('request', () => {
+    throw 123
+  })
+
+  const requestError = await fetch('http://localhost:3001/resource')
+    .then(() => {
+      throw new Error('Must not resolve')
+    })
+    .catch<TypeError & { cause?: unknown }>((error) => error)
+
+  expect(requestError.name).toBe('TypeError')
+  expect(requestError.message).toBe('Failed to fetch')
+  expect(requestError.cause).toBe(123)
+})

test/modules/http/compliance/http-unhandled-exception.test.ts

@@ -5,6 +5,7 @@ import { vi, it, expect, beforeAll, afterEach, afterAll } from 'vitest'
 import http from 'node:http'
 import { ClientRequestInterceptor } from '../../../../src/interceptors/ClientRequest'
 import { waitForClientRequest } from '../../../helpers'
+import { DeferredPromise } from '@open-draft/deferred-promise'
 
 const interceptor = new ClientRequestInterceptor()
 
@@ -49,3 +50,17 @@ it('treats unhandled interceptor errors as 500 responses', async () => {
     stack: expect.any(String),
   })
 })
+
+it('treats thrown non-errors as request errors', async () => {
+  interceptor.on('request', () => {
+    throw 123
+  })
+
+  const request = http.get('http://localhost/resource')
+  const requestErrorPromise = new DeferredPromise<Error>()
+  request.on('error', (error) => requestErrorPromise.resolve(error))
+
+  const requestError = await requestErrorPromise
+
+  expect(requestError).toBe(123)
+})