node/test/parallel/test-quic-h3-post-request.mjs

// Flags: --experimental-quic --experimental-stream-iter --no-warnings

// Test: HTTP/3 request with body data (POST-like).
// Client sends request pseudo-headers plus a body, server reads the body
// and echoes it back in the response.
// Verifies:
// - Client can send request headers + body via createBidirectionalStream
// - Server receives the request body via async iteration
// - Server response with echoed body is delivered to the client
// - The terminal flag is correctly NOT set when body is provided

import { hasQuic, skip, mustCall } from '../common/index.mjs';
import assert from 'node:assert';
import * as fixtures from '../common/fixtures.mjs';

if (!hasQuic) {
  skip('QUIC is not enabled');
}

const { listen, connect } = await import('node:quic');
const { createPrivateKey } = await import('node:crypto');
const { bytes } = await import('stream/iter');

const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
const cert = fixtures.readKey('agent1-cert.pem');

const encoder = new TextEncoder();
const decoder = new TextDecoder();
const requestBody = 'Hello from the client';

const serverDone = Promise.withResolvers();

const serverEndpoint = await listen(mustCall(async (serverSession) => {
  serverSession.onstream = mustCall(async (stream) => {
    // Read the full request body from the client.
    const body = await bytes(stream);
    const text = decoder.decode(body);
    assert.strictEqual(text, requestBody);

    await stream.closed;
    serverSession.close();
    serverDone.resolve();
  });
}), {
  sni: { '*': { keys: [key], certs: [cert] } },
  onheaders: mustCall(function(headers) {
    assert.strictEqual(headers[':method'], 'POST');
    assert.strictEqual(headers[':path'], '/submit');

    // Echo the request body back in the response.
    // At this point, request body hasn't arrived yet — we use onstream
    // to read it. But we can send response headers immediately.
    this.sendHeaders({
      ':status': '200',
      'content-type': 'text/plain',
    });
    // Write echoed body after reading it in onstream. For simplicity,
    // we write a fixed response here and verify the request body
    // separately in onstream.
    const w = this.writer;
    w.writeSync(encoder.encode('echo:' + requestBody));
    w.endSync();
  }),
});

const clientSession = await connect(serverEndpoint.address, {
  servername: 'localhost',
  verifyPeer: 'manual',
});

const info = await clientSession.opened;
assert.strictEqual(info.protocol, 'h3');

const clientHeadersReceived = Promise.withResolvers();

// Send a POST request with body. When body is provided, terminal is NOT
// set on the HEADERS frame (body follows).
const stream = await clientSession.createBidirectionalStream({
  headers: {
    ':method': 'POST',
    ':path': '/submit',
    ':scheme': 'https',
    ':authority': 'localhost',
  },
  body: encoder.encode(requestBody),
  onheaders: mustCall(function(headers) {
    assert.strictEqual(headers[':status'], 200);
    clientHeadersReceived.resolve();
  }),
});

await clientHeadersReceived.promise;

// Read the response body.
const responseBody = await bytes(stream);
assert.strictEqual(decoder.decode(responseBody), 'echo:' + requestBody);

await Promise.all([stream.closed, serverDone.promise]);
await clientSession.close();
await serverEndpoint.close();