Add generic handler tests using framework (#30)

Author: jpwilliams

package.json

@@ -19,7 +19,7 @@
     "pb:version": "genversion --semi --double --es6 ./src/version.ts",
     "pb:landing": "yarn build:landing && node -e 'const page = JSON.stringify(require(\"fs\").readFileSync(\"./landing/dist/index.html\").toString()); console.log(\"export const landing = \" + page);' > ./src/landing.ts && npx prettier ./src/landing.ts --write",
     "build": "yarn run clean && tsc --project tsconfig.build.json",
-    "test": "jest --passWithNoTests",
+    "test": "node --expose-gc --max-old-space-size=4096 ./node_modules/.bin/jest --silent --logHeapUsage --maxWorkers=8",
     "clean": "rm -rf ./dist",
     "lint": "eslint .",
     "postversion": "yarn run build && yarn run build:copy",
@@ -71,6 +71,7 @@
     "genversion": "^3.1.1",
     "jest": "27.5.1",
     "next": "^12.3.0",
+    "nock": "^13.2.9",
     "node-mocks-http": "^1.11.0",
     "nodemon": "^2.0.20",
     "np": "^7.6.1",

src/cloudflare.test.ts

@@ -1,22 +1,89 @@
+import fetch, { Headers, Response } from "cross-fetch";
 import * as CloudflareHandler from "./cloudflare";
 import { testFramework } from "./test/helpers";
 
 const originalProcess = process;
+const originalFetch = globalThis.fetch;
+const originalResponse = globalThis.Response;
+const originalHeaders = globalThis.Headers;
 
 testFramework("Cloudflare", CloudflareHandler, {
   lifecycleChanges: () => {
     beforeEach(() => {
       jest.resetModules();
-      process = undefined as unknown as NodeJS.Process;
+
+      /**
+       * Fake lack of any `process` global var; Cloudflare allows access to env
+       * vars by passing them in to the request handler.
+       *
+       * Because of some test components (mainly `debug`) that use
+       * `process.stderr`, we do need to provide some pieces of this, but we can
+       * still remove any env vars.
+       */
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      process.env = undefined as any;
+
+      /**
+       * Fake a global `fetch` value, which is available as the Cloudflare
+       * handler will use the global DOM `fetch`.
+       */
+      globalThis.fetch = fetch;
+
+      /**
+       * Fake a global `Response` class, which is used to create new responses
+       * for the handler.
+       */
+      globalThis.Response = Response;
+
+      /**
+       * Fake a global `Headers` class, which is used to create new Headers
+       * objects during response building.
+       */
+      globalThis.Headers = Headers;
     });
 
     afterEach(() => {
-      process = originalProcess;
+      /**
+       * Reset all changes made to the global scope
+       */
+      process.env = originalProcess.env;
+      globalThis.fetch = originalFetch;
+      globalThis.Response = originalResponse;
+      globalThis.Headers = originalHeaders;
+    });
+  },
+  transformReq: (req, res, env) => {
+    const headers = new Headers();
+    Object.entries(req.headers).forEach(([k, v]) => {
+      headers.set(k, v as string);
     });
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    (req as any).headers = headers;
+
+    return [
+      {
+        request: req,
+        env,
+      },
+    ];
+  },
+  transformRes: async (res, ret: Response) => {
+    const headers: Record<string, string> = {};
+
+    ret.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+
+    return {
+      status: ret.status,
+      body: await ret.text(),
+      headers,
+    };
   },
   envTests: () => {
     test("process should be undefined", () => {
-      expect(process).toBeUndefined();
+      expect(process.env).toBeUndefined();
     });
   },
   handlerTests: () => {

src/components/Inngest.ts

@@ -1,6 +1,6 @@
 import { envKeys } from "../helpers/consts";
 import { devServerAvailable, devServerUrl } from "../helpers/devserver";
-import { devServerHost, isProd } from "../helpers/env";
+import { devServerHost, hasProcessEnv, isProd } from "../helpers/env";
 import type {
   PartialK,
   SendEventPayload,
@@ -107,10 +107,7 @@ export class Inngest<Events extends Record<string, EventPayload>> {
     this.name = name;
 
     this.eventKey =
-      eventKey ||
-      (typeof process === "undefined"
-        ? ""
-        : process.env[envKeys.EventKey] || "");
+      eventKey || (hasProcessEnv() ? process.env[envKeys.EventKey] || "" : "");
 
     this.inngestBaseUrl = new URL(inngestBaseUrl);
     this.inngestApiUrl = new URL(`e/${this.eventKey}`, this.inngestBaseUrl);
@@ -271,7 +268,7 @@ export class Inngest<Events extends Record<string, EventPayload>> {
       // If the dev server host env var has been set we always want to use
       // the dev server - even if it's down.  Otherwise, optimistically use
       // it for non-prod services.
-      if (host !== undefined || await devServerAvailable(host, fetch)) {
+      if (host !== undefined || (await devServerAvailable(host, fetch))) {
         url = devServerUrl(host, `e/${this.eventKey}`).href;
       }
     }

src/express.test.ts

@@ -45,7 +45,7 @@ describe("InngestCommHandler", () => {
         { event: "test/event.name" },
         { step: new InngestStep(() => undefined) }
       );
-      const ch = new InngestCommHandler("test-1", [fn], {});
+      const ch = new InngestCommHandler("test-1", [fn], { landingPage: true });
       const handler = ch.createHandler() as RequestHandler;
       // Matches a real-world request using an express app
       const req: Request = httpMocks.createRequest({

src/helpers/env.ts

@@ -20,23 +20,25 @@ export const devServerHost = (): string | undefined => {
   // processed using webpack's DefinePlugin, which is dumb and does a straight
   // text replacement instead of actually understanding the AST, despite webpack
   // being fully capable of understanding the AST.
-  const values =
-    typeof process === "undefined"
-      ? []
-      : [
-          process.env.INNGEST_DEVSERVER_URL,
-          process.env.REACT_APP_INNGEST_DEVSERVER_URL,
-          process.env.NEXT_PUBLIC_INNGEST_DEVSERVER_URL,
-        ];
+  const values = hasProcessEnv()
+    ? [
+        process.env.INNGEST_DEVSERVER_URL,
+        process.env.REACT_APP_INNGEST_DEVSERVER_URL,
+        process.env.NEXT_PUBLIC_INNGEST_DEVSERVER_URL,
+      ]
+    : [];
 
   return values.find((a) => !!a);
 };
 
 export const isProd = (): boolean => {
-  const values =
-    typeof process === "undefined"
-      ? []
-      : [process.env.NODE_ENV, process.env.VERCEL_ENV, process.env.CONTEXT];
+  const values = hasProcessEnv()
+    ? [process.env.NODE_ENV, process.env.VERCEL_ENV, process.env.CONTEXT]
+    : [];
 
   return values.includes("production");
 };
+
+export const hasProcessEnv = (): boolean => {
+  return typeof process !== "undefined" && "env" in process;
+};

src/remix.test.ts

@@ -1,4 +1,30 @@
+import { Headers } from "cross-fetch";
 import * as RemixHandler from "./remix";
 import { testFramework } from "./test/helpers";
 
-testFramework("Remix", RemixHandler);
+testFramework("Remix", RemixHandler, {
+  transformReq: (req) => {
+    const headers = new Headers();
+    Object.entries(req.headers).forEach(([k, v]) => {
+      headers.set(k, v as string);
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    (req as any).headers = headers;
+
+    return [{ request: req }];
+  },
+  transformRes: async (res, ret: Response) => {
+    const headers: Record<string, string> = {};
+
+    ret.headers.forEach((v, k) => {
+      headers[k] = v;
+    });
+
+    return {
+      status: ret.status,
+      body: await ret.text(),
+      headers,
+    };
+  },
+});

src/remix.ts

@@ -66,6 +66,7 @@ class RemixCommHandler extends InngestCommHandler {
 
             return new Response(JSON.stringify(introspection), {
               status: 200,
+              headers,
             });
           }