test: split loading and invoking function

Author: pieh

tests/utils/fixture.ts

@@ -14,7 +14,7 @@ import { env } from 'node:process'
 import { fileURLToPath } from 'node:url'
 import { v4 } from 'uuid'
 import { LocalServer } from './local-server.js'
-import { loadAndInvokeFunctionImpl, type FunctionInvocationOptions } from './lambda-helpers.mjs'
+import { loadFunction, type FunctionInvocationOptions } from './lambda-helpers.mjs'
 
 import { glob } from 'fast-glob'
 import {
@@ -345,7 +345,8 @@ export async function invokeFunction(
     .spyOn(process, 'cwd')
     .mockReturnValue(join(ctx.functionDist, SERVER_HANDLER_NAME))
   try {
-    return await loadAndInvokeFunctionImpl(ctx, options)
+    const invokeFunctionImpl = await loadFunction(ctx, options)
+    return await invokeFunctionImpl(options)
   } finally {
     cwdMock.mockRestore()
   }

tests/utils/lambda-helpers.mjs

@@ -20,6 +20,8 @@ const SERVER_HANDLER_NAME = '___netlify-server-handler'
  * @property {string} [url] TThe relative path that should be requested. Defaults to '/'
  * @property {Record<string, string>} [headers] The headers used for the invocation
  * @property {Record<string, unknown>} [flags] Feature flags that should be set during the invocation
+ *
+ * @typedef {Pick<FunctionInvocationOptions, 'env'>} LoadFunctionOptions
  */
 
 /**
@@ -109,73 +111,84 @@ const DEFAULT_FLAGS = {}
 
 /**
  * @param {FixtureTestContext} ctx
- * @param {FunctionInvocationOptions} options
+ * @param {LoadFunctionOptions} options
  */
-export async function loadAndInvokeFunctionImpl(
-  ctx,
-  { headers, httpMethod, flags, url, env } = {},
-) {
+export async function loadFunction(ctx, { env } = {}) {
   const restoreEnvironment = temporarilySetEnv(ctx, env)
 
   const { handler } = await import(
     'file:///' + join(ctx.functionDist, SERVER_HANDLER_NAME, '___netlify-entry-point.mjs')
   )
 
-  let resolveInvocation, rejectInvocation
-  const invocationPromise = new Promise((resolve, reject) => {
-    resolveInvocation = resolve
-    rejectInvocation = reject
-  })
+  /**
+   * @param {FunctionInvocationOptions} options
+   */
+  async function invokeFunction({ headers, httpMethod, flags, url, env: invokeEnv } = {}) {
+    const restoreEnvironment = temporarilySetEnv(ctx, {
+      ...env,
+      ...invokeEnv,
+    })
 
-  const response = await execute({
-    event: {
-      headers: headers || {},
-      httpMethod: httpMethod || 'GET',
-      rawUrl: new URL(url || '/', 'https://example.netlify').href,
-      flags: flags ?? DEFAULT_FLAGS,
-    },
-    lambdaFunc: { handler },
-    timeoutMs: 4_000,
-    onInvocationEnd: (error) => {
-      // lambda-local resolve promise return from execute when response is closed
-      // but we should wait for tracked background work to finish
-      // before resolving the promise to allow background work to finish
-      if (error) {
-        rejectInvocation(error)
-      } else {
-        resolveInvocation()
-      }
-    },
-  })
+    let resolveInvocation, rejectInvocation
+    const invocationPromise = new Promise((resolve, reject) => {
+      resolveInvocation = resolve
+      rejectInvocation = reject
+    })
+
+    const response = await execute({
+      event: {
+        headers: headers || {},
+        httpMethod: httpMethod || 'GET',
+        rawUrl: new URL(url || '/', 'https://example.netlify').href,
+        flags: flags ?? DEFAULT_FLAGS,
+      },
+      lambdaFunc: { handler },
+      timeoutMs: 4_000,
+      onInvocationEnd: (error) => {
+        // lambda-local resolve promise return from execute when response is closed
+        // but we should wait for tracked background work to finish
+        // before resolving the promise to allow background work to finish
+        if (error) {
+          rejectInvocation(error)
+        } else {
+          resolveInvocation()
+        }
+      },
+    })
 
-  await invocationPromise
+    await invocationPromise
 
-  if (!response) {
-    throw new Error('No response from lambda-local')
-  }
+    if (!response) {
+      throw new Error('No response from lambda-local')
+    }
 
-  const responseHeaders = Object.entries(response.multiValueHeaders || {}).reduce(
-    (prev, [key, value]) => ({
-      ...prev,
-      [key]: value.length === 1 ? `${value}` : value.join(', '),
-    }),
-    response.headers || {},
-  )
+    const responseHeaders = Object.entries(response.multiValueHeaders || {}).reduce(
+      (prev, [key, value]) => ({
+        ...prev,
+        [key]: value.length === 1 ? `${value}` : value.join(', '),
+      }),
+      response.headers || {},
+    )
 
-  const bodyBuffer = await streamToBuffer(response.body)
+    const bodyBuffer = await streamToBuffer(response.body)
 
-  restoreEnvironment()
+    restoreEnvironment()
 
-  return {
-    statusCode: response.statusCode,
-    bodyBuffer,
-    body: bodyBuffer.toString('utf-8'),
-    headers: responseHeaders,
-    isBase64Encoded: response.isBase64Encoded,
+    return {
+      statusCode: response.statusCode,
+      bodyBuffer,
+      body: bodyBuffer.toString('utf-8'),
+      headers: responseHeaders,
+      isBase64Encoded: response.isBase64Encoded,
+    }
   }
+
+  restoreEnvironment()
+
+  return invokeFunction
 }
 
 /**
- * @typedef {typeof loadAndInvokeFunctionImpl} InvokeFunction
+ * @typedef {Awaited<ReturnType<typeof loadFunction>>} InvokeFunction
  * @typedef {Promise<Awaited<ReturnType<InvokeFunction>>>} InvokeFunctionResult
  */

tests/utils/sandbox-child.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 
 import { getLogger } from 'lambda-local'
-import { loadAndInvokeFunctionImpl } from './lambda-helpers.mjs'
+import { loadFunction } from './lambda-helpers.mjs'
 
 getLogger().level = 'alert'
 
@@ -17,7 +17,9 @@ process.on(
       try {
         const [ctx, options] = msg.args
 
-        const result = await loadAndInvokeFunctionImpl(ctx, options)
+        const invokeFunctionImpl = await loadFunction(ctx, options)
+        const result = await invokeFunctionImpl(options)
+
         if (process.send) {
           process.send({
             action: 'invokeFunctionResult',