test: add node.js runtime specific middleware tests checking availability of crypto, path and http(s) node.js builtins

Author: pieh

tests/e2e/edge-middleware.test.ts renamed to tests/e2e/middleware.test.ts

@@ -16,11 +16,10 @@ type ExtendedFixtures = {
   edgeOrNodeMiddlewareStaticAssetMatcher: Fixture
 }
 
-console.log({ hasNodeMiddlewareSupport: hasNodeMiddlewareSupport() })
-
-for (const { expectedRuntime, label, testWithSwitchableMiddlewareRuntime } of [
+for (const { expectedRuntime, isNodeMiddleware, label, testWithSwitchableMiddlewareRuntime } of [
   {
     expectedRuntime: 'edge-runtime',
+    isNodeMiddleware: false,
     label: 'Edge runtime middleware',
     testWithSwitchableMiddlewareRuntime: test.extend<{}, ExtendedFixtures>({
       edgeOrNodeMiddleware: [
@@ -68,6 +67,7 @@ for (const { expectedRuntime, label, testWithSwitchableMiddlewareRuntime } of [
   hasNodeMiddlewareSupport()
     ? {
         expectedRuntime: 'node',
+        isNodeMiddleware: true,
         label: 'Node.js runtime middleware',
         testWithSwitchableMiddlewareRuntime: test.extend<{}, ExtendedFixtures>({
           edgeOrNodeMiddleware: [
@@ -565,6 +565,40 @@ for (const { expectedRuntime, label, testWithSwitchableMiddlewareRuntime } of [
         )
       })
     })
+
+    if (isNodeMiddleware) {
+      // Node.js Middleware specific tests to test features not available in Edge Runtime
+      test.describe('Node.js Middleware specific', () => {
+        test('node:crypto module', async ({ middlewareNodeRuntimeSpecific }) => {
+          const response = await fetch(`${middlewareNodeRuntimeSpecific.url}/test/crypto`)
+          expect(response.status).toBe(200)
+          const body = await response.json()
+          expect(
+            body.random,
+            'random should have 16 random bytes generated with `randomBytes` function from node:crypto in hex format',
+          ).toMatch(/[0-9a-f]{32}/)
+        })
+
+        test('node:http(s) module', async ({ middlewareNodeRuntimeSpecific }) => {
+          const response = await fetch(`${middlewareNodeRuntimeSpecific.url}/test/http`)
+          expect(response.status).toBe(200)
+          const body = await response.json()
+          expect(
+            body.proxiedWithHttpRequest,
+            'proxiedWithHttpRequest should be the result of `http.request` from node:http fetching static asset',
+          ).toStrictEqual({ hello: 'world' })
+        })
+
+        test('node:path module', async ({ middlewareNodeRuntimeSpecific }) => {
+          const response = await fetch(`${middlewareNodeRuntimeSpecific.url}/test/path`)
+          expect(response.status).toBe(200)
+          const body = await response.json()
+          expect(body.joined, 'joined should be the result of `join` function from node:path').toBe(
+            'a/b',
+          )
+        })
+      })
+    }
   })
 }
 

tests/fixtures/middleware-node/app/layout.js renamed to tests/fixtures/middleware-node-runtime-specific/app/layout.js

@@ -0,0 +1,60 @@
+import { randomBytes } from 'node:crypto'
+import { request as httpRequest } from 'node:http'
+import { request as httpsRequest } from 'node:https'
+import { join } from 'node:path'
+
+import { NextResponse } from 'next/server'
+import type { NextRequest } from 'next/server'
+
+export async function middleware(request: NextRequest) {
+  // this middleware is using Node.js APIs that are not available in Edge Runtime in very simple way to assert support for them
+  if (request.nextUrl.pathname === '/test/crypto') {
+    return NextResponse.json({ random: randomBytes(16).toString('hex') })
+  }
+
+  if (request.nextUrl.pathname === '/test/http') {
+    const body = await new Promise((resolve, reject) => {
+      const origin =
+        typeof Netlify !== 'undefined'
+          ? `https://${Netlify.context.deploy.id}--${Netlify.context.site.name}.netlify.app`
+          : `http://localhost:3000`
+
+      const target = new URL('/http-test-target.json', origin)
+
+      const httpOrHttpsRequest = target.protocol === 'https:' ? httpsRequest : httpRequest
+
+      const req = httpOrHttpsRequest(target, (res) => {
+        if (res.statusCode !== 200) {
+          reject(new Error(`Failed to fetch ${target}: ${res.statusCode}`))
+          // Consume response data to free up memory
+          res.resume()
+          return
+        }
+
+        res.setEncoding('utf8')
+        let rawData = ''
+        res.on('data', (chunk) => {
+          rawData += chunk
+        })
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(rawData))
+          } catch (e) {
+            reject(e)
+          }
+        })
+      })
+      req.end()
+      console.log({ target })
+    })
+    return NextResponse.json({ proxiedWithHttpRequest: body })
+  }
+
+  if (request.nextUrl.pathname === '/test/path') {
+    return NextResponse.json({ joined: join('a', 'b') })
+  }
+}
+
+export const config = {
+  runtime: 'nodejs',
+}

tests/fixtures/middleware-node/app/page.js renamed to tests/fixtures/middleware-node-runtime-specific/app/page.js

@@ -1,5 +1,5 @@
 {
-  "name": "middleware-node",
+  "name": "middleware-node-runtime-specific",
   "version": "0.1.0",
   "private": true,
   "scripts": {

tests/fixtures/middleware-node-runtime-specific/middleware.ts

@@ -0,0 +1,3 @@
+{
+  "hello": "world"
+}

tests/fixtures/middleware-node/next.config.js renamed to tests/fixtures/middleware-node-runtime-specific/next.config.js

@@ -346,6 +346,7 @@ export const fixtureFactories = {
       buildCommand: getBuildFixtureVariantCommand('node-middleware'),
       publishDirectory: '.next-node-middleware',
     }),
+  middlewareNodeRuntimeSpecific: () => createE2EFixture('middleware-node-runtime-specific'),
   middlewareI18n: () => createE2EFixture('middleware-i18n'),
   middlewareI18nNode: () =>
     createE2EFixture('middleware-i18n', {