@fluojs/testing 1.0.6 → 3.0.0

package/dist/portability/http-adapter-portability.js

@@ -3,9 +3,11 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; }
 function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; }
-import { request as httpsRequest } from 'node:https';
-import { Controller, Get, Post, SseResponse } from '@fluojs/http';
+import { Controller, Get, Head, Post, Produces, Query, Route, SseResponse } from '@fluojs/http';
 import { defineModule } from '@fluojs/runtime';
+import { assertNetworkHttpErrorRepresentationAbortPortability } from './error-representation-abort-portability.js';
+import { assertNetworkHttpErrorRepresentationPortability } from './error-representation-portability.js';
+import { assertPortableResponseCookies, createResponseCookiePortabilityModule } from './response-cookie-portability.js';
 
 /**
  * Options for configuring the HTTP adapter portability harness.
@@ -37,6 +39,11 @@ function resolveListeningUrl(app, adapterName) {
   return target.url;
 }
 async function requestHttps(url) {
+  const [{
+    Buffer
+  }, {
+    request: httpsRequest
+  }] = await Promise.all([import('node:buffer'), import('node:https')]);
   return await new Promise((resolve, reject) => {
     const request = httpsRequest(url, {
       rejectUnauthorized: false
@@ -57,6 +64,41 @@ async function requestHttps(url) {
     request.end();
   });
 }
+async function requestCustomHttpMethod(url, method, body) {
+  const [{
+    Buffer
+  }, {
+    request: httpRequest
+  }] = await Promise.all([import('node:buffer'), import('node:http')]);
+  const target = new URL(url);
+  const hostname = target.hostname.startsWith('[') && target.hostname.endsWith(']') ? target.hostname.slice(1, -1) : target.hostname;
+  return await new Promise((resolve, reject) => {
+    const request = httpRequest({
+      headers: {
+        'content-length': String(Buffer.byteLength(body)),
+        'content-type': 'application/json'
+      },
+      hostname,
+      method,
+      path: `${target.pathname}${target.search}`,
+      port: target.port
+    }, response => {
+      const chunks = [];
+      response.on('data', chunk => {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      });
+      response.on('end', () => {
+        resolve({
+          body: Buffer.concat(chunks).toString('utf8'),
+          statusCode: response.statusCode ?? 0
+        });
+      });
+      response.on('error', reject);
+    });
+    request.on('error', reject);
+    request.end(body);
+  });
+}
 function createLogCaptureLogger() {
   const messages = [];
   const capture = (...args) => messages.push(args.map(arg => String(arg)).join(' '));
@@ -141,28 +183,289 @@ export class HttpAdapterPortabilityHarness {
     this.options = options;
   }
 
+  /** Verifies JSON, HTML, HEAD, 406, and committed error-response portability. */
+  async assertSupportsHttpErrorRepresentations() {
+    const createBootstrapOptions = this.options.createErrorRepresentationBootstrapOptions;
+    if (createBootstrapOptions === undefined) {
+      throw new Error(`${this.options.name} adapter portability harness requires createErrorRepresentationBootstrapOptions.`);
+    }
+    await assertNetworkHttpErrorRepresentationPortability({
+      bootstrap: this.options.bootstrap,
+      createBootstrapOptions,
+      name: this.options.name
+    });
+  }
+
+  /** Verifies client-disconnect abort propagation without an HTML or JSON fallback commit. */
+  async assertDoesNotCommitAbortedHttpErrorRepresentations() {
+    const createBootstrapOptions = this.options.createErrorRepresentationBootstrapOptions;
+    if (createBootstrapOptions === undefined) {
+      throw new Error(`${this.options.name} adapter portability harness requires createErrorRepresentationBootstrapOptions.`);
+    }
+    await assertNetworkHttpErrorRepresentationAbortPortability({
+      bootstrap: this.options.bootstrap,
+      createBootstrapOptions,
+      name: this.options.name
+    });
+  }
+
+  /** Verifies ordered, non-folded portable response cookies over a real listener. */
+  async assertSupportsPortableResponseCookies() {
+    const app = await this.options.bootstrap(createResponseCookiePortabilityModule(), {
+      cors: false,
+      port: 0
+    });
+    await prepareAndListenWithCleanup(app, this.options.name);
+    await runWithListeningUrlCleanup(app, this.options.name, async url => {
+      assertPortableResponseCookies(await fetch(`${url}/response-cookies`), this.options.name);
+    });
+  }
+
+  /** Verifies 304/412 metadata and body suppression through a real network listener. */
+  async assertSupportsConditionalRequests() {
+    let _initProto, _initClass;
+    const createBootstrapOptions = this.options.createConditionalRequestBootstrapOptions;
+    if (createBootstrapOptions === undefined) {
+      throw new Error(`${this.options.name} adapter portability harness requires createConditionalRequestBootstrapOptions.`);
+    }
+    let _ValidatorsController;
+    class ValidatorsController {
+      static {
+        ({
+          e: [_initProto],
+          c: [_ValidatorsController, _initClass]
+        } = _applyDecs(this, [Controller('/validators')], [[[Produces('application/json'), Get('/resource')], 2, "getResource"], [[Produces('application/json'), Head('/resource')], 2, "headResource"], [Post('/resource'), 2, "updateResource"]]));
+      }
+      constructor() {
+        _initProto(this);
+      }
+      getResource() {
+        return {
+          id: 'resource'
+        };
+      }
+      headResource() {
+        return {
+          id: 'resource'
+        };
+      }
+      updateResource() {
+        return {
+          id: 'resource'
+        };
+      }
+      static {
+        _initClass();
+      }
+    }
+    class AppModule {}
+    defineModule(AppModule, {
+      controllers: [_ValidatorsController]
+    });
+    const app = await this.options.bootstrap(AppModule, createBootstrapOptions({
+      conditionalRequest: {
+        resolve() {
+          return {
+            exists: true,
+            validators: {
+              etag: {
+                opaqueValue: 'resource-v1',
+                strength: 'strong'
+              },
+              lastModified: new Date('2026-01-01T00:00:00.750Z')
+            }
+          };
+        }
+      },
+      contentNegotiation: {
+        formatters: [{
+          format(body) {
+            return JSON.stringify(body);
+          },
+          mediaType: 'application/json'
+        }]
+      },
+      cors: false,
+      port: 0
+    }));
+    await prepareAndListenWithCleanup(app, this.options.name);
+    await runWithListeningUrlCleanup(app, this.options.name, async baseUrl => {
+      const [notModified, preconditionFailed, head] = await Promise.all([fetch(`${baseUrl}/validators/resource`, {
+        headers: {
+          'if-none-match': '"resource-v1"'
+        }
+      }), fetch(`${baseUrl}/validators/resource`, {
+        headers: {
+          'if-match': '"different-resource"'
+        },
+        method: 'POST'
+      }), fetch(`${baseUrl}/validators/resource`, {
+        headers: {
+          'if-none-match': '"resource-v1"'
+        },
+        method: 'HEAD'
+      })]);
+      if (notModified.status !== 304 || preconditionFailed.status !== 412 || head.status !== 304 || (await notModified.text()) !== '' || (await preconditionFailed.text()) !== '' || (await head.text()) !== '' || notModified.headers.get('etag') !== '"resource-v1"' || notModified.headers.get('last-modified') !== 'Thu, 01 Jan 2026 00:00:00 GMT' || notModified.headers.get('vary') !== 'Accept' || preconditionFailed.headers.get('etag') !== '"resource-v1"' || preconditionFailed.headers.get('last-modified') !== 'Thu, 01 Jan 2026 00:00:00 GMT' || head.headers.get('etag') !== '"resource-v1"' || head.headers.get('last-modified') !== 'Thu, 01 Jan 2026 00:00:00 GMT' || head.headers.get('vary') !== 'Accept') {
+        throw new Error(`${this.options.name} adapter changed conditional request response semantics.`);
+      }
+    });
+  }
+
+  /** Verifies single-byte-range metadata and payload slicing through a real network listener. */
+  async assertSupportsSingleByteRanges() {
+    let _initProto2, _initClass2;
+    const createBootstrapOptions = this.options.createConditionalRequestBootstrapOptions;
+    if (createBootstrapOptions === undefined) {
+      throw new Error(`${this.options.name} adapter portability harness requires createConditionalRequestBootstrapOptions.`);
+    }
+    let _AssetController;
+    class AssetController {
+      static {
+        ({
+          e: [_initProto2],
+          c: [_AssetController, _initClass2]
+        } = _applyDecs(this, [Controller('/assets')], [[[Produces('application/octet-stream'), Get('/logo')], 2, "getLogo"], [[Produces('application/octet-stream'), Head('/logo')], 2, "headLogo"], [[Produces('application/octet-stream'), Post('/logo')], 2, "postLogo"]]));
+      }
+      constructor() {
+        _initProto2(this);
+      }
+      getLogo() {
+        return Uint8Array.from([0, 1, 2, 3, 4, 5]);
+      }
+      headLogo() {
+        return Uint8Array.from([0, 1, 2, 3, 4, 5]);
+      }
+      postLogo() {
+        return Uint8Array.from([0, 1, 2, 3, 4, 5]);
+      }
+      static {
+        _initClass2();
+      }
+    }
+    class AppModule {}
+    defineModule(AppModule, {
+      controllers: [_AssetController]
+    });
+    const app = await this.options.bootstrap(AppModule, createBootstrapOptions({
+      conditionalRequest: {
+        resolve() {
+          return {
+            exists: true,
+            validators: {
+              etag: {
+                opaqueValue: 'asset-v1',
+                strength: 'strong'
+              },
+              lastModified: new Date('2026-01-01T00:00:00.750Z')
+            }
+          };
+        }
+      },
+      contentNegotiation: {
+        formatters: [{
+          format(body) {
+            return JSON.stringify(body);
+          },
+          mediaType: 'application/json'
+        }, {
+          format(body) {
+            if (!(body instanceof Uint8Array)) {
+              throw new Error('Expected byte-range formatter to receive a Uint8Array.');
+            }
+            return body;
+          },
+          mediaType: 'application/octet-stream'
+        }]
+      },
+      cors: false,
+      port: 0
+    }));
+    await prepareAndListenWithCleanup(app, this.options.name);
+    await runWithListeningUrlCleanup(app, this.options.name, async baseUrl => {
+      const [bounded, suffix, openEnded, malformed, multiple, unsatisfiable, head, post, matchingEtag, nonmatchingEtag, matchingDate, nonmatchingDate] = await Promise.all([fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=2-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=-2'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=3-'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'items=2-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=0-1,3-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=9-'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=2-4'
+        },
+        method: 'HEAD'
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          range: 'bytes=2-4'
+        },
+        method: 'POST'
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          'if-range': '"asset-v1"',
+          range: 'bytes=2-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          'if-range': '"different-asset"',
+          range: 'bytes=2-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          'if-range': 'Thu, 01 Jan 2026 00:00:00 GMT',
+          range: 'bytes=2-4'
+        }
+      }), fetch(`${baseUrl}/assets/logo`, {
+        headers: {
+          'if-range': 'Wed, 31 Dec 2025 23:59:59 GMT',
+          range: 'bytes=2-4'
+        }
+      })]);
+      const [boundedBytes, suffixBytes, openEndedBytes, malformedBytes, multipleBytes, unsatisfiableBody, headBody, postBytes, matchingEtagBytes, nonmatchingEtagBytes, matchingDateBytes, nonmatchingDateBytes] = await Promise.all([bounded.bytes(), suffix.bytes(), openEnded.bytes(), malformed.bytes(), multiple.bytes(), unsatisfiable.text(), head.text(), post.bytes(), matchingEtag.bytes(), nonmatchingEtag.bytes(), matchingDate.bytes(), nonmatchingDate.bytes()]);
+      if (bounded.status !== 206 || suffix.status !== 206 || openEnded.status !== 206 || malformed.status !== 200 || multiple.status !== 200 || unsatisfiable.status !== 416 || head.status !== 206 || post.status !== 201 || matchingEtag.status !== 206 || nonmatchingEtag.status !== 200 || matchingDate.status !== 206 || nonmatchingDate.status !== 200 || bounded.headers.get('accept-ranges') !== 'bytes' || bounded.headers.get('content-range') !== 'bytes 2-4/6' || bounded.headers.get('content-length') !== '3' || suffix.headers.get('content-range') !== 'bytes 4-5/6' || openEnded.headers.get('content-range') !== 'bytes 3-5/6' || openEnded.headers.get('content-length') !== '3' || unsatisfiable.headers.get('accept-ranges') !== 'bytes' || unsatisfiable.headers.get('content-range') !== 'bytes */6' || unsatisfiable.headers.get('content-length') !== '0' || unsatisfiableBody !== '' || head.headers.get('content-range') !== bounded.headers.get('content-range') || head.headers.get('content-length') !== bounded.headers.get('content-length') || headBody !== '' || matchingEtag.headers.get('content-range') !== 'bytes 2-4/6' || matchingEtag.headers.get('etag') !== '"asset-v1"' || matchingDate.headers.get('content-range') !== 'bytes 2-4/6' || matchingDate.headers.get('last-modified') !== 'Thu, 01 Jan 2026 00:00:00 GMT' || !equalByteArrays(boundedBytes, Uint8Array.from([2, 3, 4])) || !equalByteArrays(suffixBytes, Uint8Array.from([4, 5])) || !equalByteArrays(openEndedBytes, Uint8Array.from([3, 4, 5])) || !equalByteArrays(malformedBytes, Uint8Array.from([0, 1, 2, 3, 4, 5])) || !equalByteArrays(multipleBytes, Uint8Array.from([0, 1, 2, 3, 4, 5])) || !equalByteArrays(postBytes, Uint8Array.from([0, 1, 2, 3, 4, 5])) || !equalByteArrays(matchingEtagBytes, Uint8Array.from([2, 3, 4])) || !equalByteArrays(nonmatchingEtagBytes, Uint8Array.from([0, 1, 2, 3, 4, 5])) || !equalByteArrays(matchingDateBytes, Uint8Array.from([2, 3, 4])) || !equalByteArrays(nonmatchingDateBytes, Uint8Array.from([0, 1, 2, 3, 4, 5]))) {
+        throw new Error(`${this.options.name} adapter changed single byte-range or If-Range response semantics.`);
+      }
+    });
+  }
+
   /**
    * Asserts that the adapter preserves malformed cookie values without crashing
    * or incorrectly normalizing them.
    */
   async assertPreservesMalformedCookieValues() {
-    let _initProto, _initClass;
+    let _initProto3, _initClass3;
     let _CookieController;
     class CookieController {
       static {
         ({
-          e: [_initProto],
-          c: [_CookieController, _initClass]
+          e: [_initProto3],
+          c: [_CookieController, _initClass3]
         } = _applyDecs(this, [Controller('/cookies')], [[Get('/'), 2, "readCookies"]]));
       }
       constructor() {
-        _initProto(this);
+        _initProto3(this);
       }
       readCookies(_input, context) {
         return context.request.cookies;
       }
       static {
-        _initClass();
+        _initClass3();
       }
     }
     class AppModule {}
@@ -189,18 +492,78 @@ export class HttpAdapterPortabilityHarness {
       }
     });
   }
+
+  /** Verifies `QUERY` and extension-method execution through the adapter's real listener fallback. */
+  async assertSupportsCustomHttpRouteMethods() {
+    let _initProto4, _initClass4;
+    let _CustomMethodControll;
+    class CustomMethodController {
+      static {
+        ({
+          e: [_initProto4],
+          c: [_CustomMethodControll, _initClass4]
+        } = _applyDecs(this, [Controller('/custom-methods')], [[Query('/query'), 2, "query"], [Route('PURGE', '/purge'), 2, "purge"]]));
+      }
+      constructor() {
+        _initProto4(this);
+      }
+      query(_input, context) {
+        return {
+          body: context.request.body,
+          method: context.request.method
+        };
+      }
+      purge(_input, context) {
+        return {
+          body: context.request.body,
+          method: context.request.method
+        };
+      }
+      static {
+        _initClass4();
+      }
+    }
+    class AppModule {}
+    defineModule(AppModule, {
+      controllers: [_CustomMethodControll]
+    });
+    const app = await this.options.bootstrap(AppModule, {
+      cors: false,
+      port: 0
+    });
+    await prepareAndListenWithCleanup(app, this.options.name);
+    await runWithListeningUrlCleanup(app, this.options.name, async baseUrl => {
+      for (const method of ['QUERY', 'PURGE']) {
+        const body = JSON.stringify({
+          value: method.toLowerCase()
+        });
+        const response = await requestCustomHttpMethod(`${baseUrl}/custom-methods/${method.toLowerCase()}`, method, body);
+        if (response.statusCode !== 200) {
+          throw new Error(`${this.options.name} adapter changed ${method} response status semantics: received ${String(response.statusCode)}.`);
+        }
+        if (JSON.stringify(JSON.parse(response.body)) !== JSON.stringify({
+          body: {
+            value: method.toLowerCase()
+          },
+          method
+        })) {
+          throw new Error(`${this.options.name} adapter changed ${method} method or body semantics.`);
+        }
+      }
+    });
+  }
   async assertPreservesRawBodyForJsonAndText() {
-    let _initProto2, _initClass2;
+    let _initProto5, _initClass5;
     let _WebhookController;
     class WebhookController {
       static {
         ({
-          e: [_initProto2],
-          c: [_WebhookController, _initClass2]
+          e: [_initProto5],
+          c: [_WebhookController, _initClass5]
         } = _applyDecs(this, [Controller('/webhooks')], [[Post('/json'), 2, "handleJson"], [Post('/text'), 2, "handleText"]]));
       }
       constructor() {
-        _initProto2(this);
+        _initProto5(this);
       }
       handleJson(_input, context) {
         return {
@@ -215,7 +578,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass2();
+        _initClass5();
       }
     }
     class AppModule {}
@@ -265,17 +628,17 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertPreservesExactRawBodyBytesForByteSensitivePayloads() {
-    let _initProto3, _initClass3;
+    let _initProto6, _initClass6;
     let _WebhookController2;
     class WebhookController {
       static {
         ({
-          e: [_initProto3],
-          c: [_WebhookController2, _initClass3]
+          e: [_initProto6],
+          c: [_WebhookController2, _initClass6]
         } = _applyDecs(this, [Controller('/webhooks')], [[Post('/bytes'), 2, "handleBytes"]]));
       }
       constructor() {
-        _initProto3(this);
+        _initProto6(this);
       }
       handleBytes(_input, context) {
         return {
@@ -283,7 +646,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass3();
+        _initClass6();
       }
     }
     class AppModule {}
@@ -320,17 +683,17 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertExcludesRawBodyForMultipart() {
-    let _initProto4, _initClass4;
+    let _initProto7, _initClass7;
     let _UploadController;
     class UploadController {
       static {
         ({
-          e: [_initProto4],
-          c: [_UploadController, _initClass4]
+          e: [_initProto7],
+          c: [_UploadController, _initClass7]
         } = _applyDecs(this, [Controller('/uploads')], [[Post('/'), 2, "upload"]]));
       }
       constructor() {
-        _initProto4(this);
+        _initProto7(this);
       }
       upload(_input, context) {
         return {
@@ -340,7 +703,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass4();
+        _initClass7();
       }
     }
     class AppModule {}
@@ -379,17 +742,17 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertDefaultsMultipartTotalLimitToMaxBodySize() {
-    let _initProto5, _initClass5;
+    let _initProto8, _initClass8;
     let _UploadController2;
     class UploadController {
       static {
         ({
-          e: [_initProto5],
-          c: [_UploadController2, _initClass5]
+          e: [_initProto8],
+          c: [_UploadController2, _initClass8]
         } = _applyDecs(this, [Controller('/uploads')], [[Post('/'), 2, "upload"]]));
       }
       constructor() {
-        _initProto5(this);
+        _initProto8(this);
       }
       upload(_input, context) {
         return {
@@ -398,7 +761,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass5();
+        _initClass8();
       }
     }
     class AppModule {}
@@ -434,17 +797,21 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertSupportsSseStreaming() {
-    let _initProto6, _initClass6;
+    let _initProto9, _initClass9;
+    let resolveHandlerReady;
+    const handlerReady = new Promise(resolve => {
+      resolveHandlerReady = resolve;
+    });
     let _EventsController;
     class EventsController {
       static {
         ({
-          e: [_initProto6],
-          c: [_EventsController, _initClass6]
+          e: [_initProto9],
+          c: [_EventsController, _initClass9]
         } = _applyDecs(this, [Controller('/events')], [[Get('/'), 2, "stream"]]));
       }
       constructor() {
-        _initProto6(this);
+        _initProto9(this);
       }
       stream(_input, context) {
         const stream = new SseResponse(context);
@@ -455,13 +822,11 @@ export class HttpAdapterPortabilityHarness {
           event: 'ready',
           id: 'evt-1'
         });
-        queueMicrotask(() => {
-          stream.close();
-        });
+        resolveHandlerReady(stream);
         return stream;
       }
       static {
-        _initClass6();
+        _initClass9();
       }
     }
     class AppModule {}
@@ -474,21 +839,30 @@ export class HttpAdapterPortabilityHarness {
     });
     await prepareAndListenWithCleanup(app, this.options.name);
     await runWithListeningUrlCleanup(app, this.options.name, async baseUrl => {
-      const response = await fetch(`${baseUrl}/events`, {
-        headers: {
-          accept: 'text/event-stream'
+      const client = new AbortController();
+      try {
+        const responsePromise = fetch(`${baseUrl}/events`, {
+          headers: {
+            accept: 'text/event-stream'
+          },
+          signal: client.signal
+        });
+        const stream = await withTimeout(handlerReady, 2_000, `${this.options.name} adapter did not enter the SSE handler.`);
+        stream.close();
+        const response = await responsePromise;
+        const body = await withTimeout(response.text(), 2_000, `${this.options.name} adapter did not close the SSE response stream.`);
+        if (response.status !== 200) {
+          throw new Error(`${this.options.name} adapter changed SSE response status semantics.`);
         }
-      });
-      const body = await response.text();
-      if (response.status !== 200) {
-        throw new Error(`${this.options.name} adapter changed SSE response status semantics.`);
-      }
-      const contentType = response.headers.get('content-type') ?? '';
-      if (!contentType.includes('text/event-stream')) {
-        throw new Error(`${this.options.name} adapter does not expose text/event-stream content-type.`);
-      }
-      if (!body.includes('event: ready') || !body.includes('data: {"ready":true}')) {
-        throw new Error(`${this.options.name} adapter changed SSE body framing.`);
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes('text/event-stream')) {
+          throw new Error(`${this.options.name} adapter does not expose text/event-stream content-type.`);
+        }
+        if (!body.includes('event: ready') || !body.includes('data: {"ready":true}')) {
+          throw new Error(`${this.options.name} adapter changed SSE body framing.`);
+        }
+      } finally {
+        client.abort();
       }
     });
   }
@@ -498,7 +872,7 @@ export class HttpAdapterPortabilityHarness {
    * closes before a `drain` event is emitted.
    */
   async assertSettlesStreamDrainWaitOnClose() {
-    let _initProto7, _initClass7;
+    let _initProto0, _initClass0;
     const adapterName = this.options.name;
     let resolveDrainWait;
     const drainWaitSettled = new Promise(resolve => {
@@ -508,12 +882,12 @@ export class HttpAdapterPortabilityHarness {
     class EventsController {
       static {
         ({
-          e: [_initProto7],
-          c: [_EventsController2, _initClass7]
+          e: [_initProto0],
+          c: [_EventsController2, _initClass0]
         } = _applyDecs(this, [Controller('/events')], [[Get('/'), 2, "stream"]]));
       }
       constructor() {
-        _initProto7(this);
+        _initProto0(this);
       }
       async stream(_input, context) {
         const stream = new SseResponse(context);
@@ -528,7 +902,7 @@ export class HttpAdapterPortabilityHarness {
         return stream;
       }
       static {
-        _initClass7();
+        _initClass0();
       }
     }
     class AppModule {}
@@ -554,18 +928,18 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertReportsConfiguredHostInStartupLogs() {
-    let _initProto8, _initClass8;
+    let _initProto1, _initClass1;
     const logger = createLogCaptureLogger();
     let _HealthController;
     class HealthController {
       static {
         ({
-          e: [_initProto8],
-          c: [_HealthController, _initClass8]
+          e: [_initProto1],
+          c: [_HealthController, _initClass1]
         } = _applyDecs(this, [Controller('/health')], [[Get('/'), 2, "getHealth"]]));
       }
       constructor() {
-        _initProto8(this);
+        _initProto1(this);
       }
       getHealth() {
         return {
@@ -573,7 +947,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass8();
+        _initClass1();
       }
     }
     class AppModule {}
@@ -603,18 +977,18 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertReportsHttpsStartupUrl(https) {
-    let _initProto9, _initClass9;
+    let _initProto10, _initClass10;
     const logger = createLogCaptureLogger();
     let _HealthController2;
     class HealthController {
       static {
         ({
-          e: [_initProto9],
-          c: [_HealthController2, _initClass9]
+          e: [_initProto10],
+          c: [_HealthController2, _initClass10]
         } = _applyDecs(this, [Controller('/health')], [[Get('/'), 2, "getHealth"]]));
       }
       constructor() {
-        _initProto9(this);
+        _initProto10(this);
       }
       getHealth() {
         return {
@@ -622,7 +996,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass9();
+        _initClass10();
       }
     }
     class AppModule {}
@@ -652,7 +1026,7 @@ export class HttpAdapterPortabilityHarness {
     });
   }
   async assertRemovesShutdownSignalListenersAfterClose() {
-    let _initProto0, _initClass0;
+    let _initProto11, _initClass11;
     const logger = {
       debug() {},
       error() {},
@@ -663,12 +1037,12 @@ export class HttpAdapterPortabilityHarness {
     class HealthController {
       static {
         ({
-          e: [_initProto0],
-          c: [_HealthController3, _initClass0]
+          e: [_initProto11],
+          c: [_HealthController3, _initClass11]
         } = _applyDecs(this, [Controller('/health')], [[Get('/'), 2, "getHealth"]]));
       }
       constructor() {
-        _initProto0(this);
+        _initProto11(this);
       }
       getHealth() {
         return {
@@ -676,7 +1050,7 @@ export class HttpAdapterPortabilityHarness {
         };
       }
       static {
-        _initClass0();
+        _initClass11();
       }
     }
     class AppModule {}
@@ -717,6 +1091,9 @@ export class HttpAdapterPortabilityHarness {
 export function createHttpAdapterPortabilityHarness(options) {
   return new HttpAdapterPortabilityHarness(options);
 }
+function equalByteArrays(left, right) {
+  return left.byteLength === right.byteLength && left.every((value, index) => value === right[index]);
+}
 async function withTimeout(promise, timeoutMs, message) {
   let timeout;
   const timeoutPromise = new Promise((_resolve, reject) => {