test: move middleware-conditions to test variants

Author: pieh

tests/fixtures/middleware-conditions/middleware-node.ts

@@ -0,0 +1,18 @@
+export { middleware } from './middleware-shared'
+
+export const config = {
+  runtime: 'nodejs',
+  matcher: [
+    {
+      source: '/foo',
+      missing: [{ type: 'header', key: 'x-custom-header', value: 'custom-value' }],
+    },
+    {
+      source: '/hello',
+    },
+    {
+      source: '/nl/about',
+      locale: false,
+    },
+  ],
+}

tests/fixtures/middleware-conditions/middleware-shared.ts

@@ -0,0 +1,10 @@
+import type { NextRequest } from 'next/server'
+import { NextResponse } from 'next/server'
+
+export function middleware(request: NextRequest) {
+  const response: NextResponse = NextResponse.next()
+
+  response.headers.set('x-hello-from-middleware-res', 'hello')
+
+  return response
+}

tests/fixtures/middleware-conditions/middleware.ts

@@ -1,13 +1,4 @@
-import type { NextRequest } from 'next/server'
-import { NextResponse } from 'next/server'
-
-export function middleware(request: NextRequest) {
-  const response: NextResponse = NextResponse.next()
-
-  response.headers.set('x-hello-from-middleware-res', 'hello')
-
-  return response
-}
+export { middleware } from './middleware-shared'
 
 export const config = {
   matcher: [

tests/fixtures/middleware-conditions/next.config.js

@@ -1,13 +1,17 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   output: 'standalone',
+  distDir: process.env.NEXT_DIST_DIR ?? '.next',
   i18n: {
     locales: ['en', 'fr', 'nl', 'es'],
     defaultLocale: 'en',
   },
   eslint: {
     ignoreDuringBuilds: true,
   },
+  experimental: {
+    nodeMiddleware: true,
+  },
   outputFileTracingRoot: __dirname,
 }
 

tests/fixtures/middleware-conditions/package.json

@@ -3,9 +3,9 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "postinstall": "next build",
+    "postinstall": "npm run build",
     "dev": "next dev",
-    "build": "next build"
+    "build": "node ../../utils/build-variants.mjs"
   },
   "dependencies": {
     "next": "latest",

tests/fixtures/middleware-conditions/test-variants.json

@@ -0,0 +1,21 @@
+{
+  "node-middleware": {
+    "distDir": ".next-node-middleware",
+    "files": {
+      "middleware.ts": "middleware-node.ts"
+    },
+    "test": {
+      "dependencies": {
+        "next": [
+          {
+            "versionConstraint": ">=15.2.0",
+            "canaryOnly": true
+          },
+          {
+            "versionConstraint": ">=15.5.0"
+          }
+        ]
+      }
+    }
+  }
+}

tests/integration/edge-handler.test.ts

@@ -223,120 +223,122 @@ for (const {
         expect(response.headers.get('x-runtime')).toEqual(expectedRuntime)
       })
     })
-  })
-}
-
-describe("aborts middleware execution when the matcher conditions don't match the request", () => {
-  test<FixtureTestContext>('when the path is excluded', async (ctx) => {
-    await createFixture('middleware', ctx)
-    await runPlugin(ctx)
 
-    const origin = await LocalServer.run(async (req, res) => {
-      expect(req.url).toBe('/_next/data')
-      expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
-
-      res.write('Hello from origin!')
-      res.end()
-    })
+    describe("aborts middleware execution when the matcher conditions don't match the request", () => {
+      test<FixtureTestContext>('when the path is excluded', async (ctx) => {
+        await createFixture('middleware', ctx)
+        await runPlugin(ctx, runPluginConstants)
 
-    ctx.cleanup?.push(() => origin.stop())
+        const origin = await LocalServer.run(async (req, res) => {
+          expect(req.url).toBe('/_next/data')
+          expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
 
-    const response = await invokeEdgeFunction(ctx, {
-      functions: [EDGE_MIDDLEWARE_FUNCTION_NAME],
-      origin,
-      url: '/_next/data',
-    })
+          res.write('Hello from origin!')
+          res.end()
+        })
 
-    expect(await response.text()).toBe('Hello from origin!')
-    expect(response.status).toBe(200)
-    expect(response.headers.has('x-hello-from-middleware-res')).toBeFalsy()
-    expect(origin.calls).toBe(1)
-  })
+        ctx.cleanup?.push(() => origin.stop())
 
-  test<FixtureTestContext>('when a request header matches a condition', async (ctx) => {
-    await createFixture('middleware-conditions', ctx)
-    await runPlugin(ctx)
+        const response = await invokeEdgeFunction(ctx, {
+          functions: [edgeFunctionNameRoot],
+          origin,
+          url: '/_next/data',
+        })
 
-    const origin = await LocalServer.run(async (req, res) => {
-      expect(req.url).toBe('/foo')
-      expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
+        expect(await response.text()).toBe('Hello from origin!')
+        expect(response.status).toBe(200)
+        expect(response.headers.has('x-hello-from-middleware-res')).toBeFalsy()
+        expect(origin.calls).toBe(1)
+      })
 
-      res.write('Hello from origin!')
-      res.end()
-    })
+      test<FixtureTestContext>('when a request header matches a condition', async (ctx) => {
+        await createFixture('middleware-conditions', ctx)
+        await runPlugin(ctx, runPluginConstants)
 
-    ctx.cleanup?.push(() => origin.stop())
+        const origin = await LocalServer.run(async (req, res) => {
+          expect(req.url).toBe('/foo')
+          expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
 
-    // Request 1: Middleware should run because we're not sending the header.
-    const response1 = await invokeEdgeFunction(ctx, {
-      functions: [EDGE_MIDDLEWARE_FUNCTION_NAME],
-      origin,
-      url: '/foo',
-    })
+          res.write('Hello from origin!')
+          res.end()
+        })
 
-    expect(await response1.text()).toBe('Hello from origin!')
-    expect(response1.status).toBe(200)
-    expect(response1.headers.has('x-hello-from-middleware-res')).toBeTruthy()
-    expect(origin.calls).toBe(1)
+        ctx.cleanup?.push(() => origin.stop())
 
-    // Request 2: Middleware should not run because we're sending the header.
-    const response2 = await invokeEdgeFunction(ctx, {
-      headers: {
-        'x-custom-header': 'custom-value',
-      },
-      functions: [EDGE_MIDDLEWARE_FUNCTION_NAME],
-      origin,
-      url: '/foo',
-    })
+        // Request 1: Middleware should run because we're not sending the header.
+        const response1 = await invokeEdgeFunction(ctx, {
+          functions: [edgeFunctionNameRoot],
+          origin,
+          url: '/foo',
+        })
 
-    expect(await response2.text()).toBe('Hello from origin!')
-    expect(response2.status).toBe(200)
-    expect(response2.headers.has('x-hello-from-middleware-res')).toBeFalsy()
-    expect(origin.calls).toBe(2)
-  })
+        expect(await response1.text()).toBe('Hello from origin!')
+        expect(response1.status).toBe(200)
+        expect(response1.headers.has('x-hello-from-middleware-res')).toBeTruthy()
+        expect(response1.headers.get('x-runtime')).toEqual(expectedRuntime)
+        expect(origin.calls).toBe(1)
+
+        // Request 2: Middleware should not run because we're sending the header.
+        const response2 = await invokeEdgeFunction(ctx, {
+          headers: {
+            'x-custom-header': 'custom-value',
+          },
+          functions: [edgeFunctionNameRoot],
+          origin,
+          url: '/foo',
+        })
 
-  test<FixtureTestContext>('should handle locale matching correctly', async (ctx) => {
-    await createFixture('middleware-conditions', ctx)
-    await runPlugin(ctx)
+        expect(await response2.text()).toBe('Hello from origin!')
+        expect(response2.status).toBe(200)
+        expect(response2.headers.has('x-hello-from-middleware-res')).toBeFalsy()
+        expect(origin.calls).toBe(2)
+      })
 
-    const origin = await LocalServer.run(async (req, res) => {
-      expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
+      test<FixtureTestContext>('should handle locale matching correctly', async (ctx) => {
+        await createFixture('middleware-conditions', ctx)
+        await runPlugin(ctx, runPluginConstants)
 
-      res.write('Hello from origin!')
-      res.end()
-    })
+        const origin = await LocalServer.run(async (req, res) => {
+          expect(req.headers['x-hello-from-middleware-req']).toBeUndefined()
 
-    ctx.cleanup?.push(() => origin.stop())
+          res.write('Hello from origin!')
+          res.end()
+        })
 
-    for (const path of ['/hello', '/en/hello', '/nl/hello', '/nl/about']) {
-      const response = await invokeEdgeFunction(ctx, {
-        functions: [EDGE_MIDDLEWARE_FUNCTION_NAME],
-        origin,
-        url: path,
-      })
-      expect(
-        response.headers.has('x-hello-from-middleware-res'),
-        `should match ${path}`,
-      ).toBeTruthy()
-      expect(await response.text()).toBe('Hello from origin!')
-      expect(response.status).toBe(200)
-    }
+        ctx.cleanup?.push(() => origin.stop())
 
-    for (const path of ['/invalid/hello', '/hello/invalid', '/about', '/en/about']) {
-      const response = await invokeEdgeFunction(ctx, {
-        functions: [EDGE_MIDDLEWARE_FUNCTION_NAME],
-        origin,
-        url: path,
+        for (const path of ['/hello', '/en/hello', '/nl/hello', '/nl/about']) {
+          const response = await invokeEdgeFunction(ctx, {
+            functions: [edgeFunctionNameRoot],
+            origin,
+            url: path,
+          })
+          expect(
+            response.headers.has('x-hello-from-middleware-res'),
+            `should match ${path}`,
+          ).toBeTruthy()
+          expect(response.headers.get('x-runtime')).toEqual(expectedRuntime)
+          expect(await response.text()).toBe('Hello from origin!')
+          expect(response.status).toBe(200)
+        }
+
+        for (const path of ['/invalid/hello', '/hello/invalid', '/about', '/en/about']) {
+          const response = await invokeEdgeFunction(ctx, {
+            functions: [edgeFunctionNameRoot],
+            origin,
+            url: path,
+          })
+          expect(
+            response.headers.has('x-hello-from-middleware-res'),
+            `should not match ${path}`,
+          ).toBeFalsy()
+          expect(await response.text()).toBe('Hello from origin!')
+          expect(response.status).toBe(200)
+        }
       })
-      expect(
-        response.headers.has('x-hello-from-middleware-res'),
-        `should not match ${path}`,
-      ).toBeFalsy()
-      expect(await response.text()).toBe('Hello from origin!')
-      expect(response.status).toBe(200)
-    }
+    })
   })
-})
+}
 
 describe('should run middleware on data requests', () => {
   test<FixtureTestContext>('when `trailingSlash: false`', async (ctx) => {