Test suite parallelization fix

Author: Rajat

apps/queue/jest.config.ts

@@ -1,5 +1,4 @@
 const config = {
-    preset: "@shelf/jest-mongodb",
     setupFilesAfterEnv: ["<rootDir>/setupTests.ts"],
     watchPathIgnorePatterns: ["globalConfig"],
     moduleNameMapper: {

apps/queue/setupTests.ts

@@ -3,6 +3,13 @@ import { MongoMemoryServer } from "mongodb-memory-server";
 
 let mongod: MongoMemoryServer | null = null;
 
+jest.setTimeout(30000);
+
+function getMongoPort(basePort: number) {
+    const workerId = Number(process.env.JEST_WORKER_ID || "0");
+    return basePort + workerId;
+}
+
 // Suppress console.error during tests to reduce noise
 const originalError = console.error;
 beforeAll(() => {
@@ -17,14 +24,13 @@ afterAll(() => {
 // @shelf/jest-mongodb provides global.__MONGO_URI__ through globalSetup
 // If not available, set up MongoDB Memory Server manually
 beforeAll(async () => {
-    let mongoUri = (global as any).__MONGO_URI__ || process.env.MONGO_URL;
-
-    // If @shelf/jest-mongodb didn't set up MongoDB, do it manually
-    if (!mongoUri) {
-        mongod = await MongoMemoryServer.create();
-        mongoUri = mongod.getUri();
-        (global as any).__MONGO_URI__ = mongoUri;
-    }
+    mongod = await MongoMemoryServer.create({
+        instance: {
+            ip: "127.0.0.1",
+            port: getMongoPort(38017),
+        },
+    });
+    const mongoUri = mongod.getUri();
 
     if (mongoose.connection.readyState === 0) {
         await mongoose.connect(mongoUri);
@@ -33,13 +39,16 @@ beforeAll(async () => {
 
 afterAll(async () => {
     if (mongoose.connection.readyState !== 0) {
-        await mongoose.connection.close();
+        await mongoose.disconnect();
     }
 
     // Clean up manually created MongoDB instance if it exists
     if (mongod) {
-        await mongod.stop();
+        await mongod.stop({ doCleanup: true, force: true });
+        mongod = null;
     }
+
+    delete (global as any).__MONGO_URI__;
 });
 
 // Clean up database after each test

apps/queue/src/domain/__tests__/process-ongoing-sequences.test.ts

@@ -14,11 +14,12 @@ import UserModel from "../model/user";
 import EmailDelivery from "../model/email-delivery";
 import * as queries from "../queries";
 import * as mail from "../../mail";
-import { AdminSequence, InternalUser } from "@courselit/common-logic";
+import { InternalUser } from "@courselit/common-logic";
 import { getEmailFrom, jwtUtils } from "@courselit/utils";
 import { getUnsubLink } from "../../utils/get-unsub-link";
 import { getSiteUrl } from "../../utils/get-site-url";
 import { sequenceBounceLimit } from "../../constants";
+import { AdminSequence } from "@courselit/orm-models";
 
 // Mock dependencies
 jest.mock("../../mail");
@@ -288,6 +289,20 @@ describe("processOngoingSequence", () => {
             sequenceId: { $ne: TEST_SEQUENCE_ID }, // Keep main test sequence
         });
         jest.clearAllMocks();
+
+        mockedGetSiteUrl.mockReturnValue("https://test.com");
+        mockedGetUnsubLink.mockReturnValue(
+            "https://test.com/api/unsubscribe/unsub-token-123",
+        );
+        mockedGetEmailFrom.mockImplementation(
+            ({ name, email }) => `${name} <${email}>`,
+        );
+        mockedJwtUtils.generateToken = jest.fn().mockReturnValue("test-token");
+        mockedSendMail.mockResolvedValue(undefined);
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
     });
 
     afterAll(async () => {

apps/web/graphql/communities/logic.ts

@@ -311,6 +311,17 @@ export async function updateCommunity({
     if (slug) {
         const newSlug = validateSlug(slug);
         if (newSlug !== community.slug) {
+            const conflictingCommunity =
+                await CommunityModel.findOne<InternalCommunity>({
+                    domain: ctx.subdomain._id,
+                    slug: newSlug,
+                    communityId: { $ne: community.communityId },
+                }).select("_id");
+
+            if (conflictingCommunity) {
+                throw new Error(responses.page_id_already_exists);
+            }
+
             // Page-first atomicity: update Page record first (hard unique constraint)
             try {
                 await PageModel.updateOne(

apps/web/graphql/courses/__tests__/slug.test.ts

@@ -70,11 +70,19 @@ describe("Course Slug Tests", () => {
     });
 
     afterEach(async () => {
+        if (!domain?._id) {
+            return;
+        }
+
         await CourseModel.deleteMany({ domain: domain._id });
         await PageModel.deleteMany({ domain: domain._id });
     });
 
     afterAll(async () => {
+        if (!domain?._id) {
+            return;
+        }
+
         await CourseModel.deleteMany({ domain: domain._id });
         await PageModel.deleteMany({ domain: domain._id });
         await UserModel.deleteMany({ domain: domain._id });

apps/web/graphql/courses/logic.ts

@@ -209,6 +209,22 @@ export const updateCourse = async (
 ) => {
     let course = await getCourseOrThrow(undefined, ctx, courseData.id);
 
+    if (
+        typeof courseData.title === "string" &&
+        courseData.title.trim() &&
+        courseData.title !== course.title
+    ) {
+        const conflictingCourse = await CourseModel.findOne({
+            domain: ctx.subdomain._id,
+            title: courseData.title,
+            courseId: { $ne: course.courseId },
+        }).select("_id");
+
+        if (conflictingCourse) {
+            throw new Error(responses.page_id_already_exists);
+        }
+    }
+
     const mediaIdsMarkedForDeletion: string[] = [];
     if (Object.prototype.hasOwnProperty.call(courseData, "description")) {
         const nextDescription = (courseData.description ?? "") as string;
@@ -260,6 +276,16 @@ export const updateCourse = async (
     if (courseData.slug) {
         const newSlug = validateSlug(courseData.slug);
         if (newSlug !== course.slug) {
+            const conflictingCourse = await CourseModel.findOne({
+                domain: ctx.subdomain._id,
+                slug: newSlug,
+                courseId: { $ne: course.courseId },
+            }).select("_id");
+
+            if (conflictingCourse) {
+                throw new Error(responses.page_id_already_exists);
+            }
+
             try {
                 await PageModel.updateOne(
                     {

apps/web/jest.client.config.ts

@@ -25,8 +25,6 @@ const config = {
     //     '!**/jest.config.ts',
     //     '!**/setupTests.ts',
     // ],
-    globalSetup: "<rootDir>/jest.setup.ts",
-    globalTeardown: "<rootDir>/jest.teardown.ts",
     moduleNameMapper: {
         // Ensure a single React instance is used in tests to avoid
         // "A React Element from an older version of React was rendered" errors

apps/web/jest.server.config.ts

@@ -1,9 +1,9 @@
 import type { Config } from "jest";
 
 const config: Config = {
-    preset: "@shelf/jest-mongodb",
     setupFilesAfterEnv: ["<rootDir>/setupTests.server.ts"],
     watchPathIgnorePatterns: ["globalConfig"],
+    testEnvironment: "node",
     moduleNameMapper: {
         "@courselit/utils": "<rootDir>/../../packages/utils/src",
         "@courselit/common-logic": "<rootDir>/../../packages/common-logic/src",

apps/web/setupTests.server.ts

@@ -1,4 +1,14 @@
 import mongoose from "mongoose";
+import { MongoMemoryServer } from "mongodb-memory-server";
+
+let mongod: MongoMemoryServer | null = null;
+
+jest.setTimeout(30000);
+
+function getMongoPort(basePort: number) {
+    const workerId = Number(process.env.JEST_WORKER_ID || "0");
+    return basePort + workerId;
+}
 
 // Suppress console.error during tests to reduce noise
 const originalError = console.error;
@@ -12,13 +22,28 @@ afterAll(() => {
 
 // Ensure MongoDB connection is established
 beforeAll(async () => {
+    mongod = await MongoMemoryServer.create({
+        instance: {
+            ip: "127.0.0.1",
+            port: getMongoPort(37017),
+        },
+    });
+    const mongoUri = mongod.getUri();
+
     if (mongoose.connection.readyState === 0) {
-        await mongoose.connect(global.__MONGO_URI__ || process.env.MONGO_URL);
+        await mongoose.connect(mongoUri);
     }
 });
 
 afterAll(async () => {
     if (mongoose.connection.readyState !== 0) {
-        await mongoose.connection.close();
+        await mongoose.disconnect();
     }
+
+    if (mongod) {
+        await mongod.stop({ doCleanup: true, force: true });
+        mongod = null;
+    }
+
+    delete (global as any).__MONGO_URI__;
 });

packages/email-editor/src/lib/email-renderer.tsx

@@ -12,6 +12,22 @@ export interface UtmParams {
     campaign: string;
 }
 
+function stringifyUnknownError(err: unknown): string {
+    if (err instanceof Error) {
+        return err.message;
+    }
+
+    if (typeof err === "string") {
+        return err;
+    }
+
+    try {
+        return JSON.stringify(err);
+    } catch {
+        return String(err);
+    }
+}
+
 function appendUtmParams(url: string, utm: UtmParams): string {
     try {
         const urlObj = new URL(url);
@@ -138,9 +154,16 @@ export async function renderEmailToHtml({
                 blockRegistry={blockRegistry}
             />
         );
-        const html = await pretty(await render(template));
-        return html;
+        const renderedHtml = await render(template);
+
+        try {
+            return await pretty(renderedHtml);
+        } catch {
+            // Pretty-printing is optional. If formatting fails in a given
+            // runtime, return the valid rendered markup instead of an error page.
+            return renderedHtml;
+        }
     } catch (err) {
-        return `<h1>Error: ${err instanceof Error ? err.message : "Unknown error"}</h1>`;
+        return `<h1>Error: ${stringifyUnknownError(err)}</h1>`;
     }
 }