@netlify/functions/dist/lib/builder.test.mjs

JavaScript utilities for Netlify Functions

import {
  init_main,
  invokeLambda
} from "../chunk-QG2PP5NG.mjs";
import {
  globalExpect,
  init_dist,
  test
} from "../chunk-ZE4ZZELD.mjs";
import {
  init_builder,
  wrapHandler
} from "../chunk-6V4VUZWK.mjs";
import "../chunk-7VFCQORF.mjs";
import {
  __commonJS
} from "../chunk-C6P2IO65.mjs";

// src/lib/builder.test.ts
var require_builder_test = __commonJS({
  "src/lib/builder.test.ts"() {
    init_dist();
    init_main();
    init_builder();
    var METADATA_OBJECT = { metadata: { version: 1, builder_function: true, ttl: 0 } };
    test("Injects the metadata object into an asynchronous handler", async () => {
      const ttl = 3600;
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200,
        ttl
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler));
      globalExpect(response).toStrictEqual({ ...originalResponse, metadata: { version: 1, builder_function: true, ttl } });
    });
    test("Injects the metadata object into a synchronous handler", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = (event, context, callback) => {
        callback?.(null, originalResponse);
      };
      const response = await invokeLambda(wrapHandler(myHandler));
      globalExpect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT });
    });
    test("Injects the metadata object for non-200 responses", async () => {
      const originalResponse = {
        body: ":thumbsdown:",
        statusCode: 404
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler));
      globalExpect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT });
    });
    test("Returns a 405 error for requests using the POST method", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler), { method: "POST" });
      globalExpect(response).toStrictEqual({ body: "Method Not Allowed", statusCode: 405 });
    });
    test("Returns a 405 error for requests using the PUT method", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler), { method: "PUT" });
      globalExpect(response).toStrictEqual({ body: "Method Not Allowed", statusCode: 405 });
    });
    test("Returns a 405 error for requests using the DELETE method", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler), { method: "DELETE" });
      globalExpect(response).toStrictEqual({ body: "Method Not Allowed", statusCode: 405 });
    });
    test("Returns a 405 error for requests using the PATCH method", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        return originalResponse;
      };
      const response = await invokeLambda(wrapHandler(myHandler), { method: "PATCH" });
      globalExpect(response).toStrictEqual({ body: "Method Not Allowed", statusCode: 405 });
    });
    test("Preserves errors thrown inside the wrapped handler", async () => {
      const error = new Error("Uh-oh!");
      error.someProperty = ":thumbsdown:";
      const myHandler = async () => {
        const asyncTask = new Promise((resolve) => {
          setTimeout(resolve, 0);
        });
        await asyncTask;
        throw error;
      };
      try {
        await invokeLambda(wrapHandler(myHandler));
        throw new Error("Invocation should have failed");
      } catch {
      }
    });
    test("Does not pass query parameters to the wrapped handler", async () => {
      const originalResponse = {
        body: ":thumbsup:",
        statusCode: 200
      };
      const myHandler = async (event) => {
        globalExpect(event.multiValueQueryStringParameters).toStrictEqual({});
        globalExpect(event.queryStringParameters).toStrictEqual({});
        return originalResponse;
      };
      const multiValueQueryStringParameters = { foo: ["bar"], bar: ["baz"] };
      const queryStringParameters = { foo: "bar", bar: "baz" };
      const response = await invokeLambda(wrapHandler(myHandler), {
        // @ts-expect-error TODO: Fic types.
        multiValueQueryStringParameters,
        queryStringParameters
      });
      globalExpect(response).toStrictEqual({ ...originalResponse, ...METADATA_OBJECT });
    });
  }
});
export default require_builder_test();