Repeated response headers are handled inconsistently across HTTP/1.1 and HTTP/2 #5898

import assert from 'node:assert/strict';
import { createServer as createHTTP1Server } from 'node:http';
import { createServer as createHTTP2Server } from 'node:http2';
import { test } from 'node:test';
import { brotliCompressSync, gzipSync } from 'node:zlib';
import { Client, fetch } from 'undici';

const plain = 'some plain text';
const compressed = brotliCompressSync(gzipSync(plain));
const readText = r => r.text();
const readBlobType = async r => (await r.blob()).type;
const onError = () => 'network error';
const cases = [
  { path: '/combined', headers: { 'content-encoding': 'gzip, br' },
    status: 200, body: compressed, read: readText, expected: plain },
  { path: '/split', headers: { 'content-encoding': ['gzip', 'br'] },
    status: 200, body: compressed, read: readText, expected: plain },
  { path: '/type', headers: { 'content-type': ['text/plain', 'text/html'] },
    status: 200, body: plain, read: readBlobType, expected: 'text/html' },
  { path: '/location', headers: { location: ['/A', '/B'] },
    status: 302, body: plain, read: readText, expected: 'network error' },
];

test('HTTP/1.1 vs HTTP/2 response headers', async (t) => {
  const http1Server = createHTTP1Server();
  const http2Server = createHTTP2Server({ strictSingleValueFields: false });
  const [http1Origin, http2Origin] = await Promise.all([http1Server, http2Server].map(server => {
    server.on('request', (request, response) => {
      const testCase = cases.find(c => c.path === request.url);
      const { status, headers, body } = testCase
        ?? { status: 200, headers: {}, body: request.url }; // Echo redirects.
      response.writeHead(status, headers);
      response.end(body);
    });
    return new Promise(resolve => server.listen(0, '127.0.0.1', () => {
      resolve(`http://127.0.0.1:${server.address().port}`);
    }));
  }));
  const http1Client = new Client(http1Origin, { allowH2: false });
  const http2Client = new Client(http2Origin, { h2Options: { useH2c: true } });
  t.after(async () => {
    await Promise.all([http1Client.destroy(), http2Client.destroy()]);
    for (const server of [http1Server, http2Server]) server.close();
  });
  const results = [];
  for (const { path, read, expected } of cases) {
    const http1 = await fetch(http1Origin + path, { dispatcher: http1Client }).then(read).catch(onError);
    const http2 = await fetch(http2Origin + path, { dispatcher: http2Client }).then(read).catch(onError);
    results.push({ path, expected, http1, http2 });
  }
  console.log({ node: process.version });
  console.table(results);
  assert.ok(results.every(({ expected, http1, http2 }) => http1 === expected && http2 === expected));
});