test(backend): add tests for waitlist controller to support v2 answer schema

Author: tyler-dane

packages/backend/src/waitlist/controller/waitlist.controller-add.test.ts

@@ -1,20 +1,45 @@
+import type { Express } from "express";
 import request from "supertest";
-import type { Answers_v1 } from "@core/types/waitlist/waitlist.answer.types";
+import type {
+  Answers_v1,
+  Answers_v2,
+} from "@core/types/waitlist/waitlist.answer.types";
 
 describe("POST /api/waitlist", () => {
-  beforeEach(() => jest.resetModules());
-  it("should return 400 if answers are invalid", async () => {
-    jest.doMock("../service/waitlist.service", () => ({
-      __esModule: true,
-      default: {
-        addToWaitlist: jest.fn(),
-      },
-    }));
+  let app: Express;
+  let mockAddToWaitlist: jest.Mock;
+
+  const createTestApp = async (mocks?: {
+    env?: Record<string, unknown>;
+    service?: Record<string, unknown>;
+  }) => {
+    if (mocks?.env) {
+      jest.doMock("@backend/common/constants/env.constants", () => mocks.env);
+    }
+    if (mocks?.service) {
+      jest.doMock("../service/waitlist.service", () => mocks.service);
+    }
+
     const { WaitlistController } = await import("./waitlist.controller");
     const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    const testApp = express();
+    testApp.use(express.json());
+    testApp.post("/api/waitlist", WaitlistController.addToWaitlist);
+    return testApp;
+  };
+
+  beforeEach(() => {
+    jest.resetModules();
+    mockAddToWaitlist = jest.fn();
+  });
+
+  it("should return 400 if answers are invalid", async () => {
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
 
     const res = await request(app)
       .post("/api/waitlist")
@@ -24,18 +49,14 @@ describe("POST /api/waitlist", () => {
     expect(res.error).toBeDefined();
   });
 
-  it("should return 200 if answers are valid", async () => {
-    jest.doMock("../service/waitlist.service", () => ({
-      __esModule: true,
-      default: {
-        addToWaitlist: jest.fn().mockResolvedValue(undefined),
+  it("should return 200 if v1 answers are valid", async () => {
+    mockAddToWaitlist.mockResolvedValue(undefined);
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
       },
-    }));
-    const { WaitlistController } = await import("./waitlist.controller");
-    const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    });
 
     const answers: Answers_v1 = {
       email: "test@example.com",
@@ -47,22 +68,43 @@ describe("POST /api/waitlist", () => {
       currentlyPayingFor: [],
       anythingElse: "I'm a test",
     };
+
+    const res = await request(app).post("/api/waitlist").send(answers);
+
+    expect(res.status).toBe(200);
+    expect(res.body.error).not.toBeDefined();
+    expect(mockAddToWaitlist).toHaveBeenCalledWith(answers.email, answers);
+  });
+
+  it("should return 200 if v2 answers are valid", async () => {
+    mockAddToWaitlist.mockResolvedValue(undefined);
+    app = await createTestApp({
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
+
+    const answers: Answers_v2 = {
+      email: "test@example.com",
+      schemaVersion: "2",
+    };
+
     const res = await request(app).post("/api/waitlist").send(answers);
 
     expect(res.status).toBe(200);
     expect(res.body.error).not.toBeDefined();
+    expect(mockAddToWaitlist).toHaveBeenCalledWith(answers.email, answers);
   });
-  // this test is at the bottom to avoid
-  // having to reset ENV in each test
+
   it("should return 500 if emailer values are missing", async () => {
-    jest.doMock("@backend/common/constants/env.constants", () => ({
-      ENV: {},
-    }));
-    const { WaitlistController } = await import("./waitlist.controller");
-    const express = (await import("express")).default;
-    const app = express();
-    app.use(express.json());
-    app.post("/api/waitlist", WaitlistController.addToWaitlist);
+    app = await createTestApp({
+      env: { ENV: {} },
+      service: {
+        __esModule: true,
+        default: { addToWaitlist: mockAddToWaitlist },
+      },
+    });
 
     const answers: Answers_v1 = {
       email: "test@example.com",
@@ -73,6 +115,7 @@ describe("POST /api/waitlist", () => {
       currentlyPayingFor: [],
       profession: "Founder",
     };
+
     const res = await request(app).post("/api/waitlist").send(answers);
     expect(res.status).toBe(500);
     expect(res.body.error).toBe("Missing emailer value(s)");

packages/backend/src/waitlist/controller/waitlist.controller.ts

@@ -2,54 +2,58 @@ import { Request, Response } from "express";
 import { z } from "zod";
 import { BaseError } from "@core/errors/errors.base";
 import { Logger } from "@core/logger/winston.logger";
-import { Answers } from "@core/types/waitlist/waitlist.answer.types";
-import { Schema_Waitlist } from "@core/types/waitlist/waitlist.types";
+import {
+  Answers,
+  Answers_v1,
+  Answers_v2,
+} from "@core/types/waitlist/waitlist.answer.types";
 import { isMissingWaitlistTagId } from "@backend/common/constants/env.util";
 import { findCompassUserBy } from "../../user/queries/user.queries";
 import WaitlistService from "../service/waitlist.service";
 import { EmailSchema } from "../types/waitlist.types";
 
 const logger = Logger("app:waitlist.controller");
+const WaitlistAnswerSchema = Answers.v1.or(Answers.v2);
 
 export class WaitlistController {
   private static EmailQuerySchema = z.object({ email: EmailSchema });
 
+  private static handleError(err: unknown, res: Response) {
+    if (err instanceof BaseError) {
+      logger.error(err);
+      return res.status(err.statusCode).json({ error: err.description });
+    }
+    if (err instanceof Error) {
+      logger.error(err);
+      return res.status(500).json({ error: err.message });
+    }
+    logger.error("caught unknown error");
+    return res.status(500).json({ error: "Server error" });
+  }
+
   static async addToWaitlist(
-    req: Request<unknown, unknown, Schema_Waitlist>,
+    req: Request<unknown, unknown, Answers_v1 | Answers_v2>,
     res: Response,
   ) {
     if (isMissingWaitlistTagId()) {
       return res.status(500).json({ error: "Missing emailer value(s)" });
     }
 
-    const parseResult = Answers.v1.safeParse(req.body);
+    const parseResult = WaitlistAnswerSchema.safeParse(req.body);
     if (!parseResult.success) {
       return res
         .status(400)
         .json({ error: "Invalid input", details: parseResult.error.flatten() });
     }
 
-    const answers = parseResult.data;
     try {
       const result = await WaitlistService.addToWaitlist(
-        answers.email,
-        answers,
+        parseResult.data.email,
+        parseResult.data,
       );
       return res.status(200).json(result);
     } catch (err) {
-      // If the error is a BaseError (including EmailerError), return its status and description
-      if (err instanceof BaseError) {
-        logger.error(err);
-        return res.status(err.statusCode).json({ error: err.description });
-      }
-      // If it's a generic Error, return its message
-      if (err instanceof Error) {
-        logger.error(err);
-        return res.status(500).json({ error: err.message });
-      }
-      // Otherwise, return a generic server error
-      logger.error("caught unknown error");
-      return res.status(500).json({ error: "Server error" });
+      return WaitlistController.handleError(err, res);
     }
   }
 
@@ -81,14 +85,22 @@ export class WaitlistController {
         findCompassUserBy("email", email),
         WaitlistService.getWaitlistRecord(email),
       ]);
+
     const isActive = !!existingUser;
-    const status = {
+    const name =
+      waitlistRecord && "firstName" in waitlistRecord
+        ? {
+            firstName: waitlistRecord.firstName,
+            lastName: waitlistRecord.lastName,
+          }
+        : undefined;
+
+    return res.status(200).json({
       isOnWaitlist,
       isInvited,
       isActive,
-      firstName: waitlistRecord?.firstName ?? existingUser?.firstName,
-      lastName: waitlistRecord?.lastName ?? existingUser?.lastName,
-    };
-    return res.status(200).json(status);
+      firstName: name?.firstName ?? existingUser?.firstName,
+      lastName: name?.lastName ?? existingUser?.lastName,
+    });
   }
 }