:bug fix(sign-up-import-gcal): update sync controller tests

Author: victor-enogwe

packages/backend/src/__tests__/drivers/sync.driver.ts

@@ -0,0 +1,41 @@
+import { WithId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import { Schema_User } from "@core/types/user.types";
+import mongoService from "@backend/common/services/mongo.service";
+import { Schema_Sync } from "../../../../core/src/types/sync.types";
+
+export class SyncDriver {
+  static async createSync(
+    user: Pick<WithId<Schema_User>, "_id">,
+    defaultUser = false,
+  ): Promise<WithId<Schema_Sync>> {
+    const gCalendarId = defaultUser ? "test-calendar" : faker.string.uuid();
+    const nextSyncToken = faker.internet.jwt();
+
+    const syncRecord: Schema_Sync = {
+      user: user._id.toString(),
+      google: {
+        calendarlist: [
+          {
+            gCalendarId,
+            nextSyncToken,
+            lastSyncedAt: new Date(),
+          },
+        ],
+        events: [
+          {
+            gCalendarId,
+            resourceId: faker.string.nanoid(),
+            channelId: faker.string.uuid(),
+            expiration: new Date(Date.now() + 3600000).toISOString(),
+            nextSyncToken,
+          },
+        ],
+      },
+    };
+
+    const created = await mongoService.sync.insertOne(syncRecord);
+
+    return { _id: created.insertedId, ...syncRecord };
+  }
+}

packages/backend/src/__tests__/drivers/user.driver.ts

@@ -0,0 +1,28 @@
+import { WithId } from "mongodb";
+import { faker } from "@faker-js/faker";
+import { Schema_User } from "@core/types/user.types";
+import mongoService from "@backend/common/services/mongo.service";
+
+export class UserDriver {
+  static async createUser(): Promise<WithId<Schema_User>> {
+    const firstName = faker.person.firstName();
+    const lastName = faker.person.lastName();
+
+    const user: Schema_User = {
+      email: faker.internet.email(),
+      firstName,
+      lastName,
+      name: `${firstName} ${lastName}`,
+      locale: faker.location.language().alpha2,
+      google: {
+        googleId: faker.string.uuid(),
+        picture: faker.internet.url({ protocol: "https" }),
+        gRefreshToken: faker.internet.jwt(),
+      },
+    };
+
+    const created = await mongoService.user.insertOne(user);
+
+    return { _id: created.insertedId, ...user };
+  }
+}

packages/backend/src/__tests__/drivers/waitlist.driver.ts

@@ -0,0 +1,28 @@
+import { WithId } from "mongodb";
+import { Schema_User } from "@core/types/user.types";
+import { Schema_Waitlist } from "@core/types/waitlist/waitlist.types";
+import mongoService from "@backend/common/services/mongo.service";
+
+export class WaitListDriver {
+  static async createWaitListRecord(
+    user: Pick<WithId<Schema_User>, "email" | "firstName" | "lastName">,
+  ): Promise<WithId<Schema_Waitlist>> {
+    const waitListRecord: Schema_Waitlist = {
+      email: user.email,
+      schemaVersion: "0",
+      source: "other",
+      firstName: user.firstName,
+      lastName: user.lastName,
+      currentlyPayingFor: ["superhuman", "notion"],
+      howClearAboutValues: "not-clear",
+      workingTowardsMainGoal: "yes",
+      isWillingToShare: false,
+      status: "waitlisted",
+      waitlistedAt: new Date().toISOString(),
+    };
+
+    const created = await mongoService.waitlist.insertOne(waitListRecord);
+
+    return { _id: created.insertedId, ...waitListRecord };
+  }
+}

packages/backend/src/__tests__/helpers/mock.db.setup.ts

@@ -1,10 +1,10 @@
-import { Db, ObjectId } from "mongodb";
+import { Db } from "mongodb";
 import { MongoMemoryServer } from "mongodb-memory-server";
-import { Schema_Sync } from "@core/types/sync.types";
-import { Schema_User } from "@core/types/user.types";
 import { Collections } from "@backend/common/constants/collections";
 import mongoService from "@backend/common/services/mongo.service";
-import { Schema_Waitlist } from "../../../../core/src/types/waitlist/waitlist.types";
+import { SyncDriver } from "../drivers/sync.driver";
+import { UserDriver } from "../drivers/user.driver";
+import { WaitListDriver } from "../drivers/waitlist.driver";
 
 export interface TestSetup {
   mongoServer: MongoMemoryServer;
@@ -29,75 +29,19 @@ export async function setupTestDb(): Promise<TestSetup> {
     await mongoServer.start();
     await mongoService.start(mongoServer.getUri());
 
-    const userId = new ObjectId();
-    const userIdStr = userId.toString();
-    const email = "test@example.com";
-
-    // test user
-    const user: Schema_User & { _id: ObjectId } = {
-      _id: userId,
-      email,
-      firstName: "Test",
-      lastName: "User",
-      name: "Test User",
-      locale: "en",
-      google: {
-        googleId: "test-google-id",
-        picture: "test-picture",
-        gRefreshToken: "fake-refresh-token",
-      },
-    };
-
-    // sync record for the user
-    const syncRecord: Schema_Sync = {
-      user: userIdStr,
-      google: {
-        calendarlist: [
-          {
-            gCalendarId: "test-calendar",
-            nextSyncToken: "initial-sync-token",
-            lastSyncedAt: new Date(),
-          },
-        ],
-        events: [
-          {
-            gCalendarId: "test-calendar",
-            resourceId: "test-resource-id",
-            channelId: "test-channel-id",
-            expiration: new Date(Date.now() + 3600000).toISOString(),
-            nextSyncToken: "initial-sync-token",
-          },
-        ],
-      },
-    };
-
-    // Create waitlist user
-    const waitlistRecord: Schema_Waitlist = {
-      email,
-      schemaVersion: "0",
-      source: "other",
-      firstName: "Test",
-      lastName: "User",
-      currentlyPayingFor: ["superhuman", "notion"],
-      howClearAboutValues: "not-clear",
-      workingTowardsMainGoal: "yes",
-      isWillingToShare: false,
-      status: "waitlisted",
-      waitlistedAt: new Date().toISOString(),
-    };
+    const user = await UserDriver.createUser();
 
     await Promise.all([
-      mongoService.user.insertOne(user),
-      mongoService.sync.insertOne(syncRecord),
-      mongoService.waitlist.insertOne(waitlistRecord),
+      SyncDriver.createSync(user, true),
+      WaitListDriver.createWaitListRecord(user),
     ]);
 
     return {
       mongoServer,
       mongoClient: mongoService,
       db: mongoService.db,
-      userId: userIdStr,
-      email,
+      userId: user._id.toString(),
+      email: user.email,
     };
   } catch (err) {
     const error = err as Error;