@gjsify/http2 0.3.20 → 0.4.0

package/src/http2.gjs.spec.ts

@@ -1,35 +1,68 @@
 // GJS-only integration tests for http2 server + client (Soup.Server / Soup.Session backed)
 // These tests only run on GJS since they require Soup 3.0.
 // Wrapped in on('Gjs') — not executed on Node.js.
+//
+// Phase-2 tests (pushStream, respondWithFD, respondWithFile) ported from:
+//   refs/node-test/parallel/test-http2-server-push-stream.js   (MIT, Node.js contributors)
+//   refs/node-test/parallel/test-http2-respond-file.js         (MIT, Node.js contributors)
+//   refs/node-test/parallel/test-http2-respond-file-fd.js      (MIT, Node.js contributors)
+// Rewritten for @gjsify/unit — behavior preserved, assertion dialect adapted.
+//
+// Type strategy (Workstream G): runtime values come from `node:http2` so the Node
+// bundle stays free of `gi://*` imports (this file is loaded by the same `test.mts`
+// aggregator that also drives `test:node`, even though the suite body is no-op on
+// Node via `on('Gjs', …)`). For static typing we pull the impl-private classes from
+// `@gjsify/http2` via type-only imports — stripped at compile time, so the Node
+// bundle is unaffected, but TypeScript sees the real shapes (`Http2Server`,
+// `Http2ServerRequest/Response`, `ClientHttp2Session/Stream`) and the entire
+// `as any` chain that `@types/node`'s narrower declarations would force disappears.
 
 import { describe, it, expect, on } from '@gjsify/unit';
 import http2 from 'node:http2';
+import { writeFileSync, openSync, closeSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import type {
+  Http2Server,
+  Http2ServerRequest,
+  Http2ServerResponse,
+  ClientHttp2Session,
+  ClientHttp2Stream,
+  ServerHttp2Stream,
+} from '@gjsify/http2';
+
+// Local view of `node:http2`'s default export retyped against our impl-private
+// classes. `node:http2` is the runtime source on both Node and GJS (alias-mapped
+// to `@gjsify/http2` on the GJS target by the build), but its declarations come
+// from `@types/node` and don't expose the GJS-only shapes we want to assert
+// against. This cast is the single boundary between the two views.
+const gjsHttp2 = http2 as unknown as {
+  createServer(handler?: (req: Http2ServerRequest, res: Http2ServerResponse) => void): Http2Server;
+  connect(authority: string): ClientHttp2Session;
+};
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
-type AnyServer = ReturnType<typeof http2.createServer>;
-type AnyStream = ReturnType<ReturnType<typeof http2.connect>['request']>;
-
 function withServer(
-  handler: (req: any, res: any) => void,
-): Promise<{ server: AnyServer; port: number }> {
+  handler: (req: Http2ServerRequest, res: Http2ServerResponse) => void,
+): Promise<{ server: Http2Server; port: number }> {
   return new Promise((resolve, reject) => {
-    const server = http2.createServer(handler);
+    const server = gjsHttp2.createServer(handler);
     server.once('error', reject);
     server.listen(0, () => {
-      const port = (server.address() as any)?.port;
+      const port = server.address()?.port;
       if (!port) return reject(new Error('Could not get server port'));
       resolve({ server, port });
     });
   });
 }
 
-function collectBody(stream: AnyStream): Promise<string> {
+function collectBody(stream: ClientHttp2Stream): Promise<string> {
   return new Promise((resolve, reject) => {
     const chunks: Buffer[] = [];
-    (stream as any).on('data', (chunk: Buffer) => chunks.push(chunk));
-    (stream as any).on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-    (stream as any).on('error', reject);
+    stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+    stream.on('error', reject);
   });
 }
 
@@ -38,32 +71,32 @@ function collectBody(stream: AnyStream): Promise<string> {
 export default async () => {
   await on('Gjs', async () => {
 
-    await describe('http2.createServer()', async () => {
+    await describe('gjsHttp2.createServer()', async () => {
       await it('returns an server instance with listen/close', async () => {
-        const server = http2.createServer();
+        const server = gjsHttp2.createServer();
         expect(server).toBeDefined();
-        expect(typeof (server as any).listen).toBe('function');
-        expect(typeof (server as any).close).toBe('function');
+        expect(typeof server.listen).toBe('function');
+        expect(typeof server.close).toBe('function');
       });
 
       await it('listen() starts listening and emits listening', async () => {
-        const server = http2.createServer();
+        const server = gjsHttp2.createServer();
         await new Promise<void>((resolve, reject) => {
-          (server as any).once('error', reject);
-          (server as any).listen(0, resolve);
+          server.once('error', reject);
+          server.listen(0, resolve);
         });
-        expect((server as any).listening).toBeTruthy();
-        const addr = (server as any).address();
+        expect(server.listening).toBeTruthy();
+        const addr = server.address();
         expect(addr).toBeDefined();
-        expect(addr.port > 0).toBeTruthy();
-        (server as any).close();
+        expect((addr?.port ?? 0) > 0).toBeTruthy();
+        server.close();
       });
 
       await it('close() stops listening', async () => {
-        const server = http2.createServer();
-        await new Promise<void>((res) => (server as any).listen(0, res));
-        await new Promise<void>((res) => (server as any).close(res));
-        expect((server as any).listening).toBeFalsy();
+        const server = gjsHttp2.createServer();
+        await new Promise<void>((res) => server.listen(0, res));
+        await new Promise<void>((res) => server.close(() => res()));
+        expect(server.listening).toBeFalsy();
       });
     });
 
@@ -77,17 +110,17 @@ export default async () => {
           res.end();
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
-        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true } as any);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true });
 
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', () => resolve());
-          (stream as any).on('error', reject);
+          stream.on('response', () => resolve());
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
 
         session.close();
-        (server as any).close();
+        server.close();
       });
 
       await it('req.method and req.url are populated', async () => {
@@ -101,15 +134,15 @@ export default async () => {
           res.end();
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request(
           { ':method': 'GET', ':path': '/hello?foo=bar' },
-          { endStream: true } as any,
+          { endStream: true },
         );
 
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', () => resolve());
-          (stream as any).on('error', reject);
+          stream.on('response', () => resolve());
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
 
@@ -117,7 +150,7 @@ export default async () => {
         expect(capturedUrl).toBe('/hello?foo=bar');
 
         session.close();
-        (server as any).close();
+        server.close();
       });
 
       await it('req.headers contains custom request headers', async () => {
@@ -129,22 +162,22 @@ export default async () => {
           res.end();
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request(
           { ':method': 'GET', ':path': '/', 'x-custom': 'test-value' },
-          { endStream: true } as any,
+          { endStream: true },
         );
 
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', () => resolve());
-          (stream as any).on('error', reject);
+          stream.on('response', () => resolve());
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
 
         expect(capturedHeaders['x-custom']).toBe('test-value');
 
         session.close();
-        (server as any).close();
+        server.close();
       });
     });
 
@@ -155,15 +188,15 @@ export default async () => {
           res.end('Hello HTTP/2');
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request(
           { ':method': 'GET', ':path': '/' },
-          { endStream: true } as any,
+          { endStream: true },
         );
 
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', () => resolve());
-          (stream as any).on('error', reject);
+          stream.on('response', () => resolve());
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
         const body = await collectBody(stream);
@@ -171,7 +204,7 @@ export default async () => {
         expect(body).toBe('Hello HTTP/2');
 
         session.close();
-        (server as any).close();
+        server.close();
       });
 
       await it(':status is included in response headers', async () => {
@@ -180,19 +213,19 @@ export default async () => {
           res.end('created');
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request(
           { ':method': 'POST', ':path': '/items' },
-          { endStream: true } as any,
+          { endStream: true },
         );
 
         let responseHeaders: Record<string, string | string[]> = {};
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', (headers: any) => {
+          stream.on('response', (headers: Record<string, string | string[]>) => {
             responseHeaders = headers;
             resolve();
           });
-          (stream as any).on('error', reject);
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
         await collectBody(stream);
@@ -200,7 +233,7 @@ export default async () => {
         expect(responseHeaders[':status']).toBe('201');
 
         session.close();
-        (server as any).close();
+        server.close();
       });
     });
 
@@ -218,26 +251,26 @@ export default async () => {
           res.end('ok');
         });
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request({
           ':method': 'POST',
           ':path': '/upload',
           'content-type': 'text/plain',
         });
 
-        (stream as any).write('Hello');
-        (stream as any).end(' World');
+        stream.write('Hello');
+        stream.end(' World');
 
         await new Promise<void>((resolve, reject) => {
-          (stream as any).on('response', () => resolve());
-          (stream as any).on('error', reject);
+          stream.on('response', () => resolve());
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
 
         expect(capturedBody).toBe('Hello World');
 
         session.close();
-        (server as any).close();
+        server.close();
       });
     });
 
@@ -245,8 +278,8 @@ export default async () => {
       await it('server emits stream event with headers', async () => {
         let streamEventFired = false;
 
-        const server = http2.createServer();
-        (server as any).on('stream', (stream: any, headers: any) => {
+        const server = gjsHttp2.createServer();
+        server.on('stream', (stream: ServerHttp2Stream, headers: Record<string, string | string[]>) => {
           streamEventFired = true;
           expect(stream).toBeDefined();
           expect(typeof stream.respond).toBe('function');
@@ -255,21 +288,21 @@ export default async () => {
           stream.end('stream API response');
         });
 
-        await new Promise<void>((res) => (server as any).listen(0, res));
-        const port = (server as any).address()?.port ?? 0;
+        await new Promise<void>((res) => server.listen(0, res));
+        const port = server.address()?.port ?? 0;
 
-        const session = http2.connect(`http://localhost:${port}`);
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
         const stream = session.request(
           { ':method': 'GET', ':path': '/' },
-          { endStream: true } as any,
+          { endStream: true },
         );
 
         const body = await new Promise<string>((resolve, reject) => {
           const chunks: Buffer[] = [];
-          (stream as any).on('response', () => {});
-          (stream as any).on('data', (chunk: Buffer) => chunks.push(chunk));
-          (stream as any).on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-          (stream as any).on('error', reject);
+          stream.on('response', () => {});
+          stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+          stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+          stream.on('error', reject);
           setTimeout(() => reject(new Error('timeout')), 5000);
         });
 
@@ -277,13 +310,13 @@ export default async () => {
         expect(streamEventFired).toBeTruthy();
 
         session.close();
-        (server as any).close();
+        server.close();
       });
     });
 
-    await describe('http2.connect()', async () => {
+    await describe('gjsHttp2.connect()', async () => {
       await it('returns a session with request() method', async () => {
-        const session = http2.connect('http://localhost:19999');
+        const session: ClientHttp2Session = gjsHttp2.connect('http://localhost:19999');
         expect(session).toBeDefined();
         expect(typeof session.request).toBe('function');
         expect(typeof session.close).toBe('function');
@@ -291,11 +324,320 @@ export default async () => {
       });
 
       await it('session.request() returns a stream with on()', async () => {
-        const session = http2.connect('http://localhost:19999');
+        const session = gjsHttp2.connect('http://localhost:19999');
         const stream = session.request({ ':method': 'GET', ':path': '/' });
         expect(stream).toBeDefined();
-        expect(typeof (stream as any).on).toBe('function');
+        expect(typeof stream.on).toBe('function');
+        session.close();
+      });
+    });
+
+    // ─── Phase 2: respondWithFile / respondWithFD ────────────────────────────
+    // Ported from refs/node-test/parallel/test-http2-respond-file.js
+    //              refs/node-test/parallel/test-http2-respond-file-fd.js
+    // Original: Copyright (c) Node.js contributors. MIT.
+
+    await describe('http2 respondWithFile()', async () => {
+      let tmpDir = '';
+      let fname = '';
+      const data = 'Hello from a file served by http2.respondWithFile!\n';
+
+      tmpDir = mkdtempSync(join(tmpdir(), 'gjsify-http2-'));
+      fname = join(tmpDir, 'sample.txt');
+      writeFileSync(fname, data);
+
+      await it('streams a file by path through the response body', async () => {
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).respondWithFile(fname, { 'content-type': 'text/plain' });
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request(
+          { ':method': 'GET', ':path': '/' },
+          { endStream: true } as any,
+        );
+
+        let captured: Record<string, string | string[]> = {};
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', (h: any) => { captured = h; resolve(); });
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        const body = await collectBody(stream);
+
+        expect(body).toBe(data);
+        expect(captured['content-type']).toBe('text/plain');
+
+        session.close();
+        (server as any).close();
+      });
+
+      await it('statCheck() can mutate response headers based on file stat', async () => {
+        let statSeen: any = null;
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).respondWithFile(
+            fname,
+            { 'content-type': 'text/plain' },
+            {
+              statCheck: (stat: any, headers: any) => {
+                statSeen = stat;
+                headers['content-length'] = String(stat.size);
+                headers['x-stat-mtime'] = String(stat.mtimeMs ?? stat.mtime?.getTime?.() ?? 0);
+              },
+            },
+          );
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request(
+          { ':method': 'GET', ':path': '/' },
+          { endStream: true } as any,
+        );
+
+        let captured: Record<string, string | string[]> = {};
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', (h: any) => { captured = h; resolve(); });
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        await collectBody(stream);
+
+        expect(statSeen).toBeTruthy();
+        expect(Number(captured['content-length'])).toBe(data.length);
+        expect(typeof captured['x-stat-mtime']).toBe('string');
+
+        session.close();
+        (server as any).close();
+      });
+
+      // Cleanup. Best-effort — tmpdir lives under /tmp so test failures don't pollute.
+      await it('cleanup', async () => {
+        try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+      });
+    });
+
+    await describe('http2 respondWithFD()', async () => {
+      let tmpDir = '';
+      let fname = '';
+      const data = 'FD-streamed body\n';
+
+      tmpDir = mkdtempSync(join(tmpdir(), 'gjsify-http2-fd-'));
+      fname = join(tmpDir, 'fd.txt');
+      writeFileSync(fname, data);
+
+      await it('streams an open file descriptor through the response body', async () => {
+        const fd = openSync(fname, 'r');
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).respondWithFD(fd, {
+            'content-type': 'text/plain',
+            'content-length': String(data.length),
+          });
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request(
+          { ':method': 'GET', ':path': '/' },
+          { endStream: true } as any,
+        );
+
+        let captured: Record<string, string | string[]> = {};
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', (h: any) => { captured = h; resolve(); });
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        const body = await collectBody(stream);
+
+        expect(body).toBe(data);
+        expect(Number(captured['content-length'])).toBe(data.length);
+
+        session.close();
+        (server as any).close();
+        try { closeSync(fd); } catch {}
+      });
+
+      await it('cleanup', async () => {
+        try { rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+      });
+    });
+
+    // ─── Phase 2: pushStream ─────────────────────────────────────────────────
+    // Ported from refs/node-test/parallel/test-http2-server-push-stream.js
+    // Original: Copyright (c) Node.js contributors. MIT.
+    //
+    // Soup does not expose the underlying nghttp2 session, so the
+    // PUSH_PROMISE frame the bridge constructs cannot be delivered to the
+    // client over the active Soup connection. These tests verify the
+    // server-side API contract instead: callback fired, ServerHttp2Stream
+    // synthesised, even stream-id allocated, headers + frame bytes
+    // observable. See STATUS.md "Open TODOs" → "http2 PUSH_PROMISE wire
+    // delivery" for the wire-level follow-up.
+
+    await describe('http2 pushStream() — API contract', async () => {
+      await it('callback fires with a ServerHttp2Stream + push headers', async () => {
+        let pushedStream: any = null;
+        let pushedHeaders: any = null;
+
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).pushStream(
+            {
+              ':path': '/foobar',
+              ':authority': `localhost:${port}`,
+              ':scheme': 'http',
+            },
+            (err: Error | null, stream: any, hdrs: any) => {
+              if (err) { res.writeHead(500); res.end(); return; }
+              pushedStream = stream;
+              pushedHeaders = hdrs;
+              stream.respond({ ':status': 200, 'content-type': 'text/plain' });
+              stream.end('pushed body');
+              res.writeHead(200);
+              res.end('main body');
+            },
+          );
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true } as any);
+
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', () => resolve());
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        await collectBody(stream);
+
+        expect(pushedStream).toBeTruthy();
+        expect(typeof pushedStream.respond).toBe('function');
+        expect(pushedHeaders).toBeTruthy();
+        expect(pushedHeaders[':path']).toBe('/foobar');
+        // Even server-allocated stream id (RFC 7540 §5.1.1).
+        expect(pushedStream.id % 2 === 0).toBeTruthy();
+        expect(pushedStream.id >= 2).toBeTruthy();
+
+        session.close();
+        (server as any).close();
+      });
+
+      await it('pushStream on a pushed stream rejects with ERR_HTTP2_NESTED_PUSH', async () => {
+        let nestedError: any = null;
+
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).pushStream(
+            { ':path': '/lvl1', ':authority': `localhost:${port}`, ':scheme': 'http' },
+            (err: Error | null, stream: any) => {
+              if (err) { res.writeHead(500); res.end(); return; }
+              // Nested push must fail per RFC 7540 §8.2.
+              stream.pushStream(
+                { ':path': '/lvl2', ':authority': `localhost:${port}`, ':scheme': 'http' },
+                (innerErr: any) => { nestedError = innerErr; },
+              );
+              stream.respond({ ':status': 200 });
+              stream.end('lvl1 body');
+              res.writeHead(200);
+              res.end('main');
+            },
+          );
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true } as any);
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', () => resolve());
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        await collectBody(stream);
+
+        // Allow the async push callback chain to settle.
+        await new Promise((r) => setTimeout(r, 20));
+
+        expect(nestedError).toBeTruthy();
+        expect((nestedError as any).code).toBe('ERR_HTTP2_NESTED_PUSH');
+
+        session.close();
+        (server as any).close();
+      });
+
+      await it('allocates monotonically-increasing even ids across multiple pushes', async () => {
+        const ids: number[] = [];
+        const { server, port } = await withServer(async (_req, res) => {
+          await new Promise<void>((res2) => {
+            (res as any).pushStream(
+              { ':path': '/a', ':authority': `localhost:${port}`, ':scheme': 'http' },
+              (err: any, s1: any) => {
+                if (s1) ids.push(s1.id);
+                if (s1) { s1.respond({ ':status': 200 }); s1.end('a'); }
+                (res as any).pushStream(
+                  { ':path': '/b', ':authority': `localhost:${port}`, ':scheme': 'http' },
+                  (err2: any, s2: any) => {
+                    if (s2) ids.push(s2.id);
+                    if (s2) { s2.respond({ ':status': 200 }); s2.end('b'); }
+                    res2();
+                  },
+                );
+              },
+            );
+          });
+          res.writeHead(200);
+          res.end('main');
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true } as any);
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', () => resolve());
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        await collectBody(stream);
+
+        expect(ids.length).toBe(2);
+        expect(ids[0] % 2 === 0).toBeTruthy();
+        expect(ids[1] % 2 === 0).toBeTruthy();
+        expect(ids[1] > ids[0]).toBeTruthy();
+
         session.close();
+        (server as any).close();
+      });
+
+      await it('createPushResponse() yields a usable Http2ServerResponse', async () => {
+        let pushRes: any = null;
+        const { server, port } = await withServer((_req, res) => {
+          (res as any).createPushResponse(
+            { ':path': '/aux', ':authority': `localhost:${port}`, ':scheme': 'http' },
+            (err: any, child: any) => {
+              if (child) {
+                pushRes = child;
+                child.writeHead(200, { 'content-type': 'text/plain' });
+                child.end('pushed');
+              }
+              res.writeHead(200);
+              res.end('parent');
+            },
+          );
+        });
+
+        const session = gjsHttp2.connect(`http://localhost:${port}`);
+        const stream = session.request({ ':method': 'GET', ':path': '/' }, { endStream: true } as any);
+        await new Promise<void>((resolve, reject) => {
+          (stream as any).on('response', () => resolve());
+          (stream as any).on('error', reject);
+          setTimeout(() => reject(new Error('timeout')), 5000);
+        });
+        await collectBody(stream);
+
+        await new Promise((r) => setTimeout(r, 20));
+
+        expect(pushRes).toBeTruthy();
+        expect(pushRes.statusCode).toBe(200);
+        // The detached body is observable on push responses.
+        const buf = pushRes.detachedBody;
+        expect(buf).toBeTruthy();
+        if (buf) expect(buf.toString('utf8')).toBe('pushed');
+
+        session.close();
+        (server as any).close();
       });
     });