refactor: update Vitest to v3

This involved fixing the incorrect use of the global `expect` in
concurrent tests and replacing the deprecated `TaskContext` type with
`TestContext`.

Author: renovate[bot]

package-lock.json

@@ -195,7 +195,7 @@
     "@types/through2-map": "3.0.4",
     "@types/write-file-atomic": "4.0.3",
     "@types/ws": "8.18.0",
-    "@vitest/coverage-v8": "1.6.1",
+    "@vitest/coverage-v8": "3.0.8",
     "@vitest/eslint-plugin": "^1.1.36",
     "c8": "10.1.3",
     "cheerio": "1.0.0",
@@ -217,7 +217,7 @@
     "typescript": "5.7.3",
     "typescript-eslint": "^8.26.0",
     "verdaccio": "6.0.5",
-    "vitest": "1.6.1"
+    "vitest": "3.0.8"
   },
   "ava": {
     "files": [

package.json

@@ -2,7 +2,7 @@ import path, { join } from 'path'
 import process from 'process'
 
 import execa from 'execa'
-import { describe, expect, test, type TaskContext, type TestContext } from 'vitest'
+import { describe, expect, test, type TestContext } from 'vitest'
 
 import { callCli } from '../../utils/call-cli.js'
 import { cliPath } from '../../utils/cli-path.js'
@@ -22,7 +22,7 @@ const defaultEnvs = {
  *  - that its output contains `output`
  */
 const runBuildCommand = async function (
-  t: TaskContext & TestContext,
+  t: TestContext,
   cwd: string,
   options: Partial<{
     exitCode: number

tests/integration/commands/build/build.test.ts

@@ -4,7 +4,7 @@ import { join } from 'path'
 
 import execa from 'execa'
 import fetch from 'node-fetch'
-import { describe, expect, test } from 'vitest'
+import { describe, test } from 'vitest'
 
 import { withDevServer } from '../../utils/dev-server.js'
 import { FixtureTestContext, setupFixtureTests } from '../../utils/fixture.js'
@@ -51,7 +51,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
     'dev-server-with-edge-functions',
     { devServer: true, mockApi: { routes }, setupAfterDev: recreateEdgeFunctions },
     () => {
-      test<FixtureTestContext>('should run edge functions in correct order', async ({ devServer }) => {
+      test<FixtureTestContext>('should run edge functions in correct order', async ({ devServer, expect }) => {
         const response = await fetch(`http://localhost:${devServer!.port}/ordertest`)
         const body = await response.text()
 
@@ -71,7 +71,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
         ])
       })
 
-      test<FixtureTestContext>('should provide context properties', async ({ devServer }) => {
+      test<FixtureTestContext>('should provide context properties', async ({ devServer, expect }) => {
         const response = await fetch(`http://localhost:${devServer!.port}/context`)
 
         const body = await response.json()
@@ -87,7 +87,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
         })
       })
 
-      test<FixtureTestContext>('should expose URL parameters', async ({ devServer }) => {
+      test<FixtureTestContext>('should expose URL parameters', async ({ devServer, expect }) => {
         const response = await fetch(`http://localhost:${devServer!.port}/categories/foo/products/bar`)
 
         const body = await response.json()
@@ -99,6 +99,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
 
       test<FixtureTestContext>('should expose URL parameters to edge functions with `cache: "manual"`', async ({
         devServer,
+        expect,
       }) => {
         const response = await fetch(`http://localhost:${devServer!.port}/categories-after-cache/foo/products/bar`)
 
@@ -109,7 +110,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
         })
       })
 
-      test<FixtureTestContext>('should respect config.methods field', async ({ devServer }) => {
+      test<FixtureTestContext>('should respect config.methods field', async ({ devServer, expect }) => {
         const responseGet = await fetch(`http://localhost:${devServer!.port}/products/really-bad-product`, {
           method: 'GET',
         })
@@ -125,6 +126,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
 
       test<FixtureTestContext>('should show an error page when an edge function has an uncaught exception', async ({
         devServer,
+        expect,
       }) => {
         const [plainTextResponse, htmlResponse] = await Promise.all([
           fetch(`http://localhost:${devServer!.port}/uncaught-exception`, {
@@ -148,6 +150,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
 
       test<FixtureTestContext>('should set the `URL`, `SITE_ID`, and `SITE_NAME` environment variables', async ({
         devServer,
+        expect,
       }) => {
         const body = (await fetch(`http://localhost:${devServer!.port}/echo-env`).then((res) => res.json())) as Record<
           string,
@@ -171,6 +174,7 @@ describe.skipIf(isWindows)('edge functions', async () => {
     () => {
       test<FixtureTestContext>('skips edge functions when --internal-disable-edge-functions is passed', async ({
         devServer,
+        expect,
       }) => {
         const response = await fetch(`http://localhost:${devServer!.port}/ordertest`)
         const body = await response.text()
@@ -183,7 +187,11 @@ describe.skipIf(isWindows)('edge functions', async () => {
   )
 
   await setupFixtureTests('dev-server-with-edge-functions', { devServer: true, mockApi: { routes } }, () => {
-    test<FixtureTestContext>('should not remove other edge functions on change', async ({ devServer, fixture }) => {
+    test<FixtureTestContext>('should not remove other edge functions on change', async ({
+      devServer,
+      expect,
+      fixture,
+    }) => {
       // we need to wait till file watchers are loaded
       await pause(500)
 
@@ -202,6 +210,8 @@ describe.skipIf(isWindows)('edge functions', async () => {
   })
 
   test('should reload on change to transitive dependency', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder
         .withContentFile({
@@ -223,8 +233,9 @@ describe.skipIf(isWindows)('edge functions', async () => {
         .build()
 
       await withDevServer({ cwd: builder.directory }, async (server) => {
-        const response = await fetch(server.url, {}).then((res) => res.text())
-        t.expect(response).toEqual('foo')
+        const response = await fetch(server.url, {})
+        const text = await response.text()
+        expect(text).toEqual('foo')
 
         // update file
         await builder
@@ -236,13 +247,16 @@ describe.skipIf(isWindows)('edge functions', async () => {
 
         await pause(500)
 
-        const response2 = await fetch(server.url, {}).then((res) => res.text())
-        t.expect(response2).toEqual('bar')
+        const response2 = await fetch(server.url, {})
+        const text2 = await response2.text()
+        expect(text2).toEqual('bar')
       })
     })
   })
 
   test('functions and edge functions should receive url-encoded search params in the same way', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder
         .withContentFile({
@@ -264,8 +278,8 @@ describe.skipIf(isWindows)('edge functions', async () => {
       await withDevServer({ cwd: builder.directory }, async (server) => {
         const funcResponse = await fetch(new URL('/func?1,2,3', server.url), {})
         const efResponse = await fetch(new URL('/ef?1,2,3', server.url), {})
-        t.expect(await funcResponse.text()).toEqual('?1,2,3')
-        t.expect(await efResponse.text()).toEqual('?1,2,3')
+        expect(await funcResponse.text()).toEqual('?1,2,3')
+        expect(await efResponse.text()).toEqual('?1,2,3')
       })
     })
   })
@@ -274,7 +288,10 @@ describe.skipIf(isWindows)('edge functions', async () => {
     'dev-server-with-edge-functions-and-npm-modules',
     { devServer: true, mockApi: { routes }, setup },
     () => {
-      test<FixtureTestContext>('should run an edge function that uses the Blobs npm module', async ({ devServer }) => {
+      test<FixtureTestContext>('should run an edge function that uses the Blobs npm module', async ({
+        devServer,
+        expect,
+      }) => {
         const res = await fetch(`http://localhost:${devServer!.port}/blobs`, {
           method: 'GET',
         })

tests/integration/commands/dev/edge-functions.test.ts

@@ -3,7 +3,7 @@ import { readFile } from 'fs/promises'
 import { join } from 'path'
 
 import execa from 'execa'
-import { describe, expect, test } from 'vitest'
+import { describe, test } from 'vitest'
 
 import { fileExistsAsync } from '../../../../src/lib/fs.js'
 import { cliPath } from '../../utils/cli-path.js'
@@ -36,6 +36,8 @@ describe.concurrent('functions:create command', async () => {
   ]
 
   test('should create a new function directory when none is found', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder.build()
       await withMockApi(routes, async ({ apiUrl }) => {
@@ -72,6 +74,8 @@ describe.concurrent('functions:create command', async () => {
   })
 
   test('should create a new edge function directory when none is found', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder.build()
       await withMockApi(routes, async ({ apiUrl }) => {
@@ -108,6 +112,8 @@ describe.concurrent('functions:create command', async () => {
   })
 
   test('should use specified edge function directory when found', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       builder.withNetlifyToml({ config: { build: { edge_functions: 'somethingEdgy' } } })
       await builder.build()
@@ -144,6 +150,8 @@ describe.concurrent('functions:create command', async () => {
   })
 
   test('should not create a new function directory when one is found', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       builder.withNetlifyToml({ config: { build: { functions: 'functions' } } })
 
@@ -181,6 +189,8 @@ describe.concurrent('functions:create command', async () => {
   })
 
   test('should only show function templates for the language specified via the --language flag, if one is present', async (t) => {
+    const { expect } = t
+
     const createWithLanguageTemplate = async (language: string, outputPath: string) => {
       await withSiteBuilder(t, async (builder) => {
         await builder.build()
@@ -225,6 +235,8 @@ describe.concurrent('functions:create command', async () => {
   })
 
   test('throws an error when the --language flag contains an unsupported value', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder.build()
 
@@ -264,7 +276,7 @@ describe.concurrent('functions:create command', async () => {
   })
 
   await setupFixtureTests('nx-integrated-monorepo', () => {
-    test<FixtureTestContext>('should create a new edge function', async ({ fixture, expect }) => {
+    test<FixtureTestContext>('should create a new edge function', async ({ expect, fixture }) => {
       await withMockApi(routes, async ({ apiUrl }) => {
         const childProcess = execa(
           cliPath,
@@ -319,7 +331,7 @@ describe.concurrent('functions:create command', async () => {
       // await devServer.waitForLogMatching('Loaded edge function new')
       // expect(devServer.output).not.toContain('Removed edge function')
     })
-    test<FixtureTestContext>('should create a new serverless function', async ({ fixture }) => {
+    test<FixtureTestContext>('should create a new serverless function', async ({ expect, fixture }) => {
       await withMockApi(routes, async ({ apiUrl }) => {
         const childProcess = execa(
           cliPath,

tests/integration/commands/functions-create/functions-create.test.ts

@@ -4,7 +4,7 @@ import { readFile } from 'node:fs/promises'
 import cleanDeep from 'clean-deep'
 import execa from 'execa'
 import toml from 'toml'
-import { describe, test, type TaskContext, type TestContext } from 'vitest'
+import { describe, test, type TestContext } from 'vitest'
 
 import { cliPath } from '../../utils/cli-path.js'
 import { CONFIRM, DOWN, answerWithValue, handleQuestions } from '../../utils/handle-questions.js'
@@ -14,7 +14,7 @@ import { withSiteBuilder } from '../../utils/site-builder.js'
 const defaultFunctionsDirectory = 'netlify/functions'
 
 const assertNetlifyToml = async (
-  t: TaskContext & TestContext,
+  t: TestContext,
   tomlDir: string,
   { command, functions, publish }: { command: string; functions: string; publish: string },
 ) => {

tests/integration/commands/init/init.test.ts

@@ -12,7 +12,7 @@ import { MockApi, Route, getCLIOptions, startMockApi } from './mock-api-vitest.j
 import { SiteBuilder } from './site-builder.js'
 
 const FIXTURES_DIRECTORY = fileURLToPath(new URL('../__fixtures__/', import.meta.url))
-const HOOK_TIMEOUT = 30_000
+const HOOK_TIMEOUT = 60_000
 
 interface MockApiOptions {
   routes: Route[]

tests/integration/utils/fixture.ts

@@ -13,7 +13,7 @@ import serializeJS from 'serialize-javascript'
 import tempDirectory from 'temp-dir'
 import tomlify from 'tomlify-j0.4'
 import { v4 as uuidv4 } from 'uuid'
-import type { TaskContext } from 'vitest'
+import type { TestContext } from 'vitest'
 
 const ensureDir = (directory: string) => mkdir(directory, { recursive: true })
 
@@ -331,15 +331,15 @@ export const createSiteBuilder = ({ siteName }: { siteName: string }) => {
 }
 
 /**
- * @param taskContext used to infer directory name from test name
+ * @param context used to infer directory name from test name
  */
 export async function withSiteBuilder<T>(
-  taskContext: TaskContext,
+  context: TestContext,
   testHandler: (builder: SiteBuilder) => Promise<T>,
 ): Promise<T> {
   let builder: SiteBuilder | undefined
   try {
-    builder = createSiteBuilder({ siteName: slugify(taskContext.task.name) })
+    builder = createSiteBuilder({ siteName: slugify(context.task.name) })
     return await testHandler(builder)
   } finally {
     if (builder) await builder.cleanup()