test: fix use of expect in concurrent tests

Author: ndhoule

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

@@ -4,7 +4,7 @@ import { join } from 'path'
 
 import execa from 'execa'
 import fetch from 'node-fetch'
-import { describe, expect, expectTypeOf, test } from 'vitest'
+import { describe, expectTypeOf, 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', () => {
     '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', () => {
         ])
       })
 
-      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 { deploy, geo, ip, params, requestId, server, site } = await response.json()
@@ -85,7 +85,7 @@ describe.skipIf(isWindows)('edge functions', () => {
         expect(site).toEqual({ id: 'foo', name: 'site-name', url: `http://localhost:${devServer.port}` })
       })
 
-      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 { params } = await response.json()
@@ -97,6 +97,7 @@ describe.skipIf(isWindows)('edge functions', () => {
 
       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`)
 
@@ -107,7 +108,7 @@ describe.skipIf(isWindows)('edge functions', () => {
         })
       })
 
-      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',
         })
@@ -123,6 +124,7 @@ describe.skipIf(isWindows)('edge functions', () => {
 
       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`, {
@@ -146,6 +148,7 @@ describe.skipIf(isWindows)('edge functions', () => {
 
       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,
@@ -169,6 +172,7 @@ describe.skipIf(isWindows)('edge functions', () => {
     () => {
       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()
@@ -181,7 +185,11 @@ describe.skipIf(isWindows)('edge functions', () => {
   )
 
   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)
 
@@ -200,6 +208,8 @@ describe.skipIf(isWindows)('edge functions', () => {
   })
 
   test('should reload on change to transitive dependency', async (t) => {
+    const { expect } = t
+
     await withSiteBuilder(t, async (builder) => {
       await builder
         .withContentFile({
@@ -221,8 +231,9 @@ describe.skipIf(isWindows)('edge functions', () => {
         .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
@@ -234,13 +245,16 @@ describe.skipIf(isWindows)('edge functions', () => {
 
         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({
@@ -262,8 +276,8 @@ describe.skipIf(isWindows)('edge functions', () => {
       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')
       })
     })
   })
@@ -272,7 +286,10 @@ describe.skipIf(isWindows)('edge functions', () => {
     '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/functions-create/functions-create.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', () => {
   ]
 
   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', () => {
   })
 
   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', () => {
   })
 
   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', () => {
   })
 
   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', () => {
   })
 
   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, outputPath) =>
       await withSiteBuilder(t, async (builder) => {
         await builder.build()
@@ -224,6 +234,8 @@ describe.concurrent('functions:create command', () => {
   })
 
   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()
 
@@ -263,7 +275,7 @@ describe.concurrent('functions:create command', () => {
   })
 
   setupFixtureTests('nx-integrated-monorepo', () => {
-    test<FixtureTestContext>('should create a new edge function', async ({ fixture }) => {
+    test<FixtureTestContext>('should create a new edge function', async ({ expect, fixture }) => {
       await withMockApi(routes, async ({ apiUrl }) => {
         const childProcess = execa(
           cliPath,
@@ -322,7 +334,7 @@ describe.concurrent('functions:create command', () => {
       // 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,