Merge branch 'main' into fix-flaky-tests

Author: victor-enogwe

packages/backend/.env.example

@@ -28,6 +28,7 @@ TOKEN_GCAL_NOTIFICATION=ANOTHER_UNIQUE_STRING
 ####################################################
 # 2. Database                                      #
 ####################################################
+MONGOMS_VERSION=8.0.9 # pins the test mongo server binary version
 MONGO_URI=mongodb+srv://admin:YOUR_ADMIN_PW@cluster0.m99yy.mongodb.net/dev_calendar?authSource=admin&retryWrites=true&w=majority&tls=true
 
 

packages/backend/src/__tests__/backend.test.init.ts

@@ -1,6 +1,6 @@
 const mongoUri = (global as unknown as { __MONGO_URI__: string }).__MONGO_URI__;
 
-process.env["BASEURL"] = "http;s://foo.yourdomain.app";
+process.env["BASEURL"] = "https://foo.yourdomain.app";
 process.env["CORS"] =
   "https://foo.yourdomain.app,http://localhost:3000,http://localhost:9080";
 process.env["PORT"] = "3000";

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

@@ -1,14 +1,11 @@
 import { Db } from "mongodb";
-import { MongoMemoryServer } from "mongodb-memory-server";
+import { SyncDriver } from "@backend/__tests__/drivers/sync.driver";
+import { UserDriver } from "@backend/__tests__/drivers/user.driver";
+import { WaitListDriver } from "@backend/__tests__/drivers/waitlist.driver";
 import { Collections } from "@backend/common/constants/collections";
 import mongoService from "@backend/common/services/mongo.service";
-import { SyncDriver } from "../drivers/sync.driver";
-import { UserDriver } from "../drivers/user.driver";
-import { WaitListDriver } from "../drivers/waitlist.driver";
 
 export interface TestSetup {
-  mongoServer: MongoMemoryServer;
-  mongoClient: typeof mongoService;
   db: Db;
   userId: string;
   email: string;
@@ -21,13 +18,7 @@ export interface TestSetup {
  */
 export async function setupTestDb(): Promise<TestSetup> {
   try {
-    const dbName = process.env["DB"];
-
-    // Setup in-memory MongoDB
-    const mongoServer = new MongoMemoryServer({ instance: { dbName } });
-
-    await mongoServer.start();
-    await mongoService.start(mongoServer.getUri());
+    await mongoService.start();
 
     const user = await UserDriver.createUser();
 
@@ -37,8 +28,6 @@ export async function setupTestDb(): Promise<TestSetup> {
     ]);
 
     return {
-      mongoServer,
-      mongoClient: mongoService,
       db: mongoService.db,
       userId: user._id.toString(),
       email: user.email,
@@ -55,14 +44,10 @@ export async function setupTestDb(): Promise<TestSetup> {
   }
 }
 
-export async function cleanupCollections(db: Db): Promise<void> {
-  const collections = await db.collections();
+export async function cleanupCollections(): Promise<void> {
+  const collections = await mongoService.db.collections();
 
-  const SKIP_COLLECTIONS = [
-    Collections.USER,
-    Collections.SYNC,
-    Collections.WAITLIST,
-  ];
+  const SKIP_COLLECTIONS = [Collections.USER, Collections.SYNC];
 
   const selectedCollections = collections.filter(
     (collection) => !SKIP_COLLECTIONS.includes(collection.collectionName),
@@ -73,14 +58,10 @@ export async function cleanupCollections(db: Db): Promise<void> {
   );
 }
 
-export async function cleanupTestMongo({
-  mongoServer,
-  mongoClient,
-}: TestSetup): Promise<void> {
+export async function cleanupTestDb(): Promise<void> {
   try {
-    await mongoClient.stop();
-    await mongoServer.stop({ force: true, doCleanup: true });
+    await mongoService.stop();
   } catch (err) {
-    console.error("Error during cleanup:", err);
+    console.error("Error during test db cleanup:", err);
   }
 }

packages/backend/src/event/services/event.delete.test.ts

@@ -1,33 +1,33 @@
 import dayjs from "dayjs";
-import { Collection, Db, MongoClient, ObjectId } from "mongodb";
-import { YEAR_MONTH_DAY_FORMAT } from "@core/constants/date.constants";
-import { Schema_Event } from "@core/types/event.types";
+import { Collection, ObjectId } from "mongodb";
 import {
   mockSomedayRecurrences,
   newsletterId,
-} from "../../../../core/src/__mocks__/v1/events/events.someday.recur";
-import { getDeleteByIdFilter } from "./event.service.util";
+} from "@core/__mocks__/v1/events/events.someday.recur";
+import { YEAR_MONTH_DAY_FORMAT } from "@core/constants/date.constants";
+import { Schema_Event } from "@core/types/event.types";
+import {
+  cleanupTestDb,
+  setupTestDb,
+} from "@backend/__tests__/helpers/mock.db.setup";
+import mongoService from "@backend/common/services/mongo.service";
+import { getDeleteByIdFilter } from "@backend/event/services/event.service.util";
 
 describe("Delete Events", () => {
-  let connection: MongoClient;
-  let db: Db;
   let eventCollection: Collection<Schema_Event>;
 
   beforeAll(async () => {
-    // setup in-memory connection using jest-mongodb
-    connection = await MongoClient.connect(process.env["MONGO_URL"] as string);
-    db = await connection.db();
-    eventCollection = db.collection("event.delete.test");
+    await setupTestDb();
+
+    eventCollection = mongoService.db.collection("event.delete.test");
   });
 
   beforeEach(async () => {
     await eventCollection.deleteMany({});
     await eventCollection.insertMany([...mockSomedayRecurrences]);
   });
 
-  afterAll(async () => {
-    await connection.close();
-  });
+  afterAll(cleanupTestDb);
 
   describe("Recurring events: someday", () => {
     it("only deletes future instances", async () => {

packages/backend/src/event/services/event.find.allday.test.ts

@@ -1,33 +1,31 @@
-import { Collection, Db, Filter, MongoClient } from "mongodb";
+import { Filter } from "mongodb";
+import { mockEventSetMar22 } from "@core/__mocks__/v1/events/events.22mar";
 import { Schema_Event } from "@core/types/event.types";
-import { mockEventSetMar22 } from "../../../../core/src/__mocks__/v1/events/events.22mar";
-import { getReadAllFilter } from "./event.service.util";
+import {
+  cleanupTestDb,
+  setupTestDb,
+} from "@backend/__tests__/helpers/mock.db.setup";
+import mongoService from "@backend/common/services/mongo.service";
+import { getReadAllFilter } from "@backend/event/services/event.service.util";
 
 describe("Mar 6 - 12, 2022: All-Day Events", () => {
-  let connection: MongoClient;
-  let db: Db;
-  let eventCollection: Collection<Schema_Event>;
   let filter: Filter<Schema_Event>;
   let titles: string[];
 
   beforeAll(async () => {
-    // setup in-memory connection using jest-mongodb
-    connection = await MongoClient.connect(process.env["MONGO_URL"] as string);
-    db = await connection.db();
-    eventCollection = db.collection("event");
-    await eventCollection.insertMany(mockEventSetMar22);
+    await setupTestDb();
+
+    await mongoService.event.insertMany(mockEventSetMar22);
 
     filter = getReadAllFilter("user1", {
       start: "2022-03-06T00:00:00-07:00",
       end: "2022-03-12T23:59:59-07:00",
     });
-    const result = await eventCollection.find(filter).toArray();
+    const result = await mongoService.event.find(filter).toArray();
     titles = result.map((e) => e.title);
   });
 
-  afterAll(async () => {
-    await connection.close();
-  });
+  afterAll(cleanupTestDb);
 
   it("finds overlapping multi-week event", async () => {
     expect(titles.includes("Feb 14 - Mar 8")).toBe(true);

packages/backend/src/event/services/event.find.test.ts

@@ -1,14 +1,19 @@
-import { Collection, Db, MongoClient } from "mongodb";
+import { Collection } from "mongodb";
+import { mockEventSetJan22 } from "@core/__mocks__/v1/events/events.22jan";
+import { mockEventSetSomeday1 } from "@core/__mocks__/v1/events/events.someday.1";
 import { MapEvent } from "@core/mappers/map.event";
 import { Schema_Event } from "@core/types/event.types";
 import { isBase, isExistingInstance } from "@core/util/event/event.util";
+import {
+  cleanupTestDb,
+  setupTestDb,
+} from "@backend/__tests__/helpers/mock.db.setup";
 import {
   mockRecurringGcalBaseEvent,
   mockRecurringGcalInstances,
 } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
-import { mockEventSetJan22 } from "../../../../core/src/__mocks__/v1/events/events.22jan";
-import { mockEventSetSomeday1 } from "../../../../core/src/__mocks__/v1/events/events.someday.1";
-import { getReadAllFilter } from "./event.service.util";
+import mongoService from "@backend/common/services/mongo.service";
+import { getReadAllFilter } from "@backend/event/services/event.service.util";
 
 const gBase = mockRecurringGcalBaseEvent();
 const gInstances = mockRecurringGcalInstances(gBase, 10, 7);
@@ -23,22 +28,17 @@ instances.forEach((i) => {
 const recurring = [base, ...instances];
 const allEvents = [...mockEventSetJan22, ...mockEventSetSomeday1, ...recurring];
 describe("Jan 2022: Many Formats", () => {
-  let connection: MongoClient;
-  let db: Db;
   let eventCollection: Collection<Schema_Event>;
 
   beforeAll(async () => {
-    // setup in-memory connection using jest-mongodb
-    connection = await MongoClient.connect(process.env["MONGO_URL"] as string);
-    db = await connection.db();
-    eventCollection = db.collection("event.find.test");
+    await setupTestDb();
+
+    eventCollection = mongoService.db.collection("event.find.test");
 
     await eventCollection.insertMany(allEvents);
   });
 
-  afterAll(async () => {
-    await connection.close();
-  });
+  afterAll(cleanupTestDb);
 
   it("returns events by provided user only", async () => {
     const filter = getReadAllFilter("user1", {
@@ -49,11 +49,11 @@ describe("Jan 2022: Many Formats", () => {
     events.forEach((e) => expect(e.user).toBe("user1"));
   });
   it("does NOT transform query dates to ISO format", () => {
-    /* 
+    /*
     it shouldn't transform the format, because mongo
     will do that during its date comparison
 
-    this depends on the frontend passing the date values in the correct format 
+    this depends on the frontend passing the date values in the correct format
      */
     const start = "2011-10-20T00:00:00-10:00";
     const end = "2011-11-26T00:00:00-10:00";

packages/backend/src/servers/websocket/websocket.server.test.ts

@@ -1,3 +1,8 @@
+/**
+ * @jest-environment node
+ *
+ * we do not need the database for this test
+ */
 import { randomUUID } from "node:crypto";
 import { updateUserMetadata } from "supertokens-node/recipe/usermetadata";
 import {
@@ -17,7 +22,7 @@ describe("WebSocket Server", () => {
   const baseDriver = new BaseDriver();
 
   const userMetadata: UserMetadata = {
-    sync: { importGCal: { importing: false } },
+    sync: { importGCal: null },
   };
 
   beforeAll(async () => {

packages/backend/src/sync/controllers/sync.controller.test.ts

@@ -3,19 +3,19 @@ import { EVENT_CHANGED } from "@core/constants/websocket.constants";
 import { isBase, isExistingInstance } from "@core/util/event/event.util";
 import { BaseDriver } from "@backend/__tests__/drivers/base.driver";
 import { SyncControllerDriver } from "@backend/__tests__/drivers/sync.controller.driver";
+import { SyncDriver } from "@backend/__tests__/drivers/sync.driver";
+import { UserDriver } from "@backend/__tests__/drivers/user.driver";
 import { getCategorizedEventsInDb } from "@backend/__tests__/helpers/mock.db.queries";
 import {
   cleanupCollections,
-  cleanupTestMongo,
+  cleanupTestDb,
   setupTestDb,
 } from "@backend/__tests__/helpers/mock.db.setup";
+import { waitUntilEvent } from "@backend/common/helpers/common.util";
 import gcalService from "@backend/common/services/gcal/gcal.service";
 import mongoService from "@backend/common/services/mongo.service";
 import * as syncQueries from "@backend/sync/util/sync.queries";
-import { SyncDriver } from "../../__tests__/drivers/sync.driver";
-import { UserDriver } from "../../__tests__/drivers/user.driver";
-import { waitUntilEvent } from "../../common/helpers/common.util";
-import userService from "../../user/services/user.service";
+import userService from "@backend/user/services/user.service";
 
 describe("SyncController", () => {
   const baseDriver = new BaseDriver();
@@ -33,7 +33,7 @@ describe("SyncController", () => {
 
   afterAll(async () => {
     await baseDriver.teardown();
-    await cleanupTestMongo(setup);
+    await cleanupTestDb();
     jest.clearAllMocks();
   });
 
@@ -45,7 +45,7 @@ describe("SyncController", () => {
           sessionId: randomUUID(),
         });
 
-        await cleanupCollections(setup.db);
+        await cleanupCollections();
 
         const failReason = await syncDriver.waitUntilImportGCalEnd(
           websocketClient,
@@ -369,7 +369,7 @@ describe("SyncController", () => {
     });
 
     describe("Frontend Notifications", () => {
-      beforeEach(() => cleanupCollections(setup.db));
+      beforeEach(cleanupCollections);
 
       it("should notify the frontend that the import has started", async () => {
         const user = await UserDriver.createUser();

packages/backend/src/sync/services/import/sync.import.full.test.ts

@@ -2,11 +2,11 @@ import { isBase, isExistingInstance } from "@core/util/event/event.util";
 import { getCategorizedEventsInDb } from "@backend/__tests__/helpers/mock.db.queries";
 import {
   cleanupCollections,
-  cleanupTestMongo,
+  cleanupTestDb,
   setupTestDb,
 } from "@backend/__tests__/helpers/mock.db.setup";
 import mongoService from "@backend/common/services/mongo.service";
-import { createSyncImport } from "./sync.import";
+import { createSyncImport } from "@backend/sync/services/import/sync.import";
 
 describe("SyncImport: Full", () => {
   let syncImport: Awaited<ReturnType<typeof createSyncImport>>;
@@ -17,13 +17,9 @@ describe("SyncImport: Full", () => {
     syncImport = await createSyncImport(setup.userId);
   });
 
-  beforeEach(async () => {
-    await cleanupCollections(setup.db);
-  });
+  beforeEach(cleanupCollections);
 
-  afterAll(async () => {
-    await cleanupTestMongo(setup);
-  });
+  afterAll(cleanupTestDb);
 
   it("should import the first instance of a recurring event (and the base)", async () => {
     // Importing both the bae and first instance helps us find the series recurrence rule.

packages/backend/src/sync/services/import/sync.import.series.test.ts

@@ -5,7 +5,7 @@ import {
 } from "@core/util/event/event.util";
 import {
   cleanupCollections,
-  cleanupTestMongo,
+  cleanupTestDb,
   setupTestDb,
 } from "@backend/__tests__/helpers/mock.db.setup";
 import { mockRecurringGcalBaseEvent } from "@backend/__tests__/mocks.gcal/factories/gcal.event.factory";
@@ -21,13 +21,9 @@ describe("SyncImport: Series", () => {
     syncImport = await createSyncImport(setup.userId);
   });
 
-  beforeEach(async () => {
-    await cleanupCollections(setup.db);
-  });
+  beforeEach(cleanupCollections);
 
-  afterAll(async () => {
-    await cleanupTestMongo(setup);
-  });
+  afterAll(cleanupTestDb);
 
   it("should import a series when provided a gcal base event", async () => {
     /* Assemble */