test: remove polyfilledOrNative

packages/integration-tests/test/abort-controller.test.ts

@@ -1,11 +1,9 @@
-import { polyfilledOrNative, guard } from './test-if'
-
 if (!globalThis.DOMException) {
   globalThis.DOMException = require('@edge-runtime/ponyfill').DOMException
 }
 
 describe('AbortController', () => {
-  guard(it, polyfilledOrNative)('allows to abort fetch', async () => {
+  it('allows to abort fetch', async () => {
     expect.assertions(1)
     const controller = new AbortController()
     controller.abort()

packages/integration-tests/test/body.test.ts

@@ -1,6 +1,4 @@
-import { polyfilledOrNative, guard } from './test-if'
-
-guard(describe, polyfilledOrNative)('body', () => {
+describe('body', () => {
   test('throws when the body was directly consumed', async () => {
     expect.assertions(9)
 

packages/integration-tests/test/crypto.test.ts

@@ -1,5 +1,4 @@
 import { createHash } from 'crypto'
-import { polyfilledOrNative, guard } from './test-if'
 
 if (!globalThis.crypto) {
   globalThis.crypto = require('crypto')
@@ -15,20 +14,17 @@ test('crypto.randomUUID', async () => {
   expect(crypto.randomUUID()).toEqual(expect.stringMatching(/^[a-f0-9-]+$/))
 })
 
-guard(test, polyfilledOrNative)(
-  'crypto.subtle.digest returns a SHA-256 hash',
-  async () => {
-    const digest = await crypto.subtle.digest(
-      'SHA-256',
-      new Uint8Array([104, 105, 33]),
-    )
-    expect(toHex(digest)).toEqual(
-      createHash('sha256').update('hi!').digest('hex'),
-    )
-  },
-)
+test('crypto.subtle.digest returns a SHA-256 hash', async () => {
+  const digest = await crypto.subtle.digest(
+    'SHA-256',
+    new Uint8Array([104, 105, 33]),
+  )
+  expect(toHex(digest)).toEqual(
+    createHash('sha256').update('hi!').digest('hex'),
+  )
+})
 
-guard(test, polyfilledOrNative)('Ed25519', async () => {
+test('Ed25519', async () => {
   const kp = await crypto.subtle.generateKey('Ed25519', false, [
     'sign',
     'verify',
@@ -37,7 +33,7 @@ guard(test, polyfilledOrNative)('Ed25519', async () => {
   expect(kp).toHaveProperty('publicKey')
 })
 
-guard(test, polyfilledOrNative)('X25519', async () => {
+test('X25519', async () => {
   const kp = await crypto.subtle.generateKey('X25519', false, [
     'deriveBits',
     'deriveKey',

packages/integration-tests/test/fetch.test.ts

@@ -7,7 +7,7 @@ import {
 import listen from 'test-listen'
 import multer from 'multer'
 import consume from 'stream/consumers'
-import { polyfilledOrNative, guard, isEdgeRuntime } from './test-if'
+import { guard, isEdgeRuntime } from './test-if'
 import { Duplex } from 'stream'
 
 /**
@@ -43,7 +43,75 @@ afterEach(
     }),
 )
 
-guard(describe, polyfilledOrNative())('fetch', () => {
+describe('fetch', () => {
+  it.each([
+    ['host', 'vercel.com'],
+    ['content-type', 'application/json'],
+    ['connection', 'keep-alive'],
+    ['keep-alive', 'timeout=5'],
+    ['upgrade', 'websocket'],
+  ])("sets '%s' header in the constructor", async (name, value) => {
+    server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify(req.headers))
+    })
+
+    const serverUrl = await listen(server)
+    let response = await fetch(serverUrl, { headers: { [name]: value } })
+    expect(response.status).toBe(200)
+    let json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: { [name]: value } }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: new Headers({ [name]: value }) }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: new Headers({ [name]: value }) }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+
+    response = await fetch(
+      new Request(serverUrl, { headers: { [name]: value } }),
+    )
+    expect(response.status).toBe(200)
+    json = await response.json()
+    expect(json[name]).toBe(value)
+  })
+
+  test('sets header calling Headers constructor', async () => {
+    server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify(req.headers))
+    })
+    const serverUrl = await listen(server)
+    const response = await fetch(serverUrl, {
+      headers: new Headers({
+        'user-agent': 'vercel/edge-runtime',
+        host: 'example.com',
+        'x-host': 'example.com',
+      }),
+    })
+    expect(response.status).toBe(200)
+    const headers = await response.json()
+
+    expect(headers['user-agent']).toBe('vercel/edge-runtime')
+    expect(headers.host).toBe('example.com')
+    expect(headers['x-host']).toBe('example.com')
+  })
+
   test('perform a GET', async () => {
     server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
       if (req.method !== 'GET') {
@@ -166,21 +234,26 @@ guard(describe, polyfilledOrNative())('fetch', () => {
 
   test('sets header calling Headers constructor', async () => {
     server = createServer(async (req: IncomingMessage, res: ServerResponse) => {
-      res.end(req.headers['user-agent'])
+      res.setHeader('Content-Type', 'application/json')
+      res.end(JSON.stringify(req.headers))
     })
     const serverUrl = await listen(server)
     const response = await fetch(serverUrl, {
-      headers: new Headers({ 'user-agent': 'vercel/edge-runtime' }),
+      headers: new Headers({
+        'user-agent': 'vercel/edge-runtime',
+        host: 'example.com',
+        'x-host': 'example.com',
+      }),
     })
     expect(response.status).toBe(200)
-    const text = await response.text()
-    expect(text).toBe('vercel/edge-runtime')
+    const headers = await response.json()
+
+    expect(headers['user-agent']).toBe('vercel/edge-runtime')
+    expect(headers.host).toBe('example.com')
+    expect(headers['x-host']).toBe('example.com')
   })
-})
 
-guard(test, polyfilledOrNative() && isEdgeRuntime())(
-  'sets headers unsupported in undici',
-  async () => {
+  it('sets headers unsupported in undici', async () => {
     const url = new URL('/', 'https://example.vercel.sh')
     const response = await fetch(url, {
       headers: {
@@ -189,5 +262,5 @@ guard(test, polyfilledOrNative() && isEdgeRuntime())(
       },
     })
     expect(response.status).toBe(200)
-  },
-)
+  })
+})

packages/integration-tests/test/headers.test.ts

@@ -1,57 +1,68 @@
-import { guard, polyfilledOrNative } from './test-if'
+describe('headers', () => {
+  it.each([
+    ['host', 'vercel.com'],
+    ['content-length', '1234'],
+    ['content-type', 'application/json'],
+    ['transfer-encoding', 'chunked'],
+    ['connection', 'keep-alive'],
+    ['keep-alive', 'timeout=5'],
+    ['upgrade', 'websocket'],
+    ['expect', '100-continue'],
+  ])("sets '%s' header in the constructor", async (name, value) => {
+    const headers = new Headers({ [name]: value })
+    expect(headers.get(name)).toBe(value)
+  })
 
-guard(it, polyfilledOrNative)(
-  'sets header calling Headers constructor',
-  async () => {
+  it('sets header calling Headers constructor', async () => {
     const headers = new Headers()
     headers.set('cookie', 'hello=world')
     expect(headers.get('cookie')).toBe('hello=world')
-  },
-)
-
-guard(it, polyfilledOrNative)('multiple headers', async () => {
-  const headers = new Headers()
-  headers.append('set-cookie', 'foo=chocochip')
-  headers.append('set-cookie', 'bar=chocochip')
-  expect(headers.get('set-cookie')).toBe('foo=chocochip, bar=chocochip')
-  expect([...headers]).toEqual([
-    ['set-cookie', 'foo=chocochip'],
-    ['set-cookie', 'bar=chocochip'],
-  ])
-})
+  })
 
-guard(describe, polyfilledOrNative)('iterators', () => {
-  const generate = () => {
+  it('multiple headers', async () => {
     const headers = new Headers()
-    headers.append('a', '1')
-    headers.append('b', '2')
-    headers.append('set-cookie', 'c=3')
-    headers.append('set-cookie', 'd=4')
-    return headers
-  }
-
-  test('#Symbol.iterator', () => {
-    const entries = [...generate()]
-    expect(entries).toEqual([
-      ['a', '1'],
-      ['b', '2'],
-      ['set-cookie', 'c=3'],
-      ['set-cookie', 'd=4'],
+    headers.append('set-cookie', 'foo=chocochip')
+    headers.append('set-cookie', 'bar=chocochip')
+    expect(headers.get('set-cookie')).toBe('foo=chocochip, bar=chocochip')
+    expect([...headers]).toEqual([
+      ['set-cookie', 'foo=chocochip'],
+      ['set-cookie', 'bar=chocochip'],
     ])
   })
 
-  test('#entries', () => {
-    const entries = [...generate().entries()]
-    expect(entries).toEqual([
-      ['a', '1'],
-      ['b', '2'],
-      ['set-cookie', 'c=3'],
-      ['set-cookie', 'd=4'],
-    ])
-  })
+  describe('iterators', () => {
+    const generate = () => {
+      const headers = new Headers()
+      headers.append('a', '1')
+      headers.append('b', '2')
+      headers.append('set-cookie', 'c=3')
+      headers.append('set-cookie', 'd=4')
+      return headers
+    }
+
+    test('#Symbol.iterator', () => {
+      const entries = [...generate()]
+      expect(entries).toEqual([
+        ['a', '1'],
+        ['b', '2'],
+        ['set-cookie', 'c=3'],
+        ['set-cookie', 'd=4'],
+      ])
+    })
+
+    test('#entries', () => {
+      const entries = [...generate().entries()]
+      expect(entries).toEqual([
+        ['a', '1'],
+        ['b', '2'],
+        ['set-cookie', 'c=3'],
+        ['set-cookie', 'd=4'],
+      ])
+    })
 
-  test('#values', () => {
-    const values = [...generate().values()]
-    expect(values).toEqual(['1', '2', 'c=3', 'd=4'])
+    test('#values', () => {
+      const values = [...generate().values()]
+      expect(values).toEqual(['1', '2', 'c=3', 'd=4'])
+    })
   })
 })

packages/integration-tests/test/request.test.ts

@@ -1,6 +1,25 @@
-import { polyfilledOrNative, guard } from './test-if'
+describe('Request', () => {
+  it.each([
+    ['host', 'vercel.com'],
+    ['content-length', '1234'],
+    ['content-type', 'application/json'],
+    ['transfer-encoding', 'chunked'],
+    ['connection', 'keep-alive'],
+    ['keep-alive', 'timeout=5'],
+    ['upgrade', 'websocket'],
+    ['expect', '100-continue'],
+  ])("sets '%s' header in the constructor", async (name, value) => {
+    const headers = new Headers({ [name]: value })
+    expect(
+      new Request('https://vercel.com', { headers }).headers.get(name),
+    ).toBe(value)
+    expect(
+      new Request('https://vercel.com', {
+        headers: { [name]: value },
+      }).headers.get(name),
+    ).toBe(value)
+  })
 
-guard(describe, polyfilledOrNative)('request', () => {
   test('evaluate promise', () => {
     const url = 'https://vercel.com/foo/bar?one=value'
     const req = new Request(url)

packages/integration-tests/test/response.test.ts

@@ -1,6 +1,6 @@
-import { polyfilledOrNative, guard, isEdgeRuntime } from './test-if'
+import { guard, isEdgeRuntime } from './test-if'
 
-guard(describe, polyfilledOrNative)('response', () => {
+describe('Response', () => {
   test('create a response', async () => {
     const res1 = new Response('Hello world!')
     expect(await res1.text()).toEqual('Hello world!')
@@ -58,9 +58,16 @@ guard(describe, polyfilledOrNative)('response', () => {
   guard(test, isEdgeRuntime)(
     'allow to mutate response headers for error',
     async () => {
-      const response = Response.error()
-      response.headers.set('foo', 'bar')
-      expect(response.headers.get('foo')).toEqual('bar')
+      {
+        const response = new Response()
+        response.headers.set('foo', 'bar')
+        expect(response.headers.get('foo')).toEqual('bar')
+      }
+      {
+        const response = Response.error()
+        response.headers.set('foo', 'bar')
+        expect(response.headers.get('foo')).toEqual('bar')
+      }
     },
   )
 })

packages/integration-tests/test/test-if.ts

@@ -4,22 +4,5 @@ export const guard = <T extends { skip: T }>(
 ): T =>
   (typeof conditional === 'function' ? conditional() : conditional) ? t : t.skip
 
-const aboveNode16 = () => process.versions.node.split('.').map(Number)[0] > 16
-
 export const isEdgeRuntime = () =>
   (globalThis as { EdgeRuntime?: unknown }).EdgeRuntime !== undefined
-
-/**
- * Returns true if the block should execute for a Node.js version
- * that supports the APIs natively, or in an Edge Runtime running
- * in a Node.js version that supports it.
- *
- * For instance, {@link Headers} is not available in Node.js 16.x,
- * but when running in an Edge Runtime context within Node.js 16,
- * Headers _is_ available.
- *
- * Therefore, `polyfilledOrNative` will return `true` in
- * Node.js 18.x and above, and in Edge Runtime running in Node.js 16.x
- * and above.
- */
-export const polyfilledOrNative = () => isEdgeRuntime() || aboveNode16()