@dunx/testing 3.2.0 → 3.3.0

package/dist/http2.d.ts

@@ -0,0 +1,36 @@
+import type { JsonInit, JsonResponse } from './client.js';
+/**
+ * One HTTP/2 request against a cleartext origin, and the JSON round-trip beside
+ * it - the same pair `testClient` gives for HTTP/1.1.
+ *
+ * It exists because **Bun's `fetch` cannot call an h2c origin**: both
+ * `protocol: 'http2'` and `protocol: 'h2'` reject with `HTTP2Unsupported`
+ * against any plain-HTTP peer, whatever that peer serves. `node:http2` opens
+ * with the connection preface instead, which is the "prior knowledge" path
+ * `Bun.serve({ http2: true })` answers.
+ *
+ * A connection per call, which is what a test wants: the assertion is about the
+ * server, and a pooled session would carry state between cases.
+ */
+export interface Http2Client {
+    /** The origin these requests go to. */
+    readonly url: string;
+    /** Status, headers and the raw body text. */
+    request(path?: string, init?: JsonInit): Promise<Http2Response>;
+    /** Status, headers and the parsed body, for the common assertion. */
+    json<T = unknown>(path?: string, init?: JsonInit): Promise<JsonResponse<T>>;
+}
+export interface Http2Response {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly text: string;
+}
+/**
+ * ```ts
+ * const server = await createTestServer({ modules: [AppModule], http2: true });
+ * const h2 = http2Client(server.url);
+ *
+ * expect((await h2.json('/users')).status).toBe(200);
+ * ```
+ */
+export declare const http2Client: (url: string, timeoutMs?: number) => Http2Client;

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { createTestApp, testRoot, type TestAppOptions } from './app.js';
 export { testClient, type JsonInit, type JsonResponse, type TestClient, } from './client.js';
+export { http2Client, type Http2Client, type Http2Response } from './http2.js';
 export { RecordingLogger, type RecordedLog } from './logger.js';
 export { createTestServer, type TestServer, type TestServerOptions, } from './server.js';

package/dist/index.js

@@ -47,6 +47,97 @@ That is not JSON - use request() ` + "for a response that is not.");
     }
   }
 });
+// src/http2.ts
+import http2 from "http2";
+var toBody = (init) => {
+  if (init.json !== undefined)
+    return JSON.stringify(init.json);
+  const { body } = init;
+  if (body === undefined || body === null)
+    return;
+  if (typeof body === "string" || ArrayBuffer.isView(body))
+    return body;
+  if (body instanceof ArrayBuffer)
+    return new Uint8Array(body);
+  throw new TypeError("http2Client takes a string, bytes, or `json` - not " + `${body.constructor.name}. Serialise it first, or use \`testClient\` ` + "over HTTP/1.1.");
+};
+var headerBlock = (path, init, body) => {
+  const headers = new Headers(init.headers);
+  if (init.json !== undefined && !headers.has("content-type")) {
+    headers.set("content-type", "application/json");
+  }
+  const block = {
+    ":path": path,
+    ":method": init.method ?? (body === undefined ? "GET" : "POST")
+  };
+  headers.forEach((value, key) => {
+    block[key] = value;
+  });
+  return block;
+};
+var send = (origin, path, init, timeoutMs) => new Promise((resolve, reject) => {
+  let body;
+  try {
+    body = toBody(init);
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  const client = http2.connect(origin);
+  const timer = setTimeout(() => {
+    client.destroy();
+    reject(new Error(`HTTP/2 ${path} timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  const fail = (error) => {
+    clearTimeout(timer);
+    client.destroy();
+    reject(error);
+  };
+  client.on("error", fail);
+  const request = client.request(headerBlock(path, init, body));
+  const headers = new Headers;
+  let status = 0;
+  let text = "";
+  request.setEncoding("utf8");
+  request.on("response", (received) => {
+    status = Number(received[":status"]);
+    for (const [key, value] of Object.entries(received)) {
+      if (key.startsWith(":") || value === undefined)
+        continue;
+      headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+    }
+  });
+  request.on("data", (chunk) => {
+    text += chunk;
+  });
+  request.on("error", fail);
+  request.on("end", () => {
+    clearTimeout(timer);
+    client.close();
+    resolve({ status, headers, text });
+  });
+  request.end(body);
+});
+var http2Client = (url, timeoutMs = 4000) => {
+  const origin = new URL(url).origin;
+  const at = (path) => {
+    const target = new URL(path, url);
+    return `${target.pathname}${target.search}`;
+  };
+  const request = (path = "/", init = {}) => send(origin, at(path), init, timeoutMs);
+  return {
+    url: origin,
+    request,
+    async json(path = "/", init = {}) {
+      const response = await request(path, init);
+      return {
+        status: response.status,
+        headers: response.headers,
+        body: response.text === "" ? undefined : JSON.parse(response.text)
+      };
+    }
+  };
+};
 // src/logger.ts
 import { Logger, LogLevel } from "@dunx/core";
 
@@ -146,6 +237,7 @@ var createTestServer = async (options) => {
   return {
     ...testClient(await app.listen()),
     app,
+    gatewayUrl: app.gatewayUrl,
     close: () => app.shutdown()
   };
 };
@@ -153,6 +245,7 @@ export {
   RecordingLogger,
   createTestApp,
   createTestServer,
+  http2Client,
   testClient,
   testRoot
 };

package/dist/server.d.ts

@@ -14,6 +14,11 @@ export interface TestServerOptions extends TestAppOptions, Omit<HttpOptions, 'po
 }
 export interface TestServer extends TestClient {
     readonly app: HttpApp;
+    /**
+     * Where the gateways answer, when `gatewayPort` split them off `url`.
+     * `undefined` otherwise, which is when they are on `url` itself.
+     */
+    readonly gatewayUrl: string | undefined;
     /** `app.shutdown()` - stops the server, then tears the container down. */
     close(): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/testing",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Test harness for dunx apps: a container with providers replaced in place, and a real Bun.serve on port 0",
   "keywords": [
     "bun",
@@ -51,9 +51,9 @@
     "@dunx/http": "workspace:*"
   },
   "peerDependencies": {
-    "@dunx/core": "^3.2.0",
-    "@dunx/http": "^3.2.0",
-    "@types/bun": ">=1.3.0"
+    "@dunx/core": "^3.3.0",
+    "@dunx/http": "^3.3.0",
+    "@types/bun": ">=1.4.1"
   },
   "peerDependenciesMeta": {
     "@types/bun": {
@@ -61,6 +61,6 @@
     }
   },
   "engines": {
-    "bun": ">=1.4.0"
+    "bun": ">=1.4.1"
   }
 }