fix(dns): preserve header shape for [string,string][] and ensure Host

lib/interceptor/dns.js

@@ -5,6 +5,43 @@ const DecoratorHandler = require('../handler/decorator-handler')
 const { InvalidArgumentError, InformationalError } = require('../core/errors')
 const maxInt = Math.pow(2, 31) - 1
 
+function addHostHeader (headers, host) {
+  if (headers == null) return { host }
+
+  if (Array.isArray(headers)) {
+    // Distinguish flat internal array vs array-of-pairs
+    if (headers.length > 0 && Array.isArray(headers[0])) {
+      let hasHost = false
+      for (const [k] of headers) {
+        if (k != null && String(k).toLowerCase() === 'host') { hasHost = true; break }
+      }
+      return hasHost ? headers : [['host', host], ...headers]
+    }
+
+    for (let i = 0; i < headers.length; i += 2) {
+      if (headers[i] != null && String(headers[i]).toLowerCase() === 'host') return headers
+    }
+    return ['host', host, ...headers]
+  }
+
+  if (headers && typeof headers[Symbol.iterator] === 'function') {
+    const pairs = []
+    let hasHost = false
+    for (const [k, v] of headers) {
+      if (k != null) {
+        if (String(k).toLowerCase() === 'host') hasHost = true
+        pairs.push([k, v])
+      }
+    }
+    return (hasHost ? pairs : [['host', host], ...pairs]).values()
+  }
+
+  for (const k of Object.keys(headers)) {
+    if (String(k).toLowerCase() === 'host') return headers
+  }
+  return { host, ...headers }
+}
+
 class DNSInstance {
   #maxTTL = 0
   #maxItems = 0
@@ -411,10 +448,7 @@ module.exports = interceptorOpts => {
           ...origDispatchOpts,
           servername: origin.hostname, // For SNI on TLS
           origin: newOrigin.origin,
-          headers: {
-            host: origin.host,
-            ...origDispatchOpts.headers
-          }
+          headers: addHostHeader(origDispatchOpts.headers, origin.host)
         }
 
         dispatch(

test/interceptors/dns.js

@@ -1936,3 +1936,74 @@ test('#3951 - Should handle lookup errors correctly', async t => {
     origin: 'http://localhost'
   }), new Error('lookup error'))
 })
+
+test('Various (parameterized) header shapes should work with DNS interceptor', async t => {
+  const server = createServer({ joinDuplicateHeaders: true })
+  server.on('request', (req, res) => {
+    t.equal(req.headers.foo, 'bar')
+    t.equal(typeof req.headers['0'], 'undefined')
+    t.match(req.headers.host, /^localhost:\d+$/)
+    res.end('ok')
+  })
+
+  server.listen(0)
+  await once(server, 'listening')
+
+  const origin = `http://localhost:${server.address().port}`
+
+  const { cache: cacheInterceptor, dns: dnsInterceptor } = interceptors
+
+  function * genPairs () { yield ['foo', 'bar'] }
+
+  const cases = [
+    {
+      name: 'record',
+      headers: { foo: 'bar' },
+      interceptors: [dnsInterceptor()]
+    },
+    {
+      name: 'flat array',
+      headers: ['foo', 'bar'],
+      interceptors: [dnsInterceptor()]
+    },
+    {
+      name: 'record with multi-value',
+      headers: { foo: ['bar'] },
+      interceptors: [dnsInterceptor()]
+    },
+    {
+      name: 'iterable generator of pairs',
+      headers: genPairs(),
+      interceptors: [cacheInterceptor(), dnsInterceptor({
+        lookup: (_origin, _opts, cb) => cb(null, [{ address: '127.0.0.1', family: 4 }])
+      })]
+    },
+    {
+      name: 'set of pairs',
+      headers: new Set([['foo', 'bar']]),
+      interceptors: [cacheInterceptor(), dnsInterceptor({
+        lookup: (_origin, _opts, cb) => cb(null, [{ address: '127.0.0.1', family: 4 }])
+      })]
+    },
+    {
+      name: 'map of pairs (single)',
+      headers: new Map([['foo', 'bar']]),
+      interceptors: [cacheInterceptor(), dnsInterceptor({
+        lookup: (_origin, _opts, cb) => cb(null, [{ address: '127.0.0.1', family: 4 }])
+      })]
+    }
+  ]
+
+  t = tspl(t, { plan: cases.length * 4 })
+
+  for (const c of cases) {
+    const agent = new Agent().compose(c.interceptors)
+    const r = await agent.request({ origin, path: '/', method: 'GET', headers: c.headers })
+    t.equal(r.statusCode, 200, c.name)
+    await r.body.text()
+    await agent.close()
+  }
+
+  server.close()
+  await once(server, 'close')
+})