Add gzip, deflate, brotli, ztsd & identity encoding endpoints

These are at a different path to httpbin's, partly because it's tidier
and partly because they're not fully compatible (they return fixed data,
not the full request details in encoded form).

Author: pimterry

package-lock.json

@@ -42,7 +42,7 @@
     "@types/chai": "^4.3.14",
     "@types/lodash": "^4.17.0",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^20.11.30",
+    "@types/node": "^22.15.30",
     "@types/node-forge": "^1.3.11",
     "chai": "^5.1.0",
     "destroyable-server": "^1.0.1",

package.json

@@ -37,4 +37,9 @@ export * from './http/trailers.js';
 export * from './http/error/close.js';
 export * from './http/error/reset.js';
 export * from './http/example-page.js';
-export * from './http/version.js';
+export * from './http/version.js';
+export * from './http/encoding/gzip.js';
+export * from './http/encoding/deflate.js';
+export * from './http/encoding/zstd.js';
+export * from './http/encoding/brotli.js';
+export * from './http/encoding/identity.js';

src/endpoints/http-index.ts

@@ -0,0 +1,28 @@
+import * as zlib from 'node:zlib';
+import { serializeJson } from '../../../util.js';
+import { HttpEndpoint, HttpHandler } from '../../http-index.js';
+
+// We pre-decode the data. Note that this differs from HTTPBin which returns
+// dynamic data here - for this reason, we use a subdirectory. Dynamic encoding
+// is relatively expensive so we don't want that. Instead we just use the same
+// static data every time, including only a 'brotli' field (which does match
+// HTTPBin at least, for that one field).
+const data = zlib.brotliCompressSync(serializeJson({
+    brotli: true
+}));
+
+const matchPath = (path: string) => path === '/encoding/brotli';
+
+const handle: HttpHandler = (req, res) => {
+    res.writeHead(200, {
+        'content-type': 'application/json',
+        'content-encoding': 'br'
+    });
+
+    res.end(data);
+}
+
+export const brotli: HttpEndpoint = {
+    matchPath,
+    handle
+};

src/endpoints/http/encoding/brotli.ts

@@ -0,0 +1,27 @@
+import * as zlib from 'node:zlib';
+import { serializeJson } from '../../../util.js';
+import { HttpEndpoint, HttpHandler } from '../../http-index.js';
+
+// We pre-decode the data. Note that this differs from HTTPBin which returns
+// dynamic data here - for this reason, we use a subdirectory. Dynamic encoding
+// is relatively expensive so we don't want that. Instead we just use the same
+// static data every time, including only a 'deflate' field.
+const data = zlib.deflateSync(serializeJson({
+    deflate: true
+}));
+
+const matchPath = (path: string) => path === '/encoding/deflate';
+
+const handle: HttpHandler = (req, res) => {
+    res.writeHead(200, {
+        'content-type': 'application/json',
+        'content-encoding': 'deflate'
+    });
+
+    res.end(data);
+}
+
+export const deflate: HttpEndpoint = {
+    matchPath,
+    handle
+};

src/endpoints/http/encoding/deflate.ts

@@ -0,0 +1,28 @@
+import * as zlib from 'node:zlib';
+import { serializeJson } from '../../../util.js';
+import { HttpEndpoint, HttpHandler } from '../../http-index.js';
+
+// We pre-decode the data. Note that this differs from HTTPBin which returns
+// dynamic data here - for this reason, we use a subdirectory. Dynamic encoding
+// is relatively expensive so we don't want that. Instead we just use the same
+// static data every time, including only a 'gzipped' field (which does match
+// HTTPBin at least, for that one field).
+const data = zlib.gzipSync(serializeJson({
+    gzipped: true
+}));
+
+const matchPath = (path: string) => path === '/encoding/gzip';
+
+const handle: HttpHandler = (req, res) => {
+    res.writeHead(200, {
+        'content-type': 'application/json',
+        'content-encoding': 'gzip'
+    });
+
+    res.end(data);
+}
+
+export const gzip: HttpEndpoint = {
+    matchPath,
+    handle
+};

src/endpoints/http/encoding/gzip.ts

@@ -0,0 +1,26 @@
+import { serializeJson } from '../../../util.js';
+import { HttpEndpoint, HttpHandler } from '../../http-index.js';
+
+// We pre-decode the data. Note that this differs from HTTPBin which returns
+// dynamic data here - for this reason, we use a subdirectory. Dynamic encoding
+// is relatively expensive so we don't want that. Instead we just use the same
+// static data every time, including only an 'identity' field.
+const data = serializeJson({
+    identity: true
+});
+
+const matchPath = (path: string) => path === '/encoding/identity';
+
+const handle: HttpHandler = (req, res) => {
+    res.writeHead(200, {
+        'content-type': 'application/json',
+        'content-encoding': 'identity'
+    });
+
+    res.end(data);
+}
+
+export const identity: HttpEndpoint = {
+    matchPath,
+    handle
+};

src/endpoints/http/encoding/identity.ts

@@ -0,0 +1,27 @@
+import * as zlib from 'node:zlib';
+import { serializeJson } from '../../../util.js';
+import { HttpEndpoint, HttpHandler } from '../../http-index.js';
+
+// We pre-decode the data. Note that this differs from HTTPBin which returns
+// dynamic data here - for this reason, we use a subdirectory. Dynamic encoding
+// is relatively expensive so we don't want that. Instead we just use the same
+// static data every time, including only a 'zstd' field.
+const data = zlib.zstdCompressSync(serializeJson({
+    zstd: true
+}));
+
+const matchPath = (path: string) => path === '/encoding/zstd';
+
+const handle: HttpHandler = (req, res) => {
+    res.writeHead(200, {
+        'content-type': 'application/json',
+        'content-encoding': 'zstd'
+    });
+
+    res.end(data);
+}
+
+export const zstd: HttpEndpoint = {
+    matchPath,
+    handle
+};

src/endpoints/http/encoding/zstd.ts

@@ -0,0 +1,63 @@
+import * as net from 'node:net';
+import * as zlib from 'node:zlib';
+import { expect } from 'chai';
+import { DestroyableServer, makeDestroyable } from 'destroyable-server';
+
+import { createServer } from '../src/server.js';
+
+describe('Encoding Endpoints', () => {
+
+    let server: DestroyableServer;
+    let serverPort: number;
+
+    beforeEach(async () => {
+        server = makeDestroyable(await createServer());
+        await new Promise<void>((resolve) => server.listen(resolve));
+        serverPort = (server.address() as net.AddressInfo).port;
+    });
+
+    afterEach(async () => {
+        await server.destroy();
+    });
+
+    const testCases = [
+        {
+            name: 'gzip',
+            expectedJson: { gzipped: true }
+        },
+        {
+            name: 'deflate',
+            expectedJson: { deflate: true }
+        },
+        {
+            name: 'brotli',
+            encodingName: 'br',
+            expectedJson: { brotli: true }
+        },
+        {
+            name: 'zstd',
+            expectedJson: { zstd: true },
+            decoder: zlib.zstdDecompressSync
+        },
+        {
+            name: 'identity',
+            expectedJson: { identity: true }
+        }
+    ];
+
+    testCases.forEach(({ name, encodingName, expectedJson, decoder }) => {
+        it(`/encoding/${name} should return decodeable content`, async () => {
+            const url = `http://localhost:${serverPort}/encoding/${name}`;
+            const response = await fetch(url);
+
+            expect(response.status).to.equal(200);
+            expect(response.headers.get('content-encoding')).to.equal(encodingName || name);
+
+            const actualJson = decoder
+                ? JSON.parse(decoder(await response.arrayBuffer()).toString('utf8'))
+                : await response.json(); // Decodeable by fetch automatically
+
+            expect(actualJson).to.deep.equals(expectedJson);
+        });
+    });
+});