test: consume bodies of fetch responses to fix failing macos 20 ci

test/fetch/cookies.js

@@ -1,111 +1,114 @@
 'use strict'
 
+const { strictEqual, deepStrictEqual } = require('node:assert').strict
 const { once } = require('node:events')
 const { createServer } = require('node:http')
-const { test } = require('node:test')
-const assert = require('node:assert')
-const { tspl } = require('@matteo.collina/tspl')
+const { test, describe, before, after } = require('node:test')
+const { stringify: qsStringify } = require('node:querystring')
 const { Client, fetch, Headers } = require('../..')
-const { closeServerAsPromise } = require('../utils/node-http')
 const pem = require('@metcoder95/https-pem')
 const { createSecureServer } = require('node:http2')
-const { closeClientAndServerAsPromise } = require('../utils/node-http')
 
-test('Can receive set-cookie headers from a server using fetch - issue #1262', async (t) => {
-  const server = createServer({ joinDuplicateHeaders: true }, (req, res) => {
-    res.setHeader('set-cookie', 'name=value; Domain=example.com')
-    res.end()
-  }).listen(0)
+describe('cookies', () => {
+  let server
 
-  t.after(closeServerAsPromise(server))
-  await once(server, 'listening')
-
-  const response = await fetch(`http://localhost:${server.address().port}`)
-
-  assert.strictEqual(response.headers.get('set-cookie'), 'name=value; Domain=example.com')
+  before(() => {
+    server = createServer({ joinDuplicateHeaders: true }, (req, res) => {
+      const searchParams = new URL(req.url, 'http://localhost').searchParams
+      if (searchParams.has('set-cookie')) {
+        res.setHeader('set-cookie', searchParams.get('set-cookie'))
+      }
+      res.end(req.headers.cookie)
+    })
 
-  const response2 = await fetch(`http://localhost:${server.address().port}`, {
-    credentials: 'include'
+    return once(server.listen(0), 'listening')
   })
 
-  assert.strictEqual(response2.headers.get('set-cookie'), 'name=value; Domain=example.com')
-})
-
-test('Can send cookies to a server with fetch - issue #1463', async (t) => {
-  const server = createServer({ joinDuplicateHeaders: true }, (req, res) => {
-    assert.strictEqual(req.headers.cookie, 'value')
-    res.end()
-  }).listen(0)
-
-  t.after(closeServerAsPromise(server))
-  await once(server, 'listening')
-
-  const headersInit = [
-    new Headers([['cookie', 'value']]),
-    { cookie: 'value' },
-    [['cookie', 'value']]
-  ]
+  after(() => {
+    server.close()
+    return once(server, 'close')
+  })
 
-  for (const headers of headersInit) {
-    await fetch(`http://localhost:${server.address().port}`, { headers })
-  }
-})
+  test('Can receive set-cookie headers from a server using fetch - issue #1262', async () => {
+    const query = qsStringify({
+      'set-cookie': 'name=value; Domain=example.com'
+    })
+    const response = await fetch(`http://localhost:${server.address().port}?${query}`)
 
-test('Cookie header is delimited with a semicolon rather than a comma - issue #1905', async (t) => {
-  const { strictEqual } = tspl(t, { plan: 1 })
+    strictEqual(response.headers.get('set-cookie'), 'name=value; Domain=example.com')
+    strictEqual(await response.text(), '')
 
-  const server = createServer({ joinDuplicateHeaders: true }, (req, res) => {
-    strictEqual(req.headers.cookie, 'FOO=lorem-ipsum-dolor-sit-amet; BAR=the-quick-brown-fox')
-    res.end()
-  }).listen(0)
+    const response2 = await fetch(`http://localhost:${server.address().port}?${query}`, {
+      credentials: 'include'
+    })
 
-  t.after(closeServerAsPromise(server))
-  await once(server, 'listening')
+    strictEqual(response2.headers.get('set-cookie'), 'name=value; Domain=example.com')
+    strictEqual(await response2.text(), '')
+  })
 
-  await fetch(`http://localhost:${server.address().port}`, {
-    headers: [
-      ['cookie', 'FOO=lorem-ipsum-dolor-sit-amet'],
-      ['cookie', 'BAR=the-quick-brown-fox']
+  test('Can send cookies to a server with fetch - issue #1463', async () => {
+    const headersInit = [
+      new Headers([['cookie', 'value']]),
+      { cookie: 'value' },
+      [['cookie', 'value']]
     ]
+
+    for (const headers of headersInit) {
+      const response = await fetch(`http://localhost:${server.address().port}`, { headers })
+      const text = await response.text()
+      strictEqual(text, 'value')
+    }
   })
-})
 
-test('Can receive set-cookie headers from a http2 server using fetch - issue #2885', async (t) => {
-  const server = createSecureServer(pem)
-  server.on('stream', async (stream, headers) => {
-    stream.respond({
-      'content-type': 'text/plain; charset=utf-8',
-      'x-method': headers[':method'],
-      'set-cookie': 'Space=Cat; Secure; HttpOnly',
-      ':status': 200
+  test('Cookie header is delimited with a semicolon rather than a comma - issue #1905', async () => {
+    const response = await fetch(`http://localhost:${server.address().port}`, {
+      headers: [
+        ['cookie', 'FOO=lorem-ipsum-dolor-sit-amet'],
+        ['cookie', 'BAR=the-quick-brown-fox']
+      ]
     })
 
-    stream.end('test')
+    strictEqual(await response.text(), 'FOO=lorem-ipsum-dolor-sit-amet; BAR=the-quick-brown-fox')
   })
 
-  server.listen()
-  await once(server, 'listening')
+  test('Can receive set-cookie headers from a http2 server using fetch - issue #2885', async () => {
+    const server = createSecureServer(pem)
+    server.on('stream', (stream, headers) => {
+      stream.respond({
+        'content-type': 'text/plain; charset=utf-8',
+        'x-method': headers[':method'],
+        'set-cookie': 'Space=Cat; Secure; HttpOnly',
+        ':status': 200
+      })
+
+      stream.end('test')
+    })
 
-  const client = new Client(`https://localhost:${server.address().port}`, {
-    connect: {
-      rejectUnauthorized: false
-    },
-    allowH2: true
-  })
+    await once(server.listen(0), 'listening')
+
+    const client = new Client(`https://localhost:${server.address().port}`, {
+      connect: {
+        rejectUnauthorized: false
+      },
+      allowH2: true
+    })
 
-  const response = await fetch(
-    `https://localhost:${server.address().port}/`,
-    // Needs to be passed to disable the reject unauthorized
-    {
-      method: 'GET',
-      dispatcher: client,
-      headers: {
-        'content-type': 'text-plain'
+    const response = await fetch(
+      `https://localhost:${server.address().port}/`,
+      // Needs to be passed to disable the reject unauthorized
+      {
+        method: 'GET',
+        dispatcher: client,
+        headers: {
+          'content-type': 'text-plain'
+        }
       }
-    }
-  )
+    )
 
-  t.after(closeClientAndServerAsPromise(client, server))
+    deepStrictEqual(response.headers.getSetCookie(), ['Space=Cat; Secure; HttpOnly'])
+    strictEqual(await response.text(), 'test')
 
-  assert.deepStrictEqual(response.headers.getSetCookie(), ['Space=Cat; Secure; HttpOnly'])
+    await client.close()
+    await new Promise((resolve, reject) => server.close(err => err ? reject(err) : resolve()))
+  })
 })

test/fetch/encoding.js

@@ -1,9 +1,9 @@
 'use strict'
 
+const { strictEqual } = require('node:assert').strict
 const { once } = require('node:events')
 const { createServer } = require('node:http')
 const { test, before, after, describe } = require('node:test')
-const { tspl } = require('@matteo.collina/tspl')
 const { fetch } = require('../..')
 
 describe('content-encoding handling', () => {
@@ -55,8 +55,6 @@ describe('content-encoding handling', () => {
   })
 
   test('content-encoding header', async (t) => {
-    const { strictEqual } = tspl(t, { plan: 3 })
-
     const response = await fetch(`http://localhost:${server.address().port}`, {
       keepalive: false,
       headers: { 'accept-encoding': 'deflate, gzip' }
@@ -65,13 +63,9 @@ describe('content-encoding handling', () => {
     strictEqual(response.headers.get('content-encoding'), 'deflate, gzip')
     strictEqual(response.headers.get('content-type'), 'text/plain')
     strictEqual(await response.text(), 'Hello, World!')
-
-    await t.completed
   })
 
   test('content-encoding header is case-iNsENsITIve', async (t) => {
-    const { strictEqual } = tspl(t, { plan: 3 })
-
     const response = await fetch(`http://localhost:${server.address().port}`, {
       keepalive: false,
       headers: { 'accept-encoding': 'DeFlAtE, GzIp' }
@@ -80,15 +74,11 @@ describe('content-encoding handling', () => {
     strictEqual(response.headers.get('content-encoding'), 'deflate, gzip')
     strictEqual(response.headers.get('content-type'), 'text/plain')
     strictEqual(await response.text(), 'Hello, World!')
-
-    await t.completed
   })
 
   test('should decompress zstandard response',
     { skip: typeof require('node:zlib').createZstdDecompress !== 'function' },
-    async (t) => {
-      const { strictEqual } = tspl(t, { plan: 3 })
-
+    async () => {
       const response = await fetch(`http://localhost:${server.address().port}`, {
         keepalive: false,
         headers: { 'accept-encoding': 'zstd' }
@@ -97,7 +87,5 @@ describe('content-encoding handling', () => {
       strictEqual(response.headers.get('content-encoding'), 'zstd')
       strictEqual(response.headers.get('content-type'), 'text/plain')
       strictEqual(await response.text(), 'Hello, World!')
-
-      await t.completed
     })
 })