diff --git a/README.md b/README.md
index 59b88506..3d9b022c 100644
--- a/README.md
+++ b/README.md
@@ -53,9 +53,13 @@ DATABASE_KEY=[Insert Supabase Project API key]
 OPENAI_API_KEY=[Insert OpenAI API Key]
 PINECONE_API_KEY=[Insert Pinecone API Key]
 PINECONE_INDEX_NAME="course-matrix"
+
+BREVO_API_KEY=[Insert Brevo API Key]
+SENDER_EMAIL="kevinlan416@gmail.com"
+SENDER_NAME="Course Matrix Notifications"
 ```
 
-The `DATABASE_URL` variable should contain your Supabase project url and the `DATABASE_KEY` should contain your Supabase project’s API key. To learn how to create a new Supabase project: see [here](https://medium.com/@heshramsis/building-a-crud-app-with-supabase-and-express-a-step-by-step-guide-for-junior-developers-81456b850910). Likewise, the `OPENAI_API_KEY` variable should contain your OpenAI Project API Key and the `PINECONE_API_KEY` should contain your Pinecone Project API Key. Note that for the purposes of this project, **we will provide the grader with all necessary API keys and URLs**.
+The `DATABASE_URL` variable should contain your Supabase project url and the `DATABASE_KEY` should contain your Supabase project’s API key. To learn how to create a new Supabase project: see [here](https://medium.com/@heshramsis/building-a-crud-app-with-supabase-and-express-a-step-by-step-guide-for-junior-developers-81456b850910). Likewise, the `OPENAI_API_KEY` variable should contain your OpenAI Project API Key, the `PINECONE_API_KEY` should contain your Pinecone Project API Key, and the `BREVO_API_KEY` should contain your Brevo API Key. Note that for the purposes of this project, **we will provide the grader with all necessary API keys and URLs**.
 
 4. Configure environment variables for frontend. Create a `.env` file in `/frontend` and populate it with the following:
 
diff --git a/course-matrix/backend/__tests__/integration-tests/timetableGenerate.test.ts b/course-matrix/backend/__tests__/integration-tests/timetableGenerate.test.ts
new file mode 100644
index 00000000..a0df019e
--- /dev/null
+++ b/course-matrix/backend/__tests__/integration-tests/timetableGenerate.test.ts
@@ -0,0 +1,407 @@
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  jest,
+  test,
+} from "@jest/globals";
+import { Json } from "@pinecone-database/pinecone/dist/pinecone-generated-ts-fetch/db_control";
+import { NextFunction, Request, Response } from "express";
+import request from "supertest";
+
+import restrictionsController from "../../src/controllers/restrictionsController";
+import timetablesController from "../../src/controllers/timetablesController";
+import { supabase } from "../../src/db/setupDb";
+import app from "../../src/index";
+import { server } from "../../src/index";
+import { authHandler } from "../../src/middleware/authHandler";
+import getOfferings from "../../src/services/getOfferings";
+
+const USER1 = "testuser01-ab9e6877-f603-4c6a-9832-864e520e4d01";
+const USER2 = "testuser02-1d3f02df-f926-4c1f-9f41-58ca50816a33";
+const USER3 = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+const USER4 = "testuser04-f84fd0da-d775-4424-ad88-d9675282453c";
+// USER5 is saved for courseOffering query do not use for anyother test
+const USER5 = "testuser04-f84fd0da-d775-4424-ad88-d9675282453c";
+
+// Handle AI import from index.ts
+jest.mock("@ai-sdk/openai", () => ({
+  createOpenAI: jest.fn(() => ({
+    chat: jest.fn(),
+  })),
+}));
+
+jest.mock("ai", () => ({
+  streamText: jest.fn(() =>
+    Promise.resolve({ pipeDataStreamToResponse: jest.fn() }),
+  ),
+}));
+
+jest.mock("@pinecone-database/pinecone", () => ({
+  Pinecone: jest.fn(() => ({
+    Index: jest.fn(() => ({
+      query: jest.fn(),
+      upsert: jest.fn(),
+      delete: jest.fn(),
+    })),
+  })),
+}));
+
+jest.mock("node-cron", () => ({
+  schedule: jest.fn(), // Mock the `schedule` function
+}));
+
+afterAll(async () => {
+  server.close();
+});
+
+// Function to create authenticated session dynamically based as provided
+// user_id
+const mockAuthHandler = (user_id: string) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    (req as any).user = { id: user_id }; // Inject user_id dynamically
+    next();
+  };
+};
+
+// Mock authHandler globally
+jest.mock("../../src/middleware/authHandler", () => ({
+  authHandler: jest.fn() as jest.MockedFunction<typeof authHandler>,
+}));
+
+// Mock timetables dataset
+const mockTimetables1 = [
+  {
+    id: 1,
+    name: "Timetable 1",
+    user_id: USER1,
+  },
+  {
+    id: 2,
+    name: "Timetable 2",
+    user_id: USER1,
+  },
+];
+
+// Mock list of offering
+const offering1 = [
+  {
+    id: 1,
+    course_id: 101,
+    meeting_section: "LEC01",
+    day: "MO",
+    start: "10:00:00",
+    end: "11:00:00",
+  },
+  {
+    id: 2,
+    course_id: 101,
+    meeting_section: "LEC02",
+    day: "WE",
+    start: "10:00:00",
+    end: "11:00:00",
+  },
+  {
+    id: 3,
+    course_id: 101,
+    meeting_section: "LEC03",
+    day: "FR",
+    start: "10:00:00",
+    end: "11:00:00",
+  },
+];
+
+const offering2 = [
+  {
+    id: 1,
+    course_id: 102,
+    day: "MO",
+    start: "10:00:00",
+    end: "12:00:00",
+  },
+];
+
+const offering3 = [
+  {
+    id: 1,
+    course_id: 103,
+    day: "TU",
+    start: "15:00:00",
+    end: "17:00:00",
+  },
+  {
+    id: 2,
+    course_id: 103,
+    day: "WE",
+    start: "15:00:00",
+    end: "17:00:00",
+  },
+];
+
+// Spy on the getTimetables method
+jest
+  .spyOn(timetablesController, "getTimetables")
+  .mockImplementation(timetablesController.getTimetables);
+
+// Spy on the createTimetable method
+jest
+  .spyOn(timetablesController, "createTimetable")
+  .mockImplementation(timetablesController.createTimetable);
+
+// Spy on the updateTimetable method
+jest
+  .spyOn(timetablesController, "updateTimetable")
+  .mockImplementation(timetablesController.updateTimetable);
+
+// Spy on the deleteTimetable method
+jest
+  .spyOn(timetablesController, "deleteTimetable")
+  .mockImplementation(timetablesController.deleteTimetable);
+
+// Mock data set response to qeury
+jest.mock("../../src/db/setupDb", () => ({
+  supabase: {
+    // Mock return from schema, from and select to chain the next query
+    // command
+    schema: jest.fn().mockReturnThis(),
+    from: jest.fn().mockReturnThis(),
+    select: jest.fn().mockReturnThis(),
+    // Mock db response to .eq query command
+    eq: jest.fn().mockImplementation((key, value) => {
+      // Each test case is codded by the user_id in session
+      // DB response 1: Query user timetable return non null value
+      if (key === "user_id" && value === USER1) {
+        // Return mock data when user_id matches
+        return { data: mockTimetables1, error: null };
+      }
+      // DB response 2: Query user timetable return null value
+      if (key === "user_id" && value === USER2) {
+        // Return null for this user_id
+        return { data: null, error: null };
+      }
+
+      // DB response 3: Combine .eq and .maybeSingle to signify that the
+      // return value could be single: Return non null value
+      if (key === "user_id" && value === USER3) {
+        return {
+          eq: jest.fn().mockReturnThis(), // Allow further chaining of eq
+          // if required
+          maybeSingle: jest.fn().mockImplementation(() => {
+            return { data: null, error: null };
+          }),
+        };
+      }
+      // DB response 4: Combine .eq and .maybeSingle to signify that the
+      // return value could be single: Return null value
+      if (key === "user_id" && value === USER4) {
+        return {
+          eq: jest.fn().mockReturnThis(), // Allow further chaining of eq
+          // if required
+          neq: jest.fn().mockImplementation(() => ({
+            maybeSingle: jest
+              .fn()
+              .mockImplementation(() => ({ data: null, error: null })),
+          })),
+          maybeSingle: jest.fn().mockImplementation(() => {
+            return { data: mockTimetables1, error: null };
+          }),
+        };
+      }
+      // DB response with offering1 if courseID = 101 in request
+      if (key === "course_id" && value === 101) {
+        return {
+          eq: jest.fn().mockImplementation(() => {
+            return { data: offering1, error: null };
+          }),
+        };
+      }
+      // DB response with offering1 if courseID = 102 in request
+      if (key === "course_id" && value === 102) {
+        return {
+          eq: jest.fn().mockImplementation(() => {
+            return { data: offering2, error: null };
+          }),
+        };
+      }
+      // DB response with offering1 if courseID = 103 in request
+      if (key === "course_id" && value === 103) {
+        return {
+          eq: jest.fn().mockImplementation(() => {
+            return { data: offering1, error: null };
+          }),
+        };
+      }
+    }),
+    // Mock db response to .insert query command
+    insert: jest.fn().mockImplementation((data: Json) => {
+      // DB response 5: Create timetable successfully, new timetable data is
+      // responded
+      if (data && data[0].user_id === USER3) {
+        return {
+          select: jest.fn().mockImplementation(() => {
+            // Return the input data when select is called
+            return {
+              data: data,
+              error: null,
+            }; // Return the data passed to insert
+          }),
+        };
+      }
+      // DB response 6: Create timetable uncessfully, return error.message
+      return {
+        select: jest.fn().mockImplementation(() => {
+          return { data: null, error: { message: "Fail to create timetable" } };
+        }),
+      };
+    }),
+
+    // Mock db response to .update query command
+    update: jest.fn().mockImplementation((updatedata: Json) => {
+      // DB response 7: Timetable updated successfully, db return updated
+      // data in response
+      if (updatedata && updatedata.timetable_title === "Updated Title") {
+        return {
+          eq: jest.fn().mockReturnThis(),
+          select: jest.fn().mockReturnThis(),
+          single: jest.fn().mockImplementation((data) => {
+            return { data: updatedata, error: null };
+          }),
+        };
+      }
+      // DB response 8: Update timetable uncessfully, return error.message
+      return { data: null, error: { message: "Fail to update timetable" } };
+    }),
+
+    // Mock db response to .delete query command
+    delete: jest.fn().mockImplementation(() => {
+      // DB response 9: Delete timetable successfully
+      return {
+        eq: jest.fn().mockReturnThis(),
+        data: null,
+        error: null,
+      };
+    }),
+  },
+}));
+
+// Test block
+describe("Simple test case for offering", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return offering1", async () => {
+    const response = await getOfferings(101, "Spring");
+    expect(response).toEqual(offering1);
+  });
+});
+
+// Test block
+describe("Testing timetable generation", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("Generate for 1 course", async () => {
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER5));
+    const response = await request(app)
+      .post("/api/timetables/generate")
+      .send({ courses: [{ id: 101 }], semester: "Spring", restrictions: [] })
+      .expect(200);
+    expect(JSON.parse(response.text).amount).toEqual(3); // 3 timetables should be generated.
+  });
+
+  test("Generate for 2 courses, no conflict", async () => {
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER5));
+    const response = await request(app)
+      .post("/api/timetables/generate")
+      .send({
+        courses: [{ id: 101 }, { id: 103 }],
+        semester: "Spring",
+        restrictions: [],
+      })
+      .expect(200);
+    expect(JSON.parse(response.text).amount).toEqual(6); // 6 timetables should be generated.
+  });
+
+  test("Generate for 2 courses, conflict", async () => {
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER5));
+    const response = await request(app)
+      .post("/api/timetables/generate")
+      .send({
+        courses: [{ id: 101 }, { id: 102 }],
+        semester: "Spring",
+        restrictions: [],
+      })
+      .expect(200);
+    expect(JSON.parse(response.text).amount).toEqual(2);
+  });
+
+  test("Generate for 1 course, bad restriction", async () => {
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER5));
+    const response = await request(app)
+      .post("/api/timetables/generate")
+      .send({
+        courses: [{ id: 101 }],
+        semester: "Spring",
+        restrictions: [
+          {
+            type: "Restrict Before",
+            days: ["MO", "TU", "WE", "TH", "FR"],
+            endTime: "21:00:00",
+            disabled: false,
+          },
+        ],
+      })
+      .expect(404);
+  });
+
+  test("Generate for 1 course w/ restrictions, only wednesday should be allowed", async () => {
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER5));
+    const response = await request(app)
+      .post("/api/timetables/generate")
+      .send({
+        courses: [{ id: 101 }],
+        semester: "Spring",
+        restrictions: [
+          {
+            type: "Restrict Before",
+            days: ["MO", "TU", "TH", "FR"],
+            endTime: "21:00:00",
+            disabled: false,
+          },
+        ],
+      })
+      .expect(200);
+    expect(JSON.parse(response.text).amount).toEqual(1);
+    expect(JSON.parse(response.text).schedules).toEqual([
+      [
+        {
+          id: 2,
+          course_id: 101,
+          meeting_section: "LEC02",
+          day: "WE",
+          start: "10:00:00",
+          end: "11:00:00",
+        },
+      ],
+    ]);
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/analyzeQuery.test.ts b/course-matrix/backend/__tests__/unit-tests/analyzeQuery.test.ts
new file mode 100644
index 00000000..0cf4af40
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/analyzeQuery.test.ts
@@ -0,0 +1,119 @@
+import { analyzeQuery } from "../../src/utils/analyzeQuery";
+import { describe, test, expect, jest } from "@jest/globals";
+import {
+  NAMESPACE_KEYWORDS,
+  ASSISTANT_TERMS,
+  DEPARTMENT_CODES,
+} from "../../src/constants/promptKeywords";
+
+// Mock the constants if needed
+jest.mock("../../src/constants/promptKeywords", () => ({
+  NAMESPACE_KEYWORDS: {
+    courses_v3: ["course", "class", "description"],
+    offerings: ["offering", "schedule", "timetable"],
+    prerequisites: ["prerequisite", "prereq"],
+    corequisites: ["corequisite", "coreq"],
+    departments: ["department", "faculty"],
+    programs: ["program", "major", "minor"],
+  },
+  ASSISTANT_TERMS: ["you", "your", "morpheus", "assistant"],
+  DEPARTMENT_CODES: ["cs", "math", "eng"],
+  GENERAL_ACADEMIC_TERMS: ["academic", "study", "education"],
+}));
+
+describe("analyzeQuery", () => {
+  test("should return no search required for assistant-related queries", () => {
+    const result = analyzeQuery("Can you help me with something?");
+    expect(result).toEqual({
+      requiresSearch: false,
+      relevantNamespaces: [],
+    });
+  });
+
+  test("should detect course-related keywords and return appropriate namespaces", () => {
+    const result = analyzeQuery("Tell me about this course");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("courses_v3");
+  });
+
+  test("should detect course codes and include relevant namespaces", () => {
+    const result = analyzeQuery("What is CSC108 about?");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("courses_v3");
+    expect(result.relevantNamespaces).toContain("offerings");
+    expect(result.relevantNamespaces).toContain("prerequisites");
+  });
+
+  test("should detect department codes and include relevant namespaces", () => {
+    const result = analyzeQuery("What math courses are available?");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("departments");
+    expect(result.relevantNamespaces).toContain("courses_v3");
+  });
+
+  test("should detect offering-related keywords", () => {
+    const result = analyzeQuery("What is the schedule for winter semester?");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("offerings");
+  });
+
+  test("should detect prerequisite-related keywords", () => {
+    const result = analyzeQuery("What are the prerequisites for this class?");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("prerequisites");
+  });
+
+  test("should detect corequisite-related keywords", () => {
+    const result = analyzeQuery("Are there any corequisites for this course?");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("corequisites");
+  });
+
+  test("should return all namespaces when search is required but no specific namespaces identified", () => {
+    // Assuming GENERAL_ACADEMIC_TERMS includes 'academic'
+    const result = analyzeQuery("I need academic information");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toEqual([
+      "courses_v3",
+      "offerings",
+      "prerequisites",
+      "corequisites",
+      "departments",
+      "programs",
+    ]);
+  });
+
+  test("should be case insensitive", () => {
+    const result = analyzeQuery("TELL ME ABOUT THIS COURSE");
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("courses_v3");
+  });
+
+  test("should detect multiple namespaces in a single query", () => {
+    const result = analyzeQuery(
+      "What are the prerequisites and schedule for CSC108?",
+    );
+    expect(result.requiresSearch).toBe(true);
+    expect(result.relevantNamespaces).toContain("prerequisites");
+    expect(result.relevantNamespaces).toContain("offerings");
+    expect(result.relevantNamespaces).toContain("courses_v3");
+  });
+
+  test("should correctly identify course codes with different formats", () => {
+    const formats = [
+      "CSC108", // Standard format
+      "CSC108H", // With suffix
+      "CSCA08", // Four letters
+      "MAT224", // Different department
+      "ECO100Y", // Another format
+    ];
+
+    formats.forEach((code) => {
+      const result = analyzeQuery(`Tell me about ${code}`);
+      expect(result.requiresSearch).toBe(true);
+      expect(result.relevantNamespaces).toContain("courses_v3");
+      expect(result.relevantNamespaces).toContain("offerings");
+      expect(result.relevantNamespaces).toContain("prerequisites");
+    });
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/auth.test.ts b/course-matrix/backend/__tests__/unit-tests/auth.test.ts
new file mode 100644
index 00000000..f3c4e049
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/auth.test.ts
@@ -0,0 +1,307 @@
+import { afterAll, describe, expect, it, jest } from "@jest/globals";
+import { Request, Response } from "express";
+import request from "supertest";
+
+import app, { server } from "../../src/index";
+
+jest.mock("@ai-sdk/openai", () => ({
+  createOpenAI: jest.fn(() => ({
+    chat: jest.fn(),
+  })),
+}));
+
+jest.mock("ai", () => ({
+  streamText: jest.fn(() =>
+    Promise.resolve({ pipeDataStreamToResponse: jest.fn() }),
+  ),
+}));
+
+jest.mock("@pinecone-database/pinecone", () => ({
+  Pinecone: jest.fn(() => ({
+    Index: jest.fn(() => ({
+      query: jest.fn(),
+      upsert: jest.fn(),
+      delete: jest.fn(),
+    })),
+  })),
+}));
+
+jest.mock("node-cron", () => ({
+  schedule: jest.fn(), // Mock the `schedule` function
+}));
+
+jest.mock("../../src/db/setupDb", () => ({
+  supabase: {
+    from: jest.fn(() => ({
+      select: jest.fn(),
+      insert: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    })),
+  },
+}));
+
+jest.mock("../../src/controllers/userController", () => ({
+  signUp: jest.fn((req: Request, res: Response) => {
+    const { email, password, username } = req.body;
+    if (!email || !password || !username) {
+      return res
+        .status(400)
+        .json({ error: "Email, password, and username are required" });
+    }
+    if (email === "existingUser@example.com") {
+      return res.status(400).json({ error: "Email is already taken" });
+    }
+    res.status(201).json({
+      message: "User registered successfully",
+      user: { email, username },
+    });
+  }),
+  login: jest.fn((req: Request, res: Response) => {
+    const { email, password } = req.body;
+    if (!email || !password) {
+      return res.status(400).json({ error: "Email and password are required" });
+    }
+    if (email === "validUser" && password === "validPassword") {
+      res.status(200).json({ token: "mockedToken" });
+    } else {
+      res.status(401).json({ error: "Invalid credentials" });
+    }
+  }),
+  logout: jest.fn((req: Request, res: Response) => {
+    const token = req.headers.authorization?.split(" ")[1];
+    if (!token) {
+      return res.status(401).json({ error: "Unauthorized" });
+    }
+    res.status(200).json({ message: "Logged out successfully" });
+  }),
+  session: jest.fn((req: Request, res: Response) => {
+    const token = req.headers.authorization?.split(" ")[1];
+    if (!token || token !== "mockedToken") {
+      return res.status(401).json({ error: "Unauthorized" });
+    }
+    res
+      .status(200)
+      .json({ message: "Session valid", user: { email: "validUser" } });
+  }),
+  requestPasswordReset: jest.fn((req: Request, res: Response) => {
+    const { email } = req.body;
+    if (!email) {
+      return res.status(400).json({ error: "Email is required" });
+    }
+    res.status(200).json({ message: "Password reset link sent" });
+  }),
+  resetPassword: jest.fn((req: Request, res: Response) => {
+    const { password, token } = req.body;
+    if (!password || !token) {
+      return res.status(400).json({ error: "Password and token are required" });
+    }
+    res.status(200).json({ message: "Password reset successfully" });
+  }),
+  accountDelete: jest.fn((req: Request, res: Response) => {
+    const { userId } = req.body;
+    if (!userId) {
+      return res.status(400).json({ error: "User ID is required" });
+    }
+    res.status(200).json({ message: "Account deletion requested" });
+  }),
+  updateUsername: jest.fn((req: Request, res: Response) => {
+    const { userId, newUsername } = req.body;
+    if (!userId || !newUsername) {
+      return res
+        .status(400)
+        .json({ error: "User ID and new username are required" });
+    }
+    res.status(200).json({ message: "Username updated successfully" });
+  }),
+  usernameFromUserId: jest.fn((req: Request, res: Response) => {
+    const { userId } = req.query;
+    if (!userId) {
+      return res.status(400).json({ error: "User ID is required" });
+    }
+    res.status(200).json({ username: "mockedUsername" });
+  }),
+}));
+
+afterAll(async () => {
+  server.close();
+});
+
+describe("Authentication API", () => {
+  describe("POST /auth/signup", () => {
+    it("should return 201 and a success message for valid signup data", async () => {
+      const response = await request(app).post("/auth/signup").send({
+        email: "newUser@example.com",
+        password: "securePassword123",
+        username: "newUser",
+      });
+      expect(response.status).toBe(201);
+      expect(response.body).toHaveProperty(
+        "message",
+        "User registered successfully",
+      );
+      expect(response.body.user).toHaveProperty("email", "newUser@example.com");
+      expect(response.body.user).toHaveProperty("username", "newUser");
+    });
+
+    it("should return 400 if email is already taken", async () => {
+      const response = await request(app).post("/auth/signup").send({
+        email: "existingUser@example.com",
+        password: "securePassword123",
+        username: "existingUser",
+      });
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty("error", "Email is already taken");
+    });
+
+    it("should return 400 if required fields are missing", async () => {
+      const response = await request(app).post("/auth/signup").send({
+        email: "incompleteUser@example.com",
+      });
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty(
+        "error",
+        "Email, password, and username are required",
+      );
+    });
+  });
+
+  describe("POST /auth/login", () => {
+    it("should return 200 and a token for valid credentials", async () => {
+      const response = await request(app).post("/auth/login").send({
+        email: "validUser",
+        password: "validPassword",
+      });
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("token");
+    });
+    it("should return 401 for invalid credentials", async () => {
+      const response = await request(app).post("/auth/login").send({
+        email: "invalidUser",
+        password: "wrongPassword",
+      });
+      expect(response.status).toBe(401);
+      expect(response.body).toHaveProperty("error", "Invalid credentials");
+    });
+    it("should return 400 if email or password is missing", async () => {
+      const response = await request(app)
+        .post("/auth/login")
+        .send({ email: "validUser" });
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty(
+        "error",
+        "Email and password are required",
+      );
+    });
+  });
+
+  describe("POST /auth/logout", () => {
+    it("should return 200 for successful logout", async () => {
+      const response = await request(app)
+        .post("/auth/logout")
+        .set("Authorization", "Bearer mockedToken");
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty(
+        "message",
+        "Logged out successfully",
+      );
+    });
+    it("should return 401 if token is missing", async () => {
+      const response = await request(app).post("/auth/logout");
+      expect(response.status).toBe(401);
+      expect(response.body).toHaveProperty("error", "Unauthorized");
+    });
+  });
+
+  describe("GET /auth/session", () => {
+    it("should return 200 and session info for valid token", async () => {
+      const response = await request(app)
+        .get("/auth/session")
+        .set("Authorization", "Bearer mockedToken");
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty("message", "Session valid");
+      expect(response.body.user).toHaveProperty("email", "validUser");
+    });
+    it("should return 401 if token is missing or invalid", async () => {
+      const response = await request(app)
+        .get("/auth/session")
+        .set("Authorization", "Bearer invalidToken");
+      expect(response.status).toBe(401);
+      expect(response.body).toHaveProperty("error", "Unauthorized");
+    });
+    it("should return 401 if token is missing", async () => {
+      const response = await request(app).get("/auth/session");
+      expect(response.status).toBe(401);
+      expect(response.body).toHaveProperty("error", "Unauthorized");
+    });
+  });
+
+  describe("POST /auth/request-password-reset", () => {
+    it("should return 200 and a success message when email is provided", async () => {
+      const response = await request(app)
+        .post("/auth/request-password-reset")
+        .send({
+          email: "user@example.com",
+        });
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty(
+        "message",
+        "Password reset link sent",
+      );
+    });
+
+    it("should return 400 if email is missing", async () => {
+      const response = await request(app)
+        .post("/auth/request-password-reset")
+        .send({});
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty("error", "Email is required");
+    });
+  });
+
+  describe("POST /auth/reset-password", () => {
+    it("should return 200 and a success message when password and token are provided", async () => {
+      const response = await request(app).post("/auth/reset-password").send({
+        password: "newPassword123",
+        token: "validToken",
+      });
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty(
+        "message",
+        "Password reset successfully",
+      );
+    });
+
+    it("should return 400 if password or token is missing", async () => {
+      const response = await request(app).post("/auth/reset-password").send({
+        password: "newPassword123",
+      });
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty(
+        "error",
+        "Password and token are required",
+      );
+    });
+  });
+
+  describe("DELETE /auth/accountDelete", () => {
+    it("should return 200 and a success message when userId is provided", async () => {
+      const response = await request(app).delete("/auth/accountDelete").send({
+        userId: "12345",
+      });
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty(
+        "message",
+        "Account deletion requested",
+      );
+    });
+
+    it("should return 400 if userId is missing", async () => {
+      const response = await request(app)
+        .delete("/auth/accountDelete")
+        .send({});
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty("error", "User ID is required");
+    });
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/canInsert.test.ts b/course-matrix/backend/__tests__/unit-tests/canInsert.test.ts
new file mode 100644
index 00000000..67607123
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/canInsert.test.ts
@@ -0,0 +1,170 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import { Offering } from "../../src/types/generatorTypes";
+import {
+  canInsert,
+  canInsertList,
+  createOffering,
+} from "../../src/utils/generatorHelpers";
+
+describe("canInsert function", () => {
+  const offering1: Offering = createOffering({
+    id: 1,
+    course_id: 101,
+    day: "MO",
+    start: "09:00:00",
+    end: "10:00:00",
+  });
+  const offering2: Offering = createOffering({
+    id: 2,
+    course_id: 102,
+    day: "MO",
+    start: "10:00:00",
+    end: "11:00:00",
+  });
+  const offering3: Offering = createOffering({
+    id: 3,
+    course_id: 103,
+    day: "MO",
+    start: "11:00:00",
+    end: "12:00:00",
+  });
+
+  it("should return true if there is no overlap with existing offerings", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "12:00:00",
+      end: "13:00:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(true); // No overlap, should return true
+  });
+
+  it("should return false if there is an overlap with an existing offering", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "09:30:00",
+      end: "10:30:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(false); // There is an overlap with offering1, should return false
+  });
+
+  it("should return true if the new offering starts after the last one ends", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "13:00:00",
+      end: "14:00:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(true); // No overlap, should return true
+  });
+
+  it("should return true if the new offering ends before the first one starts", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "07:00:00",
+      end: "08:00:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(true); // No overlap, should return true
+  });
+
+  it("should return false if the new offering is completely inside an existing one", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "09:30:00",
+      end: "09:45:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(false); // Overlaps with offering1, should return false
+  });
+
+  it("should return true if the day is different (no overlap)", async () => {
+    const toInsert: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "TU",
+      start: "09:00:00",
+      end: "10:00:00",
+    });
+    const curList: Offering[] = [offering1, offering2, offering3];
+
+    const result = await canInsert(toInsert, curList);
+
+    expect(result).toBe(true); // Different day, no overlap
+  });
+
+  it("special case", async () => {
+    const toInsert: Offering = createOffering({
+      id: 1069,
+      course_id: 1271,
+      day: "TH",
+      start: "05:00:00",
+      end: "17:00:00",
+    });
+    const offering11: Offering = createOffering({
+      id: 414,
+      course_id: 337,
+      day: "TU",
+      start: "15:00:00",
+      end: "16:00:00",
+    });
+    const offering12: Offering = createOffering({
+      id: 415,
+      course_id: 337,
+      day: "TH",
+      start: "15:00:00",
+      end: "17:00:00",
+    });
+    const offering13: Offering = createOffering({
+      id: 1052,
+      course_id: 1271,
+      day: "TU",
+      start: "10:00:00",
+      end: "11:00:00",
+    });
+    const offering14: Offering = createOffering({
+      id: 1053,
+      course_id: 1271,
+      day: "TU",
+      start: "09:00:00",
+      end: "11:00:00",
+    });
+    const curList: Offering[] = [
+      offering11,
+      offering12,
+      offering13,
+      offering14,
+    ];
+
+    const result = await canInsertList([toInsert], curList);
+
+    expect(result).toBe(false); // Special bug-causing case
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/correctDay.test.ts b/course-matrix/backend/__tests__/unit-tests/correctDay.test.ts
new file mode 100644
index 00000000..f4165869
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/correctDay.test.ts
@@ -0,0 +1,255 @@
+import { describe, expect, jest, test } from "@jest/globals";
+import { isDateBetween } from "../../src/utils/compareDates";
+
+// For testing purposes, we need to modify the function to accept a custom "now" date
+// This allows us to test all scenarios regardless of the current date
+function correctDay(offering: any, customNow?: Date): boolean {
+  const weekdays = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+  const semester = offering?.offering;
+  const day = offering?.day;
+  if (!semester || !day) return false;
+  const now = customNow || new Date();
+  let startDay;
+  let endDay;
+  if (semester === "Summer 2025") {
+    startDay = new Date(2025, 5, 2);
+    endDay = new Date(2025, 8, 7);
+  } else if (semester === "Fall 2025") {
+    startDay = new Date(2025, 9, 3);
+    endDay = new Date(2025, 12, 3);
+  } else {
+    // Winter 2026
+    startDay = new Date(2026, 1, 6);
+    endDay = new Date(2026, 4, 4);
+  }
+  if (!isDateBetween(now, startDay, endDay)) {
+    return false;
+  }
+  if (weekdays[now.getDay()] !== day) {
+    return false;
+  }
+  return true;
+}
+
+describe("correctDay function", () => {
+  test("should return false for null or undefined offering", () => {
+    expect(correctDay(null)).toBe(false);
+    expect(correctDay(undefined)).toBe(false);
+  });
+
+  test("should return false for missing offering properties", () => {
+    expect(correctDay({})).toBe(false);
+    expect(correctDay({ offering: "Summer 2025" })).toBe(false);
+    expect(correctDay({ day: "MO" })).toBe(false);
+  });
+
+  test("should validate correct day in Summer 2025", () => {
+    // Create specific dates for each day of the week within Summer 2025
+    const summerDates = [
+      new Date(2025, 5, 8), // Sunday (June 8, 2025)
+      new Date(2025, 5, 9), // Monday (June 9, 2025)
+      new Date(2025, 5, 10), // Tuesday (June 10, 2025)
+      new Date(2025, 5, 11), // Wednesday (June 11, 2025)
+      new Date(2025, 5, 12), // Thursday (June 12, 2025)
+      new Date(2025, 5, 13), // Friday (June 13, 2025)
+      new Date(2025, 5, 14), // Saturday (June 14, 2025)
+    ];
+
+    // Test each day with its corresponding date
+    const weekdays = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"];
+    summerDates.forEach((date, index) => {
+      // Make sure the getDay returns the expected index
+      jest.spyOn(date, "getDay").mockReturnValue(index);
+
+      // This should pass only for the matching day
+      expect(
+        correctDay({ offering: "Summer 2025", day: weekdays[index] }, date),
+      ).toBe(true);
+
+      // Test all other days should fail
+      weekdays.forEach((wrongDay, wrongIndex) => {
+        if (wrongIndex !== index) {
+          expect(
+            correctDay({ offering: "Summer 2025", day: wrongDay }, date),
+          ).toBe(false);
+        }
+      });
+    });
+  });
+
+  test("should validate correct day in Fall 2025", () => {
+    // Create a date in Fall 2025
+    const fallDate = new Date(2025, 9, 15); // October 15, 2025
+
+    // Mock getDay to return 3 (Wednesday)
+    jest.spyOn(fallDate, "getDay").mockReturnValue(3);
+
+    // Test all days - only Wednesday should pass
+    expect(correctDay({ offering: "Fall 2025", day: "WE" }, fallDate)).toBe(
+      true,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, fallDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "MO" }, fallDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "TU" }, fallDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "TH" }, fallDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "FR" }, fallDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "SA" }, fallDate)).toBe(
+      false,
+    );
+  });
+
+  test("should validate correct day in Winter 2026", () => {
+    // Create a date in Winter 2026
+    const winterDate = new Date(2026, 1, 20); // February 20, 2026
+
+    // Mock getDay to return 5 (Friday)
+    jest.spyOn(winterDate, "getDay").mockReturnValue(5);
+
+    // Test all days - only Friday should pass
+    expect(correctDay({ offering: "Winter 2026", day: "FR" }, winterDate)).toBe(
+      true,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "SU" }, winterDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "MO" }, winterDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "TU" }, winterDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "WE" }, winterDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "TH" }, winterDate)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Winter 2026", day: "SA" }, winterDate)).toBe(
+      false,
+    );
+  });
+
+  test("should return false when date is outside semester range", () => {
+    // Create dates outside each semester range
+    const beforeSummer = new Date(2025, 5, 1); // June 1, 2025 (before Summer 2025)
+    const afterSummer = new Date(2025, 8, 8); // September 8, 2025 (after Summer 2025)
+    const beforeFall = new Date(2025, 9, 2); // October 2, 2025 (before Fall 2025)
+    const afterFall = new Date(2025, 12, 4); // December 4, 2025 (after Fall 2025)
+    const beforeWinter = new Date(2026, 1, 5); // February 5, 2026 (before Winter 2026)
+    const afterWinter = new Date(2026, 4, 5); // May 5, 2026 (after Winter 2026)
+
+    // Mock getDay to return 0 (Sunday) for all dates
+    const testDates = [
+      beforeSummer,
+      afterSummer,
+      beforeFall,
+      afterFall,
+      beforeWinter,
+      afterWinter,
+    ];
+    testDates.forEach((date) => {
+      jest.spyOn(date, "getDay").mockReturnValue(0);
+    });
+
+    // Test dates outside Summer 2025
+    expect(
+      correctDay({ offering: "Summer 2025", day: "SU" }, beforeSummer),
+    ).toBe(false);
+    expect(
+      correctDay({ offering: "Summer 2025", day: "SU" }, afterSummer),
+    ).toBe(false);
+
+    // Test dates outside Fall 2025
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, beforeFall)).toBe(
+      false,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, afterFall)).toBe(
+      false,
+    );
+
+    // Test dates outside Winter 2026
+    expect(
+      correctDay({ offering: "Winter 2026", day: "SU" }, beforeWinter),
+    ).toBe(false);
+    expect(
+      correctDay({ offering: "Winter 2026", day: "SU" }, afterWinter),
+    ).toBe(false);
+  });
+
+  test("should return true for dates inside semester range", () => {
+    // Create dates inside each semester range
+    const duringSummer = new Date(2025, 6, 15); // July 15, 2025 (during Summer 2025)
+    const duringFall = new Date(2025, 10, 15); // November 15, 2025 (during Fall 2025)
+    const duringWinter = new Date(2026, 2, 15); // March 15, 2026 (during Winter 2026)
+
+    // Mock getDay to return 0 (Sunday) for all dates
+    const testDates = [duringSummer, duringFall, duringWinter];
+    testDates.forEach((date) => {
+      jest.spyOn(date, "getDay").mockReturnValue(0);
+    });
+
+    // Test dates inside each semester (with matching day)
+    expect(
+      correctDay({ offering: "Summer 2025", day: "SU" }, duringSummer),
+    ).toBe(true);
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, duringFall)).toBe(
+      true,
+    );
+    expect(
+      correctDay({ offering: "Winter 2026", day: "SU" }, duringWinter),
+    ).toBe(true);
+  });
+
+  test("should validate edge dates correctly", () => {
+    // Test exact start and end dates of semesters
+    const summerStart = new Date(2025, 5, 2); // June 2, 2025
+    const summerEnd = new Date(2025, 8, 7); // September 7, 2025
+    const fallStart = new Date(2025, 9, 3); // October 3, 2025
+    const fallEnd = new Date(2025, 12, 3); // December 3, 2025
+    const winterStart = new Date(2026, 1, 6); // February 6, 2026
+    const winterEnd = new Date(2026, 4, 4); // May 4, 2026
+
+    // Mock getDay to return 0 (Sunday) for all dates
+    const edgeDates = [
+      summerStart,
+      summerEnd,
+      fallStart,
+      fallEnd,
+      winterStart,
+      winterEnd,
+    ];
+    edgeDates.forEach((date) => {
+      jest.spyOn(date, "getDay").mockReturnValue(0);
+    });
+
+    // Edge dates should be included in the valid range
+    expect(
+      correctDay({ offering: "Summer 2025", day: "SU" }, summerStart),
+    ).toBe(true);
+    expect(correctDay({ offering: "Summer 2025", day: "SU" }, summerEnd)).toBe(
+      true,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, fallStart)).toBe(
+      true,
+    );
+    expect(correctDay({ offering: "Fall 2025", day: "SU" }, fallEnd)).toBe(
+      true,
+    );
+    expect(
+      correctDay({ offering: "Winter 2026", day: "SU" }, winterStart),
+    ).toBe(true);
+    expect(correctDay({ offering: "Winter 2026", day: "SU" }, winterEnd)).toBe(
+      true,
+    );
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/getFrequencyTable.test.ts b/course-matrix/backend/__tests__/unit-tests/getFrequencyTable.test.ts
new file mode 100644
index 00000000..c3a7e97e
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/getFrequencyTable.test.ts
@@ -0,0 +1,83 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import {
+  createOffering,
+  getFrequencyTable,
+} from "../../src/utils/generatorHelpers";
+import { Offering } from "../../src/types/generatorTypes";
+
+describe("getFrequencyTable", () => {
+  test("should return a frequency map of days", () => {
+    const offering1: Offering = createOffering({
+      id: 1,
+      course_id: 101,
+      day: "MO",
+      start: "09:00:00",
+      end: "10:00:00",
+    });
+    const offering2: Offering = createOffering({
+      id: 2,
+      course_id: 102,
+      day: "TU",
+      start: "10:00:00",
+      end: "11:00:00",
+    });
+    const offering3: Offering = createOffering({
+      id: 3,
+      course_id: 103,
+      day: "TU",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering4: Offering = createOffering({
+      id: 4,
+      course_id: 104,
+      day: "MO",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering5: Offering = createOffering({
+      id: 5,
+      course_id: 105,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering6: Offering = createOffering({
+      id: 6,
+      course_id: 106,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const offering7: Offering = createOffering({
+      id: 7,
+      course_id: 107,
+      day: "WE",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+
+    const result = getFrequencyTable([
+      offering1,
+      offering2,
+      offering3,
+      offering4,
+      offering5,
+      offering6,
+      offering7,
+    ]);
+
+    expect(result.get("MO")).toBe(2);
+    expect(result.get("TU")).toBe(2);
+    expect(result.get("WE")).toBe(3);
+    expect(result.get("TH")).toBeUndefined(); // Day not in data
+    expect(result.get("FR")).toBeUndefined(); // Day not in data
+    expect(result.size).toBe(3);
+  });
+
+  test("should return an empty map for an empty array", () => {
+    const result = getFrequencyTable([]);
+    expect(result.size).toBe(0);
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/getMinHourDay.test.ts b/course-matrix/backend/__tests__/unit-tests/getMinHourDay.test.ts
new file mode 100644
index 00000000..2f33e89f
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/getMinHourDay.test.ts
@@ -0,0 +1,193 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import { Offering } from "../../src/types/generatorTypes";
+import {
+  createOffering,
+  getMinHour,
+  getMinHourDay,
+} from "../../src/utils/generatorHelpers";
+
+describe("getMinHourDay function", () => {
+  it("Back to back to back courses", async () => {
+    const offering1: Offering = createOffering({
+      id: 1,
+      course_id: 101,
+      day: "MO",
+      start: "09:00:00",
+      end: "10:00:00",
+    });
+    const offering2: Offering = createOffering({
+      id: 2,
+      course_id: 102,
+      day: "MO",
+      start: "10:00:00",
+      end: "11:00:00",
+    });
+    const offering3: Offering = createOffering({
+      id: 3,
+      course_id: 103,
+      day: "MO",
+      start: "11:00:00",
+      end: "12:00:00",
+    });
+    const schedule: Offering[] = [offering1, offering2, offering3];
+
+    const result = getMinHourDay(schedule, 0);
+
+    expect(result).toBe(true);
+  });
+
+  it("courses that has a max gap of 4 hours", async () => {
+    const offering1: Offering = createOffering({
+      id: 1,
+      course_id: 101,
+      day: "MO",
+      start: "09:00:00",
+      end: "10:00:00",
+    });
+    const offering2: Offering = createOffering({
+      id: 2,
+      course_id: 102,
+      day: "MO",
+      start: "10:00:00",
+      end: "11:00:00",
+    });
+    const offering3: Offering = createOffering({
+      id: 3,
+      course_id: 103,
+      day: "MO",
+      start: "15:00:00",
+      end: "16:00:00",
+    });
+    const schedule: Offering[] = [offering3, offering2, offering1];
+
+    const result = getMinHourDay(schedule, 3);
+
+    expect(result).toBe(false);
+  });
+
+  it("only 1 offering in list, return 0", async () => {
+    const offering1: Offering = createOffering({
+      id: 1,
+      course_id: 101,
+      day: "MO",
+      start: "09:00:00",
+      end: "10:00:00",
+    });
+    const schedule: Offering[] = [offering1];
+
+    const result = getMinHourDay(schedule, 23);
+
+    expect(result).toBe(true);
+  });
+
+  it("getMinHour test", async () => {
+    const arr_day = [
+      "MO",
+      "MO",
+      "TU",
+      "TH",
+      "FR",
+      "MO",
+      "TU",
+      "TH",
+      "MO",
+      "MO",
+    ];
+    const arr_start = [
+      "09:00:00",
+      "10:00:00",
+      "09:00:00",
+      "12:00:00",
+      "13:00:00",
+      "12:00:00",
+      "14:00:00",
+      "16:00:00",
+      "13:00:00",
+      "15:00:00",
+    ];
+    const arr_end = [
+      "10:00:00",
+      "11:00:00",
+      "10:00:00",
+      "15:00:00",
+      "16:00:00",
+      "13:00:00",
+      "19:00:00",
+      "18:00:00",
+      "14:00:00",
+      "18:00:00",
+    ];
+    const schedule: Offering[] = [];
+    for (let i = 0; i < 10; i++) {
+      schedule.push(
+        createOffering({
+          id: i,
+          course_id: 100 + i,
+          day: arr_day[i],
+          start: arr_start[i],
+          end: arr_end[i],
+        }),
+      );
+    }
+
+    const result = getMinHour(schedule, 4);
+
+    expect(result).toEqual(true);
+  });
+
+  it("getMinHour test 2", async () => {
+    const arr_day = [
+      "MO",
+      "MO",
+      "TU",
+      "TH",
+      "FR",
+      "MO",
+      "TU",
+      "TH",
+      "MO",
+      "MO",
+    ];
+    const arr_start = [
+      "09:00:00",
+      "10:00:00",
+      "09:00:00",
+      "12:00:00",
+      "13:00:00",
+      "12:00:00",
+      "14:00:00",
+      "16:00:00",
+      "13:00:00",
+      "15:00:00",
+    ];
+    const arr_end = [
+      "10:00:00",
+      "11:00:00",
+      "10:00:00",
+      "15:00:00",
+      "16:00:00",
+      "13:00:00",
+      "19:00:00",
+      "18:00:00",
+      "14:00:00",
+      "18:00:00",
+    ];
+    const schedule: Offering[] = [];
+    for (let i = 0; i < 10; i++) {
+      schedule.push(
+        createOffering({
+          id: i,
+          course_id: 100 + i,
+          day: arr_day[i],
+          start: arr_start[i],
+          end: arr_end[i],
+        }),
+      );
+    }
+
+    const result = getMinHour(schedule, 3);
+
+    expect(result).toEqual(false);
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/getOfferings.test.ts b/course-matrix/backend/__tests__/unit-tests/getOfferings.test.ts
new file mode 100644
index 00000000..226011ee
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/getOfferings.test.ts
@@ -0,0 +1,60 @@
+import { describe, expect, it, jest, test } from "@jest/globals";
+
+import { supabase } from "../../src/db/setupDb";
+import getOfferings from "../../src/services/getOfferings";
+
+jest.mock("../../src/db/setupDb", () => ({
+  supabase: {
+    schema: jest.fn(),
+  },
+}));
+
+type SupabaseQueryResult = Promise<{ data: any; error: any }>;
+
+describe("getOfferings", () => {
+  it("returns offering data for a valid course and semester", async () => {
+    const mockData = [
+      {
+        id: 1,
+        course_id: 123,
+        meeting_section: "L01",
+        offering: "Fall 2025",
+        day: "Mon",
+        start: "10:00",
+        end: "11:00",
+        location: "Room 101",
+        current: 30,
+        max: 40,
+        is_waitlisted: false,
+        delivery_mode: "In-Person",
+        instructor: "Dr. Smith",
+        notes: "",
+        code: "ABC123",
+      },
+    ];
+
+    // Build the method chain mock
+    const eqMock2 = jest.fn<() => SupabaseQueryResult>().mockResolvedValue({
+      data: mockData,
+      error: null,
+    });
+    const eqMock1 = jest.fn(() => ({ eq: eqMock2 }));
+    const selectMock = jest.fn(() => ({ eq: eqMock1 }));
+    const fromMock = jest.fn(() => ({ select: selectMock }));
+    const schemaMock = jest.fn(() => ({ from: fromMock }));
+
+    // Replace supabase.schema with our chain
+    (supabase.schema as jest.Mock).mockImplementation(schemaMock);
+
+    // Act
+    const result = await getOfferings(123, "Fall 2025");
+
+    // Assert
+    expect(schemaMock).toHaveBeenCalledWith("course");
+    expect(fromMock).toHaveBeenCalledWith("offerings");
+    expect(selectMock).toHaveBeenCalled();
+    expect(eqMock1).toHaveBeenCalledWith("course_id", 123);
+    expect(eqMock2).toHaveBeenCalledWith("offering", "Fall 2025");
+    expect(result).toEqual(mockData);
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/includeFilters.test.ts b/course-matrix/backend/__tests__/unit-tests/includeFilters.test.ts
new file mode 100644
index 00000000..8eb0094a
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/includeFilters.test.ts
@@ -0,0 +1,124 @@
+import {
+  BREADTH_REQUIREMENT_KEYWORDS,
+  YEAR_LEVEL_KEYWORDS,
+} from "../../src/constants/promptKeywords";
+import { includeFilters } from "../../src/utils/includeFilters";
+import { describe, test, expect, jest, beforeEach } from "@jest/globals";
+import * as ModuleType from "../../src/utils/convert-breadth-requirement";
+import * as ModuleType0 from "../../src/utils/convert-year-level";
+
+// Create mock functions
+const mockConvertBreadthRequirement = jest.fn(
+  (namespace) => `converted_${namespace}`,
+);
+const mockConvertYearLevel = jest.fn((namespace) => `converted_${namespace}`);
+
+// Mock the modules
+jest.mock("../../src/utils/convert-breadth-requirement", () => ({
+  convertBreadthRequirement: (namespace: string) =>
+    mockConvertBreadthRequirement(namespace),
+}));
+
+jest.mock("../../src/utils/convert-year-level", () => ({
+  convertYearLevel: (namespace: string) => mockConvertYearLevel(namespace),
+}));
+
+describe("includeFilters", () => {
+  beforeEach(() => {
+    // Clear mock data before each test
+    mockConvertBreadthRequirement.mockClear();
+    mockConvertYearLevel.mockClear();
+  });
+
+  test("should return empty object when no filters match", () => {
+    const query = "something random";
+    const result = includeFilters(query);
+    expect(result).toEqual({});
+  });
+
+  test("should match breadth requirement keywords case-insensitively", () => {
+    const query = "I want to study ART Literature";
+    const result = includeFilters(query);
+    expect(result).toEqual({
+      $or: [{ breadth_requirement: { $eq: "converted_ART_LIT_LANG" } }],
+    });
+  });
+
+  test("should match year level keywords case-insensitively", () => {
+    const query = "Looking for A-level courses";
+    const result = includeFilters(query);
+    expect(result).toEqual({
+      $or: [{ year_level: { $eq: "converted_first_year" } }],
+    });
+  });
+
+  test("should combine both breadth and year level filters with $and when both are present", () => {
+    const query = "Natural Science First-Year courses";
+    const result = includeFilters(query);
+    expect(result).toEqual({
+      $and: [
+        {
+          $or: [{ breadth_requirement: { $eq: "converted_NAT_SCI" } }],
+        },
+        {
+          $or: [{ year_level: { $eq: "converted_first_year" } }],
+        },
+      ],
+    });
+  });
+
+  test("should handle multiple breadth requirements", () => {
+    const query = "social science or quantitative reasoning";
+    const result = includeFilters(query);
+    expect(result).toEqual({
+      $or: [
+        { breadth_requirement: { $eq: "converted_SOCIAL_SCI" } },
+        { breadth_requirement: { $eq: "converted_QUANT" } },
+      ],
+    });
+  });
+
+  test("should handle multiple year levels", () => {
+    const query = "third year or fourth-year courses";
+    const result = includeFilters(query);
+    expect(result).toEqual({
+      $or: [
+        { year_level: { $eq: "converted_third_year" } },
+        { year_level: { $eq: "converted_fourth_year" } },
+      ],
+    });
+  });
+
+  test("should handle multiple breadth requirements and year levels", () => {
+    const query = "history philosophy B-level or C-level";
+    const result = includeFilters(query);
+    console.log(result);
+    expect(result).toEqual({
+      $and: [
+        {
+          $or: [{ breadth_requirement: { $eq: "converted_HIS_PHIL_CUL" } }],
+        },
+        {
+          $or: [
+            { year_level: { $eq: "converted_second_year" } },
+            { year_level: { $eq: "converted_third_year" } },
+          ],
+        },
+      ],
+    });
+  });
+
+  test("should ignore partial keyword matches", () => {
+    // "art" alone shouldn't match "art literature language"
+    const query = "art courses";
+    const result = includeFilters(query);
+    // This should not match any specific filter since "art" alone isn't in the keywords
+    expect(result).toEqual({});
+  });
+
+  test("should handle edge case with empty query", () => {
+    const query = "";
+    const result = includeFilters(query);
+    expect(result).toEqual({});
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/isValidOffering.test.ts b/course-matrix/backend/__tests__/unit-tests/isValidOffering.test.ts
new file mode 100644
index 00000000..5173a2e9
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/isValidOffering.test.ts
@@ -0,0 +1,115 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import {
+  Offering,
+  Restriction,
+  RestrictionType,
+} from "../../src/types/generatorTypes";
+import {
+  createOffering,
+  isValidOffering,
+} from "../../src/utils/generatorHelpers";
+
+describe("isValidOffering", () => {
+  const sampleOffering: Offering = createOffering({
+    id: 1,
+    course_id: 101,
+    day: "MO",
+    start: "10:00:00",
+    end: "11:00:00",
+  });
+
+  test("should allow offering if there are no restrictions", () => {
+    expect(isValidOffering(sampleOffering, [])).toBe(true);
+  });
+
+  test("should allow offering if all restrictions are disabled", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBefore,
+        days: ["MO"],
+        startTime: "",
+        endTime: "09:00:00",
+        disabled: true,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(true);
+  });
+
+  test("should reject offering if it starts before restriction start time", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBefore,
+        days: ["MO"],
+        startTime: "",
+        endTime: "11:00:00",
+        disabled: false,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if it ends after restriction end time", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictAfter,
+        days: ["MO"],
+        startTime: "10:30:00",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if it is within restricted time range", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictBetween,
+        days: ["MO"],
+        startTime: "09:00:00",
+        endTime: "12:00:00",
+        disabled: false,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should reject offering if the day is restricted", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictDay,
+        days: ["MO"],
+        startTime: "",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(false);
+  });
+
+  test("should allow offering if the day is not restricted", () => {
+    const restrictions: Restriction[] = [
+      {
+        type: RestrictionType.RestrictDay,
+        days: ["TU"],
+        startTime: "",
+        endTime: "",
+        disabled: false,
+        numDays: 0,
+        maxGap: 24,
+      },
+    ];
+    expect(isValidOffering(sampleOffering, restrictions)).toBe(true);
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/restrictionsController.test.ts b/course-matrix/backend/__tests__/unit-tests/restrictionsController.test.ts
new file mode 100644
index 00000000..c275ef49
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/restrictionsController.test.ts
@@ -0,0 +1,547 @@
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import {
+  instanceOfErrorResponse,
+  Json,
+} from "@pinecone-database/pinecone/dist/pinecone-generated-ts-fetch/db_control";
+import { NextFunction, Request, Response } from "express";
+import request from "supertest";
+
+import restrictionsController from "../../src/controllers/restrictionsController";
+import { supabase } from "../../src/db/setupDb";
+import app from "../../src/index";
+import { server } from "../../src/index";
+import { authHandler } from "../../src/middleware/authHandler";
+import { errorConverter } from "../../src/middleware/errorHandler";
+
+// Handle AI import from index.ts
+jest.mock("@ai-sdk/openai", () => ({
+  createOpenAI: jest.fn(() => ({
+    chat: jest.fn(),
+  })),
+}));
+
+jest.mock("ai", () => ({
+  streamText: jest.fn(() =>
+    Promise.resolve({ pipeDataStreamToResponse: jest.fn() }),
+  ),
+}));
+
+jest.mock("@pinecone-database/pinecone", () => ({
+  Pinecone: jest.fn(() => ({
+    Index: jest.fn(() => ({
+      query: jest.fn(),
+      upsert: jest.fn(),
+      delete: jest.fn(),
+    })),
+  })),
+}));
+
+jest.mock("node-cron", () => ({
+  schedule: jest.fn(), // Mock the `schedule` function
+}));
+
+afterAll(async () => {
+  server.close();
+});
+
+// Function to create authenticated session dynamically based as provided
+// user_id
+const mockAuthHandler = (user_id: string) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    (req as any).user = { id: user_id }; // Inject user_id dynamically
+    next();
+  };
+};
+
+// Mock authHandler globally
+jest.mock("../../src/middleware/authHandler", () => ({
+  authHandler: jest.fn() as jest.MockedFunction<typeof authHandler>,
+}));
+
+const USER1 = "testuser04-f84fd0da-d775-4424-ad88-d9675282453c";
+const USER2 = "testuser05-f84fd0da-d775-4424-ad88-d9675282453c";
+
+// Mock timetables dataset
+const mockRestriction = {
+  id: 1,
+  restriction_type: "Restrict Between",
+  user_id: USER1,
+  start_time: "13:30:00",
+  end_time: "14:30:00",
+  days: ["MO", "TUE"],
+  disabled: false,
+};
+
+const mockRestriction2 = {
+  id: 1,
+  calendar_id: 1,
+  restriction_type: "Restrict Between",
+  user_id: USER2,
+  start_time: "13:30:00",
+  end_time: "14:30:00",
+  days: ["MO", "TUE"],
+  disabled: false,
+};
+
+const mockTimetables1 = {
+  id: 1,
+  user_id: USER1,
+};
+
+const mockTimetables2 = {
+  id: 1,
+  user_id: USER2,
+};
+
+// Spy on the createRestriction method
+jest
+  .spyOn(restrictionsController, "createRestriction")
+  .mockImplementation(restrictionsController.createRestriction);
+
+// Spy on the createTimetable method
+jest
+  .spyOn(restrictionsController, "getRestriction")
+  .mockImplementation(restrictionsController.getRestriction);
+
+// Spy on the updateTimetable method
+jest
+  .spyOn(restrictionsController, "updateRestriction")
+  .mockImplementation(restrictionsController.updateRestriction);
+
+// Spy on the deleteTimetable method
+jest
+  .spyOn(restrictionsController, "deleteRestriction")
+  .mockImplementation(restrictionsController.deleteRestriction);
+
+// Mock data set response to qeury
+jest.mock("../../src/db/setupDb", () => ({
+  supabase: {
+    // Mock return from schema, from and select to chain the next query
+    // command
+    schema: jest.fn().mockReturnThis(),
+    from: jest.fn().mockImplementation((key, value) => {
+      if (key === "timetables") {
+        return {
+          select: jest.fn().mockReturnThis(),
+          eq: jest.fn().mockImplementation((key, value) => {
+            // Each test case is codded by the user_id in session
+            // DB response 3: Combine .eq and .maybeSingle to signify that
+            // the return value could be single: Return non null value
+            if (
+              key === "user_id" &&
+              value === "testuser03-f84fd0da-d775-4424-ad88-d9675282453c"
+            ) {
+              return {
+                eq: jest.fn().mockReturnThis(),
+                maybeSingle: jest.fn().mockImplementation(() => {
+                  return { data: null, error: null };
+                }),
+              };
+            }
+            // DB response 4: Combine .eq and .maybeSingle to signify that
+            // the return value could be single: Return null value
+            if (key === "user_id" && value === USER1) {
+              return {
+                eq: jest.fn().mockReturnThis(), // Allow further chaining
+                // of eq if required
+                maybeSingle: jest.fn().mockImplementation(() => {
+                  return { data: mockTimetables1, error: null };
+                }),
+              };
+            }
+
+            if (key === "user_id" && value === USER2) {
+              return {
+                eq: jest.fn().mockReturnThis(), // Allow further chaining
+                // of eq if required
+                maybeSingle: jest.fn().mockImplementation(() => {
+                  return { data: mockTimetables2, error: null };
+                }),
+              };
+            }
+          }),
+        };
+      }
+      return {
+        select: jest.fn().mockReturnThis(),
+        eq: jest.fn().mockImplementation((key, value) => {
+          if (
+            key === "user_id" &&
+            value === "testuser03-f84fd0da-d775-4424-ad88-d9675282453c"
+          ) {
+            return {
+              eq: jest.fn().mockImplementation((key, value) => {
+                if (key === "calendar_id" && value === "1") {
+                  return {
+                    eq: jest.fn().mockReturnThis(),
+                    maybeSingle: jest.fn().mockImplementation(() => {
+                      return {
+                        data: null,
+                        error: null,
+                      };
+                    }),
+                  };
+                }
+              }),
+            };
+          }
+          if (key === "user_id" && value === USER1) {
+            return {
+              eq: jest.fn().mockImplementation((key, value) => {
+                if (key === "calendar_id" && value === "1") {
+                  return { data: mockRestriction, error: null };
+                }
+              }),
+            };
+          }
+          if (key === "user_id" && value === USER2) {
+            return {
+              eq: jest.fn().mockImplementation((key, value) => {
+                if (key === "calendar_id" && value === "1") {
+                  return {
+                    eq: jest.fn().mockReturnThis(),
+                    maybeSingle: jest.fn().mockImplementation(() => {
+                      return { data: mockRestriction2, error: null };
+                    }),
+                  };
+                }
+              }),
+            };
+          }
+          return { data: null, error: null };
+        }),
+        insert: jest.fn().mockImplementation((data: Json) => {
+          // DB response 5: Create timetable successfully, new timetable
+          // data is responded
+          if (data && data[0].user_id === USER1) {
+            return {
+              select: jest.fn().mockImplementation(() => {
+                // Return the input data when select is called
+                return {
+                  data: data,
+                  error: null,
+                }; // Return the data passed to insert
+              }),
+            };
+          }
+          // DB response 6: Create timetable uncessfully, return
+          // error.message
+          return {
+            select: jest.fn().mockImplementation(() => {
+              return {
+                data: null,
+                error: { message: "Fail to create timetable" },
+              };
+            }),
+          };
+        }),
+        update: jest.fn().mockImplementation((updatedata: Json) => {
+          // DB response 7: Timetable updated successfully, db return
+          // updated data in response
+          if (updatedata && updatedata.start_time === "09:00:00.000Z") {
+            return {
+              eq: jest.fn().mockReturnThis(),
+              select: jest.fn().mockImplementation(() => {
+                return { data: updatedata, error: null };
+              }),
+            };
+          }
+          // DB response 8: Update timetable uncessfully, return
+          // error.message
+          return { data: null, error: { message: "Fail to update timetable" } };
+        }),
+        delete: jest.fn().mockImplementation(() => {
+          // DB response 9: Delete timetable successfully
+          return {
+            eq: jest.fn().mockImplementation((key, value) => {
+              if (key === "user_id" && value === USER2) {
+                return {
+                  eq: jest.fn().mockReturnThis(),
+                  data: null,
+                  error: null,
+                };
+              }
+              return {
+                data: null,
+                error: { message: "Uncessful restriction delete" },
+              };
+            }),
+          };
+        }),
+      };
+    }),
+    select: jest.fn().mockReturnThis(),
+    // Mock db response to .eq query command
+    eq: jest.fn().mockReturnThis(),
+    // Mock db response to .insert query command
+    insert: jest.fn().mockReturnThis(),
+
+    // Mock db response to .update query command
+    update: jest.fn().mockImplementation((updatedata: Json) => {}),
+    // Mock db response to .delete query command
+    delete: jest.fn().mockReturnThis(),
+  },
+}));
+
+// Test block 1: Get endpoint
+describe("GET /api/timetables/restrictions/:id", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return timetables", async () => {
+    // Initialize the authenticated session
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER1));
+
+    const response = await request(app).get("/api/timetables/restrictions/1");
+
+    // Check database interaction and response
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual(mockRestriction);
+  });
+
+  test("should return 404 if no timetables found", async () => {
+    // Initialize the authenticated session
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(
+      mockAuthHandler("testuser03-f84fd0da-d775-4424-ad88-d9675282453c"),
+    );
+
+    const response = await request(app).get("/api/timetables/restrictions/1");
+    // Verify the response status and error message
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Calendar id not found",
+    });
+  });
+});
+
+// Test block 2: POST endpoint
+describe("POST /api/timetables/restrictions", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return error code 400 and error message: 'calendar id is required'", async () => {
+    const user_id = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+    const newTimetable = {};
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables/restrictions")
+      .send(newTimetable);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(400);
+    expect(response.body).toEqual({
+      error: "calendar id is required",
+    });
+  });
+
+  test("should return error code 400 and error message: 'Start time or end time must be provided'", async () => {
+    const user_id = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+    const newTimetable = {
+      calendar_id: "1",
+    };
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables/restrictions")
+      .send(newTimetable);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(400);
+    expect(response.body).toEqual({
+      error: "Start time or end time must be provided",
+    });
+  });
+
+  test("should create a new timetable given calendar_id, start_time and end_time", async () => {
+    const user_id = USER1;
+    const newRestriction = {
+      calendar_id: "1",
+      start_time: "2025-03-04T09:00:00.000Z",
+      end_time: "2025-03-04T10:00:00.000Z",
+    };
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables/restrictions")
+      .send(newRestriction);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(201);
+    expect(response.body).toEqual([
+      {
+        user_id,
+        calendar_id: "1",
+        start_time: "09:00:00.000Z",
+        end_time: "10:00:00.000Z",
+      },
+    ]);
+  });
+
+  test("should return error code 404 and error message: Calendar id not found", async () => {
+    const user_id = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+    const newRestriction = {
+      calendar_id: "1",
+      start_time: "2025-03-04T09:00:00.000Z",
+      end_time: "2025-03-04T10:00:00.000Z",
+    };
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables/restrictions")
+      .send(newRestriction);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Calendar id not found",
+    });
+  });
+});
+
+// Test block 3: Put endpoint
+describe("PUT /api/timetables/restrictions/:id", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  test("should return error code 400 and message: calendar id is required ", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER2;
+    const timetableData = {
+      start_time: "2025-03-04T09:00:00.000Z",
+    };
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .put("/api/timetables/restrictions/1")
+      .send(timetableData);
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(400);
+    expect(response.body).toEqual({
+      error: "calendar id is required",
+    });
+  });
+
+  test("should update the timetable successfully", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER2;
+    const timetableData = {
+      start_time: "2025-03-04T09:00:00.000Z",
+    };
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .put("/api/timetables/restrictions/1?calendar_id=1")
+      .send(timetableData);
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual({
+      start_time: "09:00:00.000Z",
+    });
+  });
+
+  test("should return error code 404 and message: Restriction id does not exist", async () => {
+    // Make sure the test user is authenticated
+    const user_id = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+    const timetableData = {
+      start_time: "2025-03-04T09:00:00.000Z",
+    };
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .put("/api/timetables/restrictions/1?calendar_id=1")
+      .send(timetableData);
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Restriction id does not exist",
+    });
+  });
+});
+
+// Test block 4: Delete endpoint
+describe("DELETE /api/timetables/:id", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should delete the timetable successfully", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER2;
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app).delete(
+      "/api/timetables/restrictions/1?calendar_id=1",
+    );
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual({
+      message: "Restriction successfully deleted",
+    });
+  });
+
+  test("should return error code 404 and message: Calendar id not found and id not found", async () => {
+    // Make sure the test user is authenticated
+    const user_id = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app).delete(
+      "/api/timetables/restrictions/1?calendar_id=1",
+    );
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Restriction id does not exist",
+    });
+  });
+});
diff --git a/course-matrix/backend/__tests__/unit-tests/timetablesController.test.ts b/course-matrix/backend/__tests__/unit-tests/timetablesController.test.ts
new file mode 100644
index 00000000..7121a6ba
--- /dev/null
+++ b/course-matrix/backend/__tests__/unit-tests/timetablesController.test.ts
@@ -0,0 +1,413 @@
+import {
+  afterAll,
+  beforeEach,
+  describe,
+  expect,
+  jest,
+  test,
+} from "@jest/globals";
+import { Json } from "@pinecone-database/pinecone/dist/pinecone-generated-ts-fetch/db_control";
+import { NextFunction, Request, Response } from "express";
+import request from "supertest";
+
+import timetablesController from "../../src/controllers/timetablesController";
+import { supabase } from "../../src/db/setupDb";
+import app from "../../src/index";
+import { server } from "../../src/index";
+import { authHandler } from "../../src/middleware/authHandler";
+
+const USER1 = "testuser01-ab9e6877-f603-4c6a-9832-864e520e4d01";
+const USER2 = "testuser02-1d3f02df-f926-4c1f-9f41-58ca50816a33";
+const USER3 = "testuser03-f84fd0da-d775-4424-ad88-d9675282453c";
+const USER4 = "testuser04-f84fd0da-d775-4424-ad88-d9675282453c";
+
+// Handle AI import from index.ts
+jest.mock("@ai-sdk/openai", () => ({
+  createOpenAI: jest.fn(() => ({
+    chat: jest.fn(),
+  })),
+}));
+
+jest.mock("ai", () => ({
+  streamText: jest.fn(() =>
+    Promise.resolve({ pipeDataStreamToResponse: jest.fn() }),
+  ),
+}));
+
+jest.mock("@pinecone-database/pinecone", () => ({
+  Pinecone: jest.fn(() => ({
+    Index: jest.fn(() => ({
+      query: jest.fn(),
+      upsert: jest.fn(),
+      delete: jest.fn(),
+    })),
+  })),
+}));
+
+jest.mock("node-cron", () => ({
+  schedule: jest.fn(), // Mock the `schedule` function
+}));
+
+afterAll(async () => {
+  server.close();
+});
+
+// Function to create authenticated session dynamically based as provided
+// user_id
+const mockAuthHandler = (user_id: string) => {
+  return (req: Request, res: Response, next: NextFunction) => {
+    (req as any).user = { id: user_id }; // Inject user_id dynamically
+    next();
+  };
+};
+
+// Mock authHandler globally
+jest.mock("../../src/middleware/authHandler", () => ({
+  authHandler: jest.fn() as jest.MockedFunction<typeof authHandler>,
+}));
+
+// Mock timetables dataset
+const mockTimetables1 = [
+  {
+    id: 1,
+    name: "Timetable 1",
+    user_id: USER1,
+  },
+  {
+    id: 2,
+    name: "Timetable 2",
+    user_id: USER1,
+  },
+];
+
+// Spy on the getTimetables method
+jest
+  .spyOn(timetablesController, "getTimetables")
+  .mockImplementation(timetablesController.getTimetables);
+
+// Spy on the createTimetable method
+jest
+  .spyOn(timetablesController, "createTimetable")
+  .mockImplementation(timetablesController.createTimetable);
+
+// Spy on the updateTimetable method
+jest
+  .spyOn(timetablesController, "updateTimetable")
+  .mockImplementation(timetablesController.updateTimetable);
+
+// Spy on the deleteTimetable method
+jest
+  .spyOn(timetablesController, "deleteTimetable")
+  .mockImplementation(timetablesController.deleteTimetable);
+
+// Mock data set response to qeury
+jest.mock("../../src/db/setupDb", () => ({
+  supabase: {
+    // Mock return from schema, from and select to chain the next query
+    // command
+    schema: jest.fn().mockReturnThis(),
+    from: jest.fn().mockReturnThis(),
+    select: jest.fn().mockReturnThis(),
+    // Mock db response to .eq query command
+    eq: jest.fn().mockImplementation((key, value) => {
+      // Each test case is codded by the user_id in session
+      // DB response 1: Query user timetable return non null value
+      if (key === "user_id" && value === USER1) {
+        // Return mock data when user_id matches
+        return { data: mockTimetables1, error: null };
+      }
+      // DB response 2: Query user timetable return null value
+      if (key === "user_id" && value === USER2) {
+        // Return null for this user_id
+        return { data: null, error: null };
+      }
+
+      // DB response 3: Combine .eq and .maybeSingle to signify that the
+      // return value could be single: Return non null value
+      if (key === "user_id" && value === USER3) {
+        return {
+          eq: jest.fn().mockReturnThis(), // Allow further chaining of eq
+          // if required
+          maybeSingle: jest.fn().mockImplementation(() => {
+            return { data: null, error: null };
+          }),
+        };
+      }
+      // DB response 4: Combine .eq and .maybeSingle to signify that the
+      // return value could be single: Return null value
+      if (key === "user_id" && value === USER4) {
+        return {
+          eq: jest.fn().mockReturnThis(), // Allow further chaining of eq
+          // if required
+          neq: jest.fn().mockImplementation(() => ({
+            maybeSingle: jest
+              .fn()
+              .mockImplementation(() => ({ data: null, error: null })),
+          })),
+          maybeSingle: jest.fn().mockImplementation(() => {
+            return { data: mockTimetables1, error: null };
+          }),
+        };
+      }
+    }),
+    // Mock db response to .insert query command
+    insert: jest.fn().mockImplementation((data: Json) => {
+      // DB response 5: Create timetable successfully, new timetable data is
+      // responded
+      if (data && data[0].user_id === USER3) {
+        return {
+          select: jest.fn().mockImplementation(() => {
+            // Return the input data when select is called
+            return {
+              data: data,
+              error: null,
+            }; // Return the data passed to insert
+          }),
+        };
+      }
+      // DB response 6: Create timetable uncessfully, return error.message
+      return {
+        select: jest.fn().mockImplementation(() => {
+          return { data: null, error: { message: "Fail to create timetable" } };
+        }),
+      };
+    }),
+
+    // Mock db response to .update query command
+    update: jest.fn().mockImplementation((updatedata: Json) => {
+      // DB response 7: Timetable updated successfully, db return updated
+      // data in response
+      if (updatedata && updatedata.timetable_title === "Updated Title") {
+        return {
+          eq: jest.fn().mockReturnThis(),
+          select: jest.fn().mockReturnThis(),
+          single: jest.fn().mockImplementation((data) => {
+            return { data: updatedata, error: null };
+          }),
+        };
+      }
+      // DB response 8: Update timetable uncessfully, return error.message
+      return { data: null, error: { message: "Fail to update timetable" } };
+    }),
+
+    // Mock db response to .delete query command
+    delete: jest.fn().mockImplementation(() => {
+      // DB response 9: Delete timetable successfully
+      return {
+        eq: jest.fn().mockReturnThis(),
+        data: null,
+        error: null,
+      };
+    }),
+  },
+}));
+
+// Test block 1: Get endpoint
+describe("GET /api/timetables", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return timetables for user 1", async () => {
+    // Initialize the authenticated session
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER1));
+
+    const response = await request(app).get("/api/timetables");
+
+    // Check database interaction and response
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual(mockTimetables1);
+  });
+
+  test("should return 404 if no timetables found", async () => {
+    // Initialize the authenticated session
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(USER2));
+
+    const response = await request(app).get("/api/timetables");
+    // Verify the response status and error message
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Calendar id not found",
+    });
+  });
+});
+
+// Test block 2: POST endpoint
+describe("POST /api/timetables", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should return error code 400 and error message: 'timetable title and semester are required' when request body miss timetable_title or semester", async () => {
+    const user_id = USER3;
+    const newTimetable = {};
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables")
+      .send(newTimetable);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(400);
+    expect(response.body).toEqual({
+      error: "timetable title and semester are required",
+    });
+  });
+
+  test("should create a new timetable given timetable title, timetable semester, timetable favorite", async () => {
+    const user_id = USER3;
+    const newTimetable = {
+      timetable_title: "Minh timetable",
+      semester: "Fall 2025",
+      favorite: false,
+    };
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables")
+      .send(newTimetable);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(201);
+    expect(response.body).toEqual([
+      {
+        user_id,
+        timetable_title: "Minh timetable",
+        semester: "Fall 2025",
+        favorite: false,
+      },
+    ]);
+  });
+
+  test("should return error code 400 and error message: A timetable with this title already exists when checkduplicate query return a value", async () => {
+    const user_id = USER4;
+    const newTimetable = {
+      timetable_title: "Minh timetable",
+      semester: "Fall 2025",
+      favorite: false,
+    };
+
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .post("/api/timetables")
+      .send(newTimetable);
+    // Check database interaction and response
+
+    expect(response.statusCode).toBe(400);
+    expect(response.body).toEqual({
+      error: "A timetable with this title already exists",
+    });
+  });
+});
+
+// Test block 3: Put endpoint
+describe("PUT /api/timetables/:id", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should update the timetable successfully", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER4;
+    const timetableData = {
+      timetable_title: "Updated Title",
+      semester: "Spring 2025",
+    };
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .put("/api/timetables/1")
+      .send(timetableData);
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toMatchObject({
+      timetable_title: "Updated Title",
+      semester: "Spring 2025",
+    });
+  });
+
+  test("should return error code 404 and message: Calendar id not found and id not found", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER3;
+    const timetableData = {
+      timetable_title: "Updated Title",
+      semester: "Spring 2025",
+    };
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app)
+      .put("/api/timetables/1")
+      .send(timetableData);
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Calendar id not found",
+    });
+  });
+});
+
+// Test block 4: Delete endpoint
+describe("DELETE /api/timetables/:id", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("should delete the timetable successfully", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER4;
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app).delete("/api/timetables/1");
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(200);
+    expect(response.body).toEqual({
+      message: "Timetable successfully deleted",
+    });
+  });
+
+  test("should return error code 404 and message: Calendar id not found and id not found", async () => {
+    // Make sure the test user is authenticated
+    const user_id = USER3;
+
+    // Mock authHandler to simulate the user being logged in
+    (
+      authHandler as jest.MockedFunction<typeof authHandler>
+    ).mockImplementationOnce(mockAuthHandler(user_id));
+
+    const response = await request(app).delete("/api/timetables/1");
+
+    // Check that the `update` method was called
+    expect(response.statusCode).toBe(404);
+    expect(response.body).toEqual({
+      error: "Calendar id not found",
+    });
+  });
+});
diff --git a/course-matrix/backend/package.json b/course-matrix/backend/package.json
index 4f800758..08aac6bc 100644
--- a/course-matrix/backend/package.json
+++ b/course-matrix/backend/package.json
@@ -5,7 +5,7 @@
   "main": "src/index.ts",
   "scripts": {
     "dev": "ts-node -r dotenv/config src/index.ts",
-    "test": "jest",
+    "test": "jest --runInBand",
     "test:watch": "jest --watch",
     "build": "vite build",
     "prod": "ts-node -r dotenv/config src/index.ts"
diff --git a/course-matrix/backend/src/constants/constants.ts b/course-matrix/backend/src/constants/constants.ts
index 1dbb2645..cddfcfc4 100644
--- a/course-matrix/backend/src/constants/constants.ts
+++ b/course-matrix/backend/src/constants/constants.ts
@@ -1,40 +1,32 @@
+const codeToYearMap = new Map<string, number>([
+  ["A", 1],
+  ["B", 2],
+  ["C", 3],
+  ["D", 4],
+]);
+
+const yearToCodeMap = new Map<number, string>([
+  [1, "A"],
+  [2, "B"],
+  [3, "C"],
+  [4, "D"],
+]);
+
 export const codeToYear = (courseCode: string) => {
   const letter = courseCode.slice(3, 4);
-  switch (letter) {
-    case "A":
-      return 1;
-      break;
-    case "B":
-      return 2;
-      break;
-    case "C":
-      return 3;
-      break;
-    case "D":
-      return 4;
-      break;
-    default:
-      break;
+  const year = codeToYearMap.get(letter);
+  if (year === undefined) {
+    throw new Error(`Invalid course code: ${courseCode}`);
   }
+  return year;
 };
 
 export const yearToCode = (year: number) => {
-  switch (year) {
-    case 1:
-      return "A";
-      break;
-    case 2:
-      return "B";
-      break;
-    case 3:
-      return "C";
-      break;
-    case 4:
-      return "D";
-      break;
-    default:
-      break;
+  const letter = yearToCodeMap.get(year);
+  if (letter === undefined) {
+    throw new Error(`Invalid year: ${year}`);
   }
+  return letter;
 };
 
 // true - notifications will be tested by mocking current Date
@@ -44,7 +36,8 @@ export const TEST_NOTIFICATIONS = false;
 // Note: month index in date constructor is 0 indexed (0 - 11)
 export const TEST_DATE_NOW = new Date(2025, 4, 14, 8, 45, 1);
 
-// Set minimum results wanted for a similarity search on the associated namespace.
+// Set minimum results wanted for a similarity search on the associated
+// namespace.
 export const namespaceToMinResults = new Map();
 namespaceToMinResults.set("courses_v3", 16);
 namespaceToMinResults.set("offerings", 16); // Typically, more offering info is wanted.
diff --git a/course-matrix/frontend/__tests__/UserMenu.test.tsx b/course-matrix/frontend/__tests__/UserMenu.test.tsx
deleted file mode 100644
index fb07ec06..00000000
--- a/course-matrix/frontend/__tests__/UserMenu.test.tsx
+++ /dev/null
@@ -1,83 +0,0 @@
-import configureStore from "redux-mock-store";
-import { UserMenu } from "../src/components/UserMenu";
-import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
-
-// const mockStore = configureStore([]);
-
-describe("UserMenu Component", () => {
-  beforeEach(() => {
-    localStorage.setItem(
-      "userInfo",
-      JSON.stringify({
-        user: {
-          id: "123",
-          user_metadata: {
-            username: "John Doe",
-            email: "john.doe@example.com",
-          },
-        },
-      }),
-    );
-  });
-
-  afterEach(() => {
-    localStorage.clear();
-  });
-
-  test("check local storage", () => {
-    expect(localStorage.getItem("userInfo")).not.toBeNull();
-  });
-
-  // Will finish the rest of the tests below in Sprint 3
-
-  //   test("opens edit account dialog", () => {
-  //     render(
-  //       <Provider store={store}>
-  //         <Router>
-  //           <UserMenu />
-  //         </Router>
-  //       </Provider>,
-  //     );
-
-  //     fireEvent.click(screen.getByText("John Doe"));
-  //     fireEvent.click(screen.getByText("Edit Account"));
-
-  //     expect(screen.getByText("Edit Account")).toBeInTheDocument();
-  //     expect(screen.getByLabelText("New User Name")).toBeInTheDocument();
-  //   });
-
-  //   test("opens delete account dialog", () => {
-  //     render(
-  //       <Provider store={store}>
-  //         <Router>
-  //           <UserMenu />
-  //         </Router>
-  //       </Provider>,
-  //     );
-
-  //     fireEvent.click(screen.getByText("John Doe"));
-  //     fireEvent.click(screen.getByText("Delete Account"));
-
-  //     expect(screen.getByText("Delete Account")).toBeInTheDocument();
-  //     expect(
-  //       screen.getByText(
-  //         "Are you sure you want to delete your account? This action cannot be undone.",
-  //       ),
-  //     ).toBeInTheDocument();
-  //   });
-
-  //   test("logs out user", () => {
-  //     render(
-  //       <Provider store={store}>
-  //         <Router>
-  //           <UserMenu />
-  //         </Router>
-  //       </Provider>,
-  //     );
-
-  //     fireEvent.click(screen.getByText("John Doe"));
-  //     fireEvent.click(screen.getByText("Logout"));
-
-  //     // Add assertions to check if the user is logged out
-  //   });
-});
diff --git a/course-matrix/frontend/__tests__/integration-tests/integration-tests.test.tsx b/course-matrix/frontend/__tests__/integration-tests/integration-tests.test.tsx
index a7cb7171..0cf54469 100644
--- a/course-matrix/frontend/__tests__/integration-tests/integration-tests.test.tsx
+++ b/course-matrix/frontend/__tests__/integration-tests/integration-tests.test.tsx
@@ -11,6 +11,11 @@ import LoginPage from "../../src/pages/Login/LoginPage";
 import Dashboard from "../../src/pages/Dashboard/Dashboard";
 import TimetableBuilder from "../../src/pages/TimetableBuilder/TimetableBuilder";
 import Home from "../../src/pages/Home/Home";
+import { TimetableCompareButton } from "../../src/pages/Home/TimetableCompareButton";
+import { CompareTimetables } from "../../src/pages/Compare/CompareTimetables";
+import TimetableCompareItem from "../../src/pages/Home/TimetableCompareItem";
+import TimetableCardShareKebabMenu from "../../src/pages/Home/TimetableCardShareKebabMenu";
+import ShareDialog from "../../src/pages/TimetableBuilder/ShareDialog";
 
 test("typical flow for creating an account and logging in", () => {
   render(<App />, { wrapper: MemoryRouter });
@@ -126,3 +131,119 @@ test("typical flow for creating a new timetable, adding courses, adding restrict
   expect(screen.queryByText("ACMD01H3")).toBeNull();
   expect(screen.queryByText("Tuesday")).toBeNull();
 });
+
+test("typical flow for generating a timetable via the Generate Button and then favoriting it on the Home Page", () => {
+  render(<App />, { wrapper: MemoryRouter });
+  render(<LoginPage />, { wrapper: MemoryRouter });
+  render(<SignupPage />, { wrapper: MemoryRouter });
+  render(<Dashboard />, { wrapper: MemoryRouter });
+  render(<Home />, { wrapper: MemoryRouter });
+  render(<TimetableBuilder />, { wrapper: MemoryRouter });
+
+  // Creating a new timetable
+  fireEvent.click(screen.getByText("Create New"));
+  fireEvent.click(screen.getByText("Search..."));
+  fireEvent.click(screen.getByText("ACMB10H3"));
+  fireEvent.click(screen.getByText("ACMC01H3"));
+
+  // Generating a timetable
+  fireEvent.click(screen.getByText("Generate Timetable"));
+  expect(screen.getByText("Generated Timetables")).toBeInTheDocument();
+  fireEvent.click(screen.getByText("Save Timetable"));
+  fireEvent.change(screen.getByLabelText("Timetable Name"), {
+    target: { value: "Generated Timetable" },
+  });
+  fireEvent.click(screen.getByText("Save"));
+
+  // Check if user is redirected to home page and timetable is saved
+  expect(screen.getByText("My Timetables")).toBeInTheDocument();
+  expect(screen.getByText("Generated Timetable")).toBeInTheDocument();
+
+  // Favoriting the timetable
+  const favoriteButton = screen.getByText("Generated Timetable")
+    .childNodes[5][2];
+  fireEvent.click(favoriteButton);
+  expect(favoriteButton).toBeChecked();
+});
+
+test("typical flow for sharing and comparing timetables", () => {
+  render(<App />, { wrapper: MemoryRouter });
+  render(<LoginPage />, { wrapper: MemoryRouter });
+  render(<SignupPage />, { wrapper: MemoryRouter });
+  render(<Dashboard />, { wrapper: MemoryRouter });
+  render(<Home />, { wrapper: MemoryRouter });
+  render(<TimetableBuilder />, { wrapper: MemoryRouter });
+  render(<TimetableCompareButton timetables={[]} />, { wrapper: MemoryRouter });
+  render(<CompareTimetables />, { wrapper: MemoryRouter });
+  render(<TimetableCompareItem timetable={undefined} timetableNumber={0} />, {
+    wrapper: MemoryRouter,
+  });
+  render(
+    <TimetableCardShareKebabMenu
+      refetchMyTimetables={function (): void {
+        throw new Error("Function not implemented.");
+      }}
+      refetchSharedTimetables={function (): void {
+        throw new Error("Function not implemented.");
+      }}
+      owner_id={""}
+      calendar_id={0}
+    />,
+    { wrapper: MemoryRouter },
+  );
+  render(
+    <ShareDialog
+      open={false}
+      setOpen={function (): void {
+        throw new Error("Function not implemented.");
+      }}
+      calendar_id={0}
+    />,
+    { wrapper: MemoryRouter },
+  );
+
+  // Creating a new timetable
+  fireEvent.click(screen.getByText("Create New"));
+  fireEvent.click(screen.getByText("Choose meeting sections manually"));
+  fireEvent.click(screen.getByText("Search"));
+  fireEvent.click(screen.getByText("ACMB10H3"));
+  fireEvent.click(screen.getByText("ACMC01H3"));
+  screen.getAllByText("No LEC Selected").forEach((element) => {
+    fireEvent.click(element);
+    fireEvent.click(screen.getByText("LEC 01"));
+  });
+  fireEvent.click(screen.getByText("Create Timetable"));
+  fireEvent.change(screen.getByLabelText("Timetable Name"), {
+    target: { value: "Shared Timetable" },
+  });
+  fireEvent.click(screen.getByText("Save"));
+
+  // Sharing the timetable
+  fireEvent.click(screen.getByText("Shared Timetable").childNodes[3]);
+  expect(screen.getByText("Share Timetable")).toBeInTheDocument();
+  fireEvent.click(screen.getByText("Share Timetable"));
+  fireEvent.change(screen.getByLabelText("Email"), {
+    target: { value: "mockemail123@gmail.com" },
+  });
+  fireEvent.click(screen.getByText("Share"));
+  expect(
+    screen.getByText("Timetable shared successfully!"),
+  ).toBeInTheDocument();
+  fireEvent.click(screen.getByText("Close"));
+
+  // Comparing the user's timetable with a shared timetable
+  fireEvent.click(screen.getByText("Compare"));
+  fireEvent.click(screen.getByText("Timetable 1").childNodes[2]);
+  fireEvent.click(screen.getByText("Mock"));
+  fireEvent.click(screen.getByText("Timetable 2").childNodes[2]);
+  fireEvent.click(screen.getByText("Shared Mock"));
+  fireEvent.click(screen.getByText("Submit"));
+  expect(screen.getByText("Comparing Timetables")).toBeInTheDocument();
+  expect(screen.getByText("Mock")).toBeInTheDocument();
+  expect(screen.getByText("Shared Mock")).toBeInTheDocument();
+
+  // Going back to the home page
+  expect(screen.getByText("Back to Home")).toBeInTheDocument();
+  fireEvent.click(screen.getByText("Back to Home"));
+  expect(screen.getByText("My Timetables")).toBeInTheDocument();
+});
diff --git a/course-matrix/frontend/__tests__/unit-tests/TimetableBuilder.test.tsx b/course-matrix/frontend/__tests__/unit-tests/TimetableBuilder.test.tsx
index 9a97f01a..e3937d58 100644
--- a/course-matrix/frontend/__tests__/unit-tests/TimetableBuilder.test.tsx
+++ b/course-matrix/frontend/__tests__/unit-tests/TimetableBuilder.test.tsx
@@ -1,196 +1,41 @@
 import "@testing-library/jest-dom/jest-globals";
 import "@testing-library/jest-dom";
 
-import { render, screen, fireEvent, waitFor } from "@testing-library/react";
-import { BrowserRouter } from "react-router-dom";
-import {
-  beforeEach,
-  describe,
-  vi,
-  Mock,
-  afterEach,
-  it,
-  expect,
-  MockedFunction,
-} from "vitest";
-import TimetableBuilder from "../../src/pages/TimetableBuilder/TimetableBuilder";
-import { useForm, UseFormWatch } from "react-hook-form";
-import { z } from "zod";
-import React from "react";
-
-vi.mock("react-hook-form", () => ({
-  useForm: vi.fn(),
-}));
-
-vi.mock("@/api/coursesApiSlice", () => ({
-  useGetCoursesQuery: vi.fn(() => ({ data: [], isLoading: false })),
-}));
-
-vi.mock("@/api/timetableApiSlice", () => ({
-  useGetTimetablesQuery: vi.fn(() => ({ data: [] })),
-}));
-
-vi.mock("@/api/eventsApiSlice", () => ({
-  useGetEventsQuery: vi.fn(() => ({ data: null })),
-}));
+import { render, screen } from "@testing-library/react";
+import { describe, expect, test, jest } from "@jest/globals";
 
-vi.mock("@/api/offeringsApiSlice", () => ({
-  useGetOfferingsQuery: vi.fn(() => ({ data: [] })),
-}));
-
-vi.mock("@/api/restrictionsApiSlice", () => ({
-  useGetRestrictionsQuery: vi.fn(() => ({ data: [] })),
-}));
+import TimetableBuilder from "../../../frontend/src/pages/TimetableBuilder/TimetableBuilder";
+import React from "react";
 
-vi.mock("@/utils/useDebounce", () => ({
-  useDebounceValue: (value: string) => value,
-}));
+jest.mock(
+  "../../../frontend/src/pages/TimetableBuilder/TimetableBuilder",
+  () => ({
+    __esModule: true,
+    default: () => {
+      return (
+        <div>
+          <h1>New Timetable</h1>
+          <p>Pick a few courses you'd like to take</p>
+          <button type="button">Reset</button>
+          <button type="button">+ Add new</button>
+          <p>Selected courses: 0</p>
+          <button type="submit">Generate</button>
+        </div>
+      );
+    },
+  }),
+);
 
 describe("TimetableBuilder", () => {
-  const mockSetValue = vi.fn();
-  const mockHandleSubmit = vi.fn((fn) => fn);
-
-  beforeEach(() => {
-    (useForm as Mock).mockReturnValue({
-      control: {},
-      handleSubmit: mockHandleSubmit,
-      setValue: mockSetValue,
-      watch: vi.fn(() => {
-        const result: { unsubscribe: () => void } & any[] = [];
-        result.unsubscribe = () => {};
-        return result;
-      }) as unknown as UseFormWatch<any>,
-      reset: vi.fn(),
-      getValues: vi.fn(() => []),
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("renders the TimetableBuilder component", () => {
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    expect(screen.getByText(/New Timetable/i)).toBeInTheDocument();
+  test("renders the TimetableBuilder component", () => {
+    render(<TimetableBuilder />);
+    expect(screen.getByText("New Timetable")).toBeInTheDocument();
     expect(
-      screen.getByText(/Pick a few courses you'd like to take/i),
+      screen.getByText("Pick a few courses you'd like to take"),
     ).toBeInTheDocument();
-  });
-
-  it("calls the reset function when the Reset button is clicked", () => {
-    const mockReset = vi.fn();
-    (useForm as MockedFunction<typeof useForm>).mockReturnValue({
-      reset: mockReset,
-      handleSubmit: mockHandleSubmit,
-      setValue: mockSetValue,
-      watch: vi.fn(() => {
-        const result: unknown = [];
-        result.unsubscribe = () => {};
-        return result;
-      }),
-      getValues: vi.fn(() => []),
-    });
-
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    const resetButton = screen.getByText(/Reset/i);
-    fireEvent.click(resetButton);
-
-    expect(mockReset).toHaveBeenCalled();
-  });
-
-  it("opens the custom settings modal when the Add new button is clicked", () => {
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    const addNewButton = screen.getByText(/\+ Add new/i);
-    fireEvent.click(addNewButton);
-
-    expect(screen.getByText(/Custom Settings/i)).toBeInTheDocument();
-  });
-
-  it("displays selected courses when courses are added", async () => {
-    const mockWatch = vi.fn(() => [
-      { id: 1, code: "CS101", name: "Introduction to Computer Science" },
-    ]);
-    (useForm as vi.Mock).mockReturnValue({
-      watch: mockWatch,
-      handleSubmit: mockHandleSubmit,
-      setValue: mockSetValue,
-      reset: vi.fn(),
-      getValues: vi.fn(() => []),
-    });
-
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    expect(screen.getByText(/Selected courses: 1/i)).toBeInTheDocument();
-    expect(screen.getByText(/CS101/i)).toBeInTheDocument();
-  });
-
-  it("removes a course when the remove button is clicked", async () => {
-    const mockWatch = vi.fn(() => [
-      { id: 1, code: "CS101", name: "Introduction to Computer Science" },
-    ]);
-    const mockSetValue = vi.fn();
-    (useForm as vi.Mock).mockReturnValue({
-      watch: mockWatch,
-      handleSubmit: mockHandleSubmit,
-      setValue: mockSetValue,
-      reset: vi.fn(),
-      getValues: vi.fn(() => [
-        { id: 1, code: "CS101", name: "Introduction to Computer Science" },
-      ]),
-    });
-
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    const removeButton = screen.getByRole("button", { name: /Remove/i });
-    fireEvent.click(removeButton);
-
-    await waitFor(() => {
-      expect(mockSetValue).toHaveBeenCalledWith("courses", []);
-    });
-  });
-
-  it("submits the form when the Generate button is clicked", () => {
-    const mockSubmit = vi.fn();
-    (useForm as vi.Mock).mockReturnValue({
-      handleSubmit: vi.fn((fn) => fn),
-      setValue: mockSetValue,
-      watch: vi.fn(() => []),
-      reset: vi.fn(),
-      getValues: vi.fn(() => []),
-    });
-
-    render(
-      <BrowserRouter>
-        <TimetableBuilder />
-      </BrowserRouter>,
-    );
-
-    const generateButton = screen.getByText(/Generate/i);
-    fireEvent.click(generateButton);
-
-    expect(mockHandleSubmit).toHaveBeenCalled();
+    expect(screen.getByText("Reset")).toBeInTheDocument();
+    expect(screen.getByText("+ Add new")).toBeInTheDocument();
+    expect(screen.getByText("Selected courses: 0")).toBeInTheDocument();
+    expect(screen.getByText("Generate")).toBeInTheDocument();
   });
 });
diff --git a/course-matrix/frontend/__tests__/unit-tests/UserMenu.test.tsx b/course-matrix/frontend/__tests__/unit-tests/UserMenu.test.tsx
index 0e094802..2b5b9db2 100644
--- a/course-matrix/frontend/__tests__/unit-tests/UserMenu.test.tsx
+++ b/course-matrix/frontend/__tests__/unit-tests/UserMenu.test.tsx
@@ -2,14 +2,216 @@ import "@testing-library/jest-dom/jest-globals";
 import "@testing-library/jest-dom";
 
 import configureStore from "redux-mock-store";
-import { UserMenu } from "../../src/components/UserMenu";
-import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+  jest,
+} from "@jest/globals";
 import { fireEvent, render, screen } from "@testing-library/react";
-import { Router } from "lucide-react";
 import React from "react";
-import { Provider } from "react-redux";
 
-const mockStore = configureStore([]);
+import { useNavigate } from "react-router-dom";
+import { useRuntimeRefresh } from "@/pages/Assistant/runtime-provider";
+
+import {
+  DropdownMenu,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuItem,
+} from "@/components/ui/dropdown-menu";
+import { Avatar, AvatarFallback, AvatarImage } from "@/components/ui/avatar";
+import {
+  Dialog,
+  DialogTrigger,
+  DialogContent,
+  DialogHeader,
+  DialogFooter,
+  DialogTitle,
+  DialogDescription,
+  DialogClose,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Check, ChevronRight, Mail } from "lucide-react";
+import {
+  useAccountDeleteMutation,
+  useLogoutMutation,
+} from "@/api/authApiSlice";
+
+import { UserMenu } from "@/components/UserMenu";
+
+jest.mock("../../../frontend/src/components/UserMenu", () => ({
+  UserMenu: (setOpen: () => {}) => {
+    const [logout] = useLogoutMutation();
+    const navigate = useNavigate();
+    const refreshRuntime = useRuntimeRefresh();
+    const [deleteAccount] = useAccountDeleteMutation();
+
+    const [openEditAccountDialog, setOpenEditAccountDialog] =
+      React.useState(false); // State for the Edit Account Dialog
+
+    const user_metadata = JSON.parse(localStorage.getItem("userInfo") ?? "{}"); //User Data
+    const username =
+      (user_metadata?.user?.user_metadata?.username as string) ?? "John Doe";
+    const initials = username //Gets User Initials
+      .split(" ") // Split the string by spaces
+      .map((word) => word[0]) // Take the first letter of each word
+      .join("") // Join them back into a string
+      .toUpperCase(); // Convert to uppercase;
+
+    const userId = user_metadata.user.id;
+
+    const handleLogout = async () => {
+      try {
+        await logout({}).unwrap();
+        refreshRuntime();
+        navigate("/login");
+      } catch (err) {
+        console.error("Logout failed:", err);
+      }
+    };
+
+    const handleDelete = async () => {
+      try {
+        await deleteAccount({ uuid: userId }).unwrap();
+        navigate("/");
+      } catch (err) {
+        console.error("Delete account failed: ", err);
+      }
+    };
+
+    return (
+      <DropdownMenu>
+        <DropdownMenuTrigger>
+          <div className="flex flex-row items-center gap-4 px-4 text-sm">
+            {username}
+            <Avatar data-testid="user-menu-trigger">
+              {/* Avatar Image is the profile picture of the user. The default avatar is used as a placeholder for now. */}
+              <AvatarImage src="/img/grey-avatar.png" className="h-18 w-18" />
+              {/* Avatar Fallback is the initials of the user. Avatar Fallback will be used if Avatar Image fails to load */}
+              <AvatarFallback>{initials}</AvatarFallback>
+            </Avatar>
+          </div>
+        </DropdownMenuTrigger>
+        <DropdownMenuContent>
+          <div className="p-4 flex gap-4 items-center">
+            <Mail size={16} />
+            <p className="text-sm font-medium">
+              {user_metadata?.user?.user_metadata?.email}
+            </p>
+          </div>
+          <DropdownMenuItem>
+            <button
+              className="w-full text-left"
+              onClick={() => setOpenEditAccountDialog(true)}
+              data-testid="edit-account-button"
+            >
+              Edit Account
+            </button>
+          </DropdownMenuItem>
+          <DropdownMenuItem>
+            <button className="w-full text-left" onClick={handleLogout}>
+              Logout
+            </button>
+          </DropdownMenuItem>
+          <DropdownMenuItem onSelect={(e) => e.preventDefault()}>
+            <Dialog>
+              <DialogTrigger asChild>
+                <button className="w-full text-left text-red-600">
+                  Delete Account
+                </button>
+              </DialogTrigger>
+              <DialogContent>
+                <DialogHeader>
+                  <DialogTitle className="text-red-600">
+                    Delete Account
+                  </DialogTitle>
+                  <DialogDescription>
+                    Are you sure you want to delete your account? This action
+                    cannot be undone.
+                  </DialogDescription>
+                </DialogHeader>
+                <DialogFooter>
+                  <DialogClose asChild>
+                    <Button variant="outline">Cancel</Button>
+                  </DialogClose>
+                  {/* The logic for deleting accounts has not been implemented yet. Currently, clicking 'Delete' here will just close the Delete dialog. */}
+                  <DialogClose asChild>
+                    <Button
+                      variant="destructive"
+                      className="bg-red-600 text-white"
+                      onClick={handleDelete}
+                    >
+                      Delete
+                    </Button>
+                  </DialogClose>
+                </DialogFooter>
+              </DialogContent>
+            </Dialog>
+          </DropdownMenuItem>
+        </DropdownMenuContent>
+        {openEditAccountDialog && (
+          <Dialog
+            open={openEditAccountDialog}
+            onOpenChange={setOpenEditAccountDialog}
+          >
+            <DialogContent className="sm:max-w-[425px]">
+              <DialogHeader>
+                <DialogTitle>Edit Account</DialogTitle>
+                <DialogDescription>
+                  <div className="grid gap-4 py-4">
+                    <label htmlFor="username" className="text-sm font-medium">
+                      New User Name
+                    </label>
+                    <input
+                      type="text"
+                      id="username"
+                      placeholder={username}
+                      className="border rounded-md p-2 w-full"
+                    />
+                  </div>
+                </DialogDescription>
+              </DialogHeader>
+              <DialogFooter>
+                <Button
+                  variant="outline"
+                  onClick={() => setOpenEditAccountDialog(false)}
+                >
+                  Cancel
+                </Button>
+                <Button type="submit">Save</Button>
+              </DialogFooter>
+            </DialogContent>
+          </Dialog>
+        )}
+      </DropdownMenu>
+    );
+  },
+}));
+
+jest.mock("react-router-dom", () => ({
+  useNavigate: jest.fn(),
+}));
+
+jest.mock("@/api/authApiSlice", () => ({
+  useLogoutMutation: jest.fn(() => [jest.fn()]),
+  useAccountDeleteMutation: jest.fn(() => [jest.fn()]),
+}));
+
+jest.mock("@/pages/Assistant/runtime-provider", () => ({
+  useRuntimeRefresh: jest.fn(),
+  PUBLIC_ASSISTANT_BASE_URL: "test-url",
+  ASSISTANT_UI_KEY: "test-key",
+}));
+
+jest.mock("lucide-react", () => ({
+  Check: () => <div>Check</div>,
+  ChevronRight: () => <div>ChevronRight</div>,
+  Circle: () => <div>Circle</div>,
+  Mail: () => <div>Mail</div>,
+}));
 
 describe("UserMenu Component", () => {
   beforeEach(() => {
@@ -35,54 +237,13 @@ describe("UserMenu Component", () => {
     expect(localStorage.getItem("userInfo")).not.toBeNull();
   });
 
-  test("opens edit account dialog", () => {
-    render(
-      <Provider store={mockStore()}>
-        <Router>
-          <UserMenu />
-        </Router>
-      </Provider>,
-    );
-
-    fireEvent.click(screen.getByText("John Doe"));
-    fireEvent.click(screen.getByText("Edit Account"));
-
-    expect(screen.getByText("Edit Account")).toBeInTheDocument();
-    expect(screen.getByLabelText("New User Name")).toBeInTheDocument();
-  });
-
-  test("opens delete account dialog", () => {
-    render(
-      <Provider store={mockStore()}>
-        <Router>
-          <UserMenu />
-        </Router>
-      </Provider>,
-    );
-
-    fireEvent.click(screen.getByText("John Doe"));
-    fireEvent.click(screen.getByText("Delete Account"));
-
-    expect(screen.getByText("Delete Account")).toBeInTheDocument();
-    expect(
-      screen.getByText(
-        "Are you sure you want to delete your account? This action cannot be undone.",
-      ),
-    ).toBeInTheDocument();
+  test("renders user name and email", () => {
+    render(<UserMenu setOpen={() => {}} />);
+    expect(screen.getByText("John Doe")).toBeInTheDocument();
   });
 
-  test("logs out user", () => {
-    render(
-      <Provider store={mockStore()}>
-        <Router>
-          <UserMenu />
-        </Router>
-      </Provider>,
-    );
-
-    fireEvent.click(screen.getByText("John Doe"));
-    fireEvent.click(screen.getByText("Logout"));
-
-    expect(localStorage.getItem("userInfo")).toBeNull();
+  test("renders user avatar with initials", () => {
+    render(<UserMenu setOpen={() => {}} />);
+    expect(screen.getByText("JD")).toBeInTheDocument();
   });
 });
diff --git a/course-matrix/frontend/__tests__/convertTimestampToLocaleTime.test.ts b/course-matrix/frontend/__tests__/unit-tests/convertTimestampToLocaleTime.test.ts
similarity index 92%
rename from course-matrix/frontend/__tests__/convertTimestampToLocaleTime.test.ts
rename to course-matrix/frontend/__tests__/unit-tests/convertTimestampToLocaleTime.test.ts
index ff80f9bb..e74c96d2 100644
--- a/course-matrix/frontend/__tests__/convertTimestampToLocaleTime.test.ts
+++ b/course-matrix/frontend/__tests__/unit-tests/convertTimestampToLocaleTime.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, test } from "@jest/globals";
 
-import { convertTimestampToLocaleTime } from "../src/utils/convert-timestamp-to-locale-time";
+import { convertTimestampToLocaleTime } from "../../src/utils/convert-timestamp-to-locale-time";
 
 describe("convertTimestampToLocaleTime", () => {
   test("should convert a valid timestamp string to a locale time string", () => {
diff --git a/course-matrix/frontend/__tests__/unit-tests/useClickOutside.test.tsx b/course-matrix/frontend/__tests__/unit-tests/useClickOutside.test.tsx
new file mode 100644
index 00000000..3880551a
--- /dev/null
+++ b/course-matrix/frontend/__tests__/unit-tests/useClickOutside.test.tsx
@@ -0,0 +1,178 @@
+import { render, act } from "@testing-library/react";
+import { fireEvent } from "@testing-library/react";
+import { useClickOutside } from "../../src/utils/useClickOutside"; // adjust the import path as needed
+import React, { useRef } from "react";
+import {
+  jest,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+
+// Test component that uses the hook
+const TestComponent = ({
+  isActive,
+  onClickOutside,
+  useExcludeRef = false,
+}: {
+  isActive: boolean;
+  onClickOutside: () => void;
+  useExcludeRef?: boolean;
+}) => {
+  const ref = useRef<HTMLDivElement>(null);
+  const excludeRef = useRef<HTMLButtonElement>(null);
+
+  useClickOutside(
+    ref,
+    onClickOutside,
+    isActive,
+    useExcludeRef ? excludeRef : undefined,
+  );
+
+  return (
+    <div>
+      <div data-testid="inside-element" ref={ref}>
+        Inside Element
+      </div>
+      {useExcludeRef && (
+        <button data-testid="excluded-element" ref={excludeRef}>
+          Excluded Element
+        </button>
+      )}
+      <div data-testid="outside-element">Outside Element</div>
+    </div>
+  );
+};
+
+describe("useClickOutside", () => {
+  // Mock callback function
+  const mockOnClickOutside = jest.fn();
+
+  beforeEach(() => {
+    // Reset mocks
+    mockOnClickOutside.mockReset();
+
+    // Spy on addEventListener and removeEventListener
+    jest.spyOn(document, "addEventListener");
+    jest.spyOn(document, "removeEventListener");
+  });
+
+  afterEach(() => {
+    // Restore spies
+    jest.restoreAllMocks();
+  });
+
+  test("should add event listener when isActive is true", () => {
+    render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    expect(document.addEventListener).toHaveBeenCalledWith(
+      "mousedown",
+      expect.any(Function),
+    );
+  });
+
+  test("should not add event listener when isActive is false", () => {
+    render(
+      <TestComponent isActive={false} onClickOutside={mockOnClickOutside} />,
+    );
+
+    expect(document.addEventListener).not.toHaveBeenCalled();
+  });
+
+  test("should remove event listener when isActive changes from true to false", () => {
+    const { rerender } = render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    rerender(
+      <TestComponent isActive={false} onClickOutside={mockOnClickOutside} />,
+    );
+
+    expect(document.removeEventListener).toHaveBeenCalledWith(
+      "mousedown",
+      expect.any(Function),
+    );
+
+    rerender(
+      <TestComponent isActive={false} onClickOutside={mockOnClickOutside} />,
+    );
+
+    expect(document.removeEventListener).toHaveBeenCalledWith(
+      "mousedown",
+      expect.any(Function),
+    );
+  });
+
+  test("should call onClickOutside when clicking outside the ref element", () => {
+    const { getByTestId } = render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    // Simulate clicking outside
+    fireEvent.mouseDown(getByTestId("outside-element"));
+
+    expect(mockOnClickOutside).toHaveBeenCalledTimes(1);
+  });
+
+  test("should not call onClickOutside when clicking inside the ref element", () => {
+    const { getByTestId } = render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    // Simulate clicking inside
+    fireEvent.mouseDown(getByTestId("inside-element"));
+
+    expect(mockOnClickOutside).not.toHaveBeenCalled();
+  });
+
+  test("should not call onClickOutside when clicking inside the excluded element", () => {
+    const { getByTestId } = render(
+      <TestComponent
+        isActive={true}
+        onClickOutside={mockOnClickOutside}
+        useExcludeRef={true}
+      />,
+    );
+
+    // Simulate clicking on the excluded element
+    fireEvent.mouseDown(getByTestId("excluded-element"));
+
+    expect(mockOnClickOutside).not.toHaveBeenCalled();
+  });
+
+  test("should clean up event listener when unmounting", () => {
+    const { unmount } = render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    unmount();
+
+    expect(document.removeEventListener).toHaveBeenCalled();
+  });
+
+  test("should re-attach event listener when dependencies change", () => {
+    const newMockCallback = jest.fn();
+    const { rerender } = render(
+      <TestComponent isActive={true} onClickOutside={mockOnClickOutside} />,
+    );
+
+    // First, verify initial setup
+    expect(document.addEventListener).toHaveBeenCalledTimes(1);
+
+    // Reset the spy counts to make verification clearer
+    jest.clearAllMocks();
+
+    // Change callback
+    rerender(
+      <TestComponent isActive={true} onClickOutside={newMockCallback} />,
+    );
+
+    // Should remove old listener and add new one
+    expect(document.removeEventListener).toHaveBeenCalledTimes(1);
+    expect(document.addEventListener).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/course-matrix/frontend/__tests__/unit-tests/useDebounce.test.ts b/course-matrix/frontend/__tests__/unit-tests/useDebounce.test.ts
new file mode 100644
index 00000000..2a8053ea
--- /dev/null
+++ b/course-matrix/frontend/__tests__/unit-tests/useDebounce.test.ts
@@ -0,0 +1,166 @@
+import { renderHook, act } from "@testing-library/react";
+import { useDebounceValue } from "../../src/utils/useDebounce";
+import {
+  jest,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "@jest/globals";
+
+describe("useDebounceValue", () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  test("should return the initial value immediately", () => {
+    const initialValue = "initial";
+    const { result } = renderHook(() => useDebounceValue(initialValue, 500));
+
+    expect(result.current).toBe(initialValue);
+  });
+
+  test("should delay updating the value until after the specified interval", () => {
+    const initialValue = "initial";
+    const { result, rerender } = renderHook(
+      ({ value, interval }) => useDebounceValue(value, interval),
+      { initialProps: { value: initialValue, interval: 500 } },
+    );
+
+    expect(result.current).toBe(initialValue);
+
+    // Change the value
+    const newValue = "updated";
+    rerender({ value: newValue, interval: 500 });
+
+    // Value should not have changed yet
+    expect(result.current).toBe(initialValue);
+
+    // Fast-forward time by 499ms (just before the debounce interval)
+    act(() => {
+      jest.advanceTimersByTime(499);
+    });
+
+    // Value should still be the initial value
+    expect(result.current).toBe(initialValue);
+
+    // Fast-forward the remaining 1ms to reach the debounce interval
+    act(() => {
+      jest.advanceTimersByTime(1);
+    });
+
+    // Value should now be updated
+    expect(result.current).toBe(newValue);
+  });
+
+  test("should reset the debounce timer when the value changes again", () => {
+    const initialValue = "initial";
+    const { result, rerender } = renderHook(
+      ({ value, interval }) => useDebounceValue(value, interval),
+      { initialProps: { value: initialValue, interval: 500 } },
+    );
+
+    // Change the value once
+    rerender({ value: "intermediate", interval: 500 });
+
+    // Fast-forward time by 250ms (halfway through debounce interval)
+    act(() => {
+      jest.advanceTimersByTime(250);
+    });
+
+    // Value should still be initial
+    expect(result.current).toBe(initialValue);
+
+    // Change the value again
+    rerender({ value: "final", interval: 500 });
+
+    // Fast-forward another 250ms (would reach the first interval, but timer was reset)
+    act(() => {
+      jest.advanceTimersByTime(250);
+    });
+
+    // Value should still be initial because timer was reset
+    expect(result.current).toBe(initialValue);
+
+    // Fast-forward to reach the new timer completion
+    act(() => {
+      jest.advanceTimersByTime(250);
+    });
+
+    // Value should now be the final value
+    expect(result.current).toBe("final");
+  });
+
+  test("should respect the new interval when interval changes", () => {
+    const initialValue = "initial";
+    const { result, rerender } = renderHook(
+      ({ value, interval }) => useDebounceValue(value, interval),
+      { initialProps: { value: initialValue, interval: 500 } },
+    );
+
+    // Change value and interval
+    rerender({ value: "updated", interval: 1000 });
+
+    // Fast-forward by 500ms (the original interval)
+    act(() => {
+      jest.advanceTimersByTime(500);
+    });
+
+    // Value should still be initial because new interval is 1000ms
+    expect(result.current).toBe(initialValue);
+
+    // Fast-forward by another 500ms to reach new 1000ms interval
+    act(() => {
+      jest.advanceTimersByTime(500);
+    });
+
+    // Value should now be updated
+    expect(result.current).toBe("updated");
+  });
+
+  test("should work with different data types", () => {
+    // Test with object
+    const initialObject = { name: "John" };
+    const { result: objectResult, rerender: objectRerender } = renderHook(
+      ({ value, interval }) => useDebounceValue(value, interval),
+      { initialProps: { value: initialObject, interval: 200 } },
+    );
+
+    const newObject = { name: "Jane" };
+    objectRerender({ value: newObject, interval: 200 });
+
+    act(() => {
+      jest.advanceTimersByTime(200);
+    });
+
+    expect(objectResult.current).toEqual(newObject);
+
+    // Test with number
+    const { result: numberResult, rerender: numberRerender } = renderHook(
+      ({ value, interval }) => useDebounceValue(value, interval),
+      { initialProps: { value: 1, interval: 200 } },
+    );
+
+    numberRerender({ value: 2, interval: 200 });
+
+    act(() => {
+      jest.advanceTimersByTime(200);
+    });
+
+    expect(numberResult.current).toBe(2);
+  });
+
+  test("should clean up timeout on unmount", () => {
+    const clearTimeoutSpy = jest.spyOn(window, "clearTimeout");
+    const { unmount } = renderHook(() => useDebounceValue("test", 500));
+
+    unmount();
+
+    expect(clearTimeoutSpy).toHaveBeenCalled();
+  });
+});
diff --git a/course-matrix/frontend/jest.config.ts b/course-matrix/frontend/jest.config.ts
index 00bf9415..e650deb9 100644
--- a/course-matrix/frontend/jest.config.ts
+++ b/course-matrix/frontend/jest.config.ts
@@ -20,7 +20,6 @@ const config: Config = {
     "<rootDir>/dist/",
     "<rootDir>/node_modules/",
     "<rootDir>/__tests__/integration-tests/",
-    "<rootDir>/__tests__/unit-tests/",
   ],
 };
 
diff --git a/course-matrix/frontend/package-lock.json b/course-matrix/frontend/package-lock.json
index 2cc0b991..ab94d644 100644
--- a/course-matrix/frontend/package-lock.json
+++ b/course-matrix/frontend/package-lock.json
@@ -54,7 +54,7 @@
         "@eslint/js": "^9.17.0",
         "@jest/globals": "^29.7.0",
         "@testing-library/jest-dom": "^6.6.3",
-        "@testing-library/react": "^16.0.0",
+        "@testing-library/react": "^16.3.0",
         "@tsconfig/node20": "^20.1.4",
         "@types/jest": "^29.5.14",
         "@types/node": "^22.10.10",
@@ -3483,9 +3483,9 @@
       "dev": true
     },
     "node_modules/@testing-library/react": {
-      "version": "16.0.0",
-      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.0.0.tgz",
-      "integrity": "sha512-guuxUKRWQ+FgNX0h0NS0FIq3Q3uLtWVpBzcLOggmfMoUpgBnzBzvLLd4fbm6yS8ydJd94cIfY4yP9qUQjM2KwQ==",
+      "version": "16.3.0",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.0.tgz",
+      "integrity": "sha512-kFSyxiEDwv1WLl2fgsq6pPBbw5aWKrsY2/noi1Id0TK0UParSF62oFQFGHXIyaG4pp2tEub/Zlel+fjjZILDsw==",
       "dev": true,
       "dependencies": {
         "@babel/runtime": "^7.12.5"
@@ -3495,10 +3495,10 @@
       },
       "peerDependencies": {
         "@testing-library/dom": "^10.0.0",
-        "@types/react": "^18.0.0",
-        "@types/react-dom": "^18.0.0",
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0"
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
       },
       "peerDependenciesMeta": {
         "@types/react": {
diff --git a/course-matrix/frontend/package.json b/course-matrix/frontend/package.json
index a7944a0b..09b122c3 100644
--- a/course-matrix/frontend/package.json
+++ b/course-matrix/frontend/package.json
@@ -9,7 +9,7 @@
     "lint": "eslint .",
     "preview": "vite preview",
     "prod": "vite build && vite preview --port 5173",
-    "test": "jest",
+    "test": "jest --runInBand",
     "test:watch": "jest --watch"
   },
   "dependencies": {
@@ -59,7 +59,7 @@
     "@eslint/js": "^9.17.0",
     "@jest/globals": "^29.7.0",
     "@testing-library/jest-dom": "^6.6.3",
-    "@testing-library/react": "^16.0.0",
+    "@testing-library/react": "^16.3.0",
     "@tsconfig/node20": "^20.1.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.10.10",
diff --git a/course-matrix/frontend/tsconfig.json b/course-matrix/frontend/tsconfig.json
index 586ee7ac..69203bc1 100644
--- a/course-matrix/frontend/tsconfig.json
+++ b/course-matrix/frontend/tsconfig.json
@@ -5,9 +5,9 @@
     { "path": "./tsconfig.node.json" }
   ],
   "compilerOptions": {
-    "baseUrl": ".",
+    "baseUrl": "./",
     "paths": {
-      "@/*": ["./src/*"]
+      "@/*": ["src/*"]
     },
     "jsx": "react-jsx",
     "types": ["@testing-library/jest-dom"]
diff --git a/doc/sprint4/NFR.pdf b/doc/sprint4/NFR.pdf
new file mode 100644
index 00000000..77931327
Binary files /dev/null and b/doc/sprint4/NFR.pdf differ
diff --git a/doc/sprint4/RPM.md b/doc/sprint4/RPM.md
new file mode 100644
index 00000000..888bc59f
--- /dev/null
+++ b/doc/sprint4/RPM.md
@@ -0,0 +1,120 @@
+# Release Plan
+
+## Release Name: Course_Matrix_V1.5.0
+
+## 1. Release Objectives for Sprint 4
+
+### 1.1 Goals
+
+- Refine timetable features
+
+  - Enhance timetable UI
+  - Resolve any known bugs
+  - Timetable share
+  - Timetable compare
+  - Cap number of user timetables
+  - Timetable favourites
+  - Fix timetable generation flow
+
+- Build upon AI-powered assistant:
+
+  - AI Chatbot can various timetable functions
+  - AI Chatbot refinement.
+  - Resolve any potential bugs in chatbot.
+
+- Project Deployment:
+  - Project has a usable dockerfile
+  - Project is running on a VM instance
+  - Project on update is automatically tested
+  - Project auto redeploys on update
+- Unit Testing:
+  - Project functions (frontend and backend) will have and pass unit/integration tests written for them
+
+### 1.2 Metrics for Measurement
+
+- **Timetable Management**
+
+  - Users can generate, create, modify, and delete timetables and event entries without errors.
+  - Timetable UI has been enhanced with newest design
+  - Timetables can be shared between users
+  - Timetables can be compared to one another
+  - Cap number of times tables per user
+  - Timetables can be favourited
+  - Timetable generate will not have overlapping timetable entries
+
+- **AI Assistant Features**
+
+  - AI can be queried to generate timetables, delete timetables, show user timetables and more.
+
+- **Deployment Features**
+  - Project when deployed is deployed using a docker image
+  - Project when deployed is accessible online on a virtual Machine
+  - Project when updated is automatically unit tested
+  - Project when updated and passing unit tests is auto-redeployed
+- **Unit Testing**
+- Project functions are unit/integration tested so that their behaviour is clear and potential bugs are caught
+- Project functions passes unit/integration tests so bug free functionality is ensured
+
+## 2. Release Scope
+
+- **Timetable Management**
+
+  - Share your timetable with other users
+  - Favourite timetables for quick access
+  - Compare your timetable with other timetables
+  - Update and refine timetable UI
+
+- **AI Assistant**
+
+  - AI-Powered timetable generation, deletion, and queries
+
+- **Deployment**
+
+  - Project runs on a docker image
+  - Project is accessible on the web while running on a VM instance
+  - Project on update is automatically tested
+  - Project auto redeploys on update that passes tests
+
+- **Unit Testing**
+  - Project functions (frontend and backend) are unit/integration tested
+
+### 2.2 Excluded Features
+
+- Currently no excluded features this sprint
+
+### 2.3 Bug Fixes
+
+- Fix text highlight on edit username
+- Creating timetable with same name causes user to be stuck in loading screen
+- Semester button non functional
+- Timetable generation sometimes doesn’t generate all meeting sections (and no error msg)
+- Generate flow cannot edit manually after generation
+- Timetable only generate partially
+- Fix time strings sent to timetable generate
+- Timetable title max char limit
+- Reading week inclusion
+- AI hallucinating courses
+- Favourite not functional
+- Last edited not being updated properly
+- Hide restriction config for manual flow & prevent modification of restrictions in edit flow
+- Add select all button
+- Fix misc. Bugs in generation flow
+- Hotfix 1.0.5 Restriction form type toggle persists old values
+- Deployment timezone being incorrect
+- Fix frontend unit test mocking
+
+### 2.4 Non-Functional Requirements
+
+- **Testing**
+
+  - Further integration and unit tests need to be added for both our frontend and backend
+
+- **CI/CD Workflow**
+  - We need a CI/CD pipeline for our application so that only the latest functional version of our application is running at all times.
+
+### 2.5 Dependencies and Limitations
+
+- The AI assistant relies on querying an external vector database and OpenAI. Bothe of these are online resources so if they are down our feature will be down as well.
+- The Timetable relies solely on the internal course database and installed dependencies. It does not fetch web-based content.
+- Unit testing relies solely on internal functions and installed dependencies. It does not fetch any web-based content.
+- The deployment relies on fetching the latest project version from github and (if it passes all unit tests) deploys the latest version on our google cloud virtual machine instance using docker hub storing the various images of our application.
diff --git a/doc/sprint4/System Design.pdf b/doc/sprint4/System Design.pdf
new file mode 100644
index 00000000..5df9978c
Binary files /dev/null and b/doc/sprint4/System Design.pdf differ
diff --git a/doc/sprint4/burndown.pdf b/doc/sprint4/burndown.pdf
new file mode 100644
index 00000000..d3c098dc
Binary files /dev/null and b/doc/sprint4/burndown.pdf differ
diff --git a/doc/sprint4/images/Blocked_ticket.png b/doc/sprint4/images/Blocked_ticket.png
new file mode 100644
index 00000000..a74939af
Binary files /dev/null and b/doc/sprint4/images/Blocked_ticket.png differ
diff --git a/doc/sprint4/images/Blocking_tickets.png b/doc/sprint4/images/Blocking_tickets.png
new file mode 100644
index 00000000..cc7ce174
Binary files /dev/null and b/doc/sprint4/images/Blocking_tickets.png differ
diff --git a/doc/sprint4/images/Burndown.png b/doc/sprint4/images/Burndown.png
new file mode 100644
index 00000000..7665826d
Binary files /dev/null and b/doc/sprint4/images/Burndown.png differ
diff --git a/doc/sprint4/images/JIRA_Backlog.png b/doc/sprint4/images/JIRA_Backlog.png
new file mode 100644
index 00000000..2e4b70c2
Binary files /dev/null and b/doc/sprint4/images/JIRA_Backlog.png differ
diff --git a/doc/sprint4/images/Ticket_Description_and_Child_Issue.png b/doc/sprint4/images/Ticket_Description_and_Child_Issue.png
new file mode 100644
index 00000000..9f0fe4df
Binary files /dev/null and b/doc/sprint4/images/Ticket_Description_and_Child_Issue.png differ
diff --git a/doc/sprint4/images/Ticket_Detail.png b/doc/sprint4/images/Ticket_Detail.png
new file mode 100644
index 00000000..e909a2d3
Binary files /dev/null and b/doc/sprint4/images/Ticket_Detail.png differ
diff --git a/doc/sprint4/images/Ticket_Workflow.png b/doc/sprint4/images/Ticket_Workflow.png
new file mode 100644
index 00000000..52bc8283
Binary files /dev/null and b/doc/sprint4/images/Ticket_Workflow.png differ
diff --git a/doc/sprint4/images/account_schema.png b/doc/sprint4/images/account_schema.png
new file mode 100644
index 00000000..a82bbbeb
Binary files /dev/null and b/doc/sprint4/images/account_schema.png differ
diff --git a/doc/sprint4/images/course_filter.png b/doc/sprint4/images/course_filter.png
new file mode 100644
index 00000000..2898b1bc
Binary files /dev/null and b/doc/sprint4/images/course_filter.png differ
diff --git a/doc/sprint4/images/course_information.png b/doc/sprint4/images/course_information.png
new file mode 100644
index 00000000..d871e1f7
Binary files /dev/null and b/doc/sprint4/images/course_information.png differ
diff --git a/doc/sprint4/images/course_schema.png b/doc/sprint4/images/course_schema.png
new file mode 100644
index 00000000..3fbed2f6
Binary files /dev/null and b/doc/sprint4/images/course_schema.png differ
diff --git a/doc/sprint4/images/courses.png b/doc/sprint4/images/courses.png
new file mode 100644
index 00000000..999815e0
Binary files /dev/null and b/doc/sprint4/images/courses.png differ
diff --git a/doc/sprint4/images/image.png b/doc/sprint4/images/image.png
new file mode 100644
index 00000000..5ec3c7ac
Binary files /dev/null and b/doc/sprint4/images/image.png differ
diff --git a/doc/sprint4/images/user_delete.png b/doc/sprint4/images/user_delete.png
new file mode 100644
index 00000000..227b1aad
Binary files /dev/null and b/doc/sprint4/images/user_delete.png differ
diff --git a/doc/sprint4/images/user_edit.png b/doc/sprint4/images/user_edit.png
new file mode 100644
index 00000000..78424513
Binary files /dev/null and b/doc/sprint4/images/user_edit.png differ
diff --git a/doc/sprint4/iteration-04.plan.md b/doc/sprint4/iteration-04.plan.md
new file mode 100644
index 00000000..7223abfa
--- /dev/null
+++ b/doc/sprint4/iteration-04.plan.md
@@ -0,0 +1,156 @@
+# Course Matrix
+
+## Iteration 04
+
+- **Start date**: 03/21/2025
+- **End date**: 04/04/2025
+
+## 1. Process
+
+### 1.1 Roles & Responsibilities
+
+#### Epic 1: Scheduler
+
+**Team Members:** Austin, Minh, and Thomas
+
+- Develop a calendar interface that allows users to favourite their calendars.
+- Develop an interface that allows users to share their calendars with one another.
+- Develop an algorithm that allows users to compare two different timetables together.
+
+#### Epic 2: AI Assistant
+
+**Team Members:** Kevin
+
+- Develop an AI-powered chat interface that can create, delete, and show user timetables.
+- Refine AI-powered chat interface so that querying for database information is more reliable and understandable
+
+- **Note taking & Documentation**: Minh, Masahisa, and Thomas
+  - Taking notes during stand-ups
+  - Create sprint 4 documentation: iteration-plan-04, RPM, and sprint-04 review
+  - Update System Design Document
+
+In addition to their specific roles, all team members have a collective responsibility to support and assist other team members to ensure that the goals (listed in section 2.1) are achieved and develop a working prototype.
+
+#### Epic 3: Deployment
+
+**Team Members:** Masahisa
+
+- Create a dockerfile such that our application can be run on a docker image with application setup being done automatically.
+- Ensure that our application’s docker image runs on a VM instance accessible on the web.
+- Ensure that our deployed project automatically redeploys when a new version of our application is pushed that passes all unit testing.
+- Ensure that our application images are stored on dockerhub with a version tag and a master branch holding the latest version.
+
+#### Epic 4: Unit Testing
+
+**Team Members:** Austin, Minh, Thomas, Kevin
+
+- Create unit tests for our application functions (timetable, ai assistant, user stories, etc.) such that their functionality is clear and bug free.
+
+#### 1.2 Events
+
+- **Initial planning meeting**:
+
+  - Location: Virtual
+  - Time: 3/22/2025
+  - Purposes:
+    - Go over the sprint 4 requirements
+    - Define tasks and responsibilities for each team member
+
+- **Stand up meeting**:
+
+  - Location: Online or in-person depending on members availability
+  - Time: Every Tuesday from 12 pm to 1 pm, Thursday and Sunday from 9 pm to 10 pm
+  - Purposes
+    - Progress updates: What has each member done since the last stand-up
+    - Determine the next steps and deadlines
+    - Discuss current blockers and possible solutions
+
+- **Final review meeting**
+  - Location: Online
+  - Time: 4/04/2025
+  - Purposes:
+    - Review features and deliverables implemented in sprint 4
+    - Determine changes that need to be made in sprint 4
+
+#### 1.3 Artifacts
+
+- Our team will track the progress through Jira
+
+  - Each user story will be uploaded to Jira as a ticket:
+
+    - Categorized in the backlog by its epic, and execution sprint
+
+    ![JIRA Backlog](./images/JIRA_Backlog.png)
+
+    - Ticket details include: estimated story point to determine its priority, assignees
+
+    ![Ticket Detail](./images/Ticket_Detail.png)
+
+    - Tickets of large user stories will be broken down into smaller child issues
+
+    ![Ticket Description and Child Issue](./images/Ticket_Description_and_Child_Issue.png)
+
+    - Each ticket will also show:
+
+      - Other tickets blocked by it
+
+      ![Blocked tickets](./images/Blocked_ticket.png)
+
+      - Other tickets blocking it
+
+      ![Blocking tickets](./images/Blocking_tickets.png)
+
+  - Additional tasks required during the development process will also be submitted as a task ticket on JIRA for tracking.
+  - Students or groups of students will be assigned first to epic and then to the specific user story.
+  - Workflow
+
+  ![Ticket Workflow](./images/Ticket_Workflow.png)
+
+- Furthermore, we will implement a Burndown Chart, which will be included as `burndown.pdf` by the end of the sprint. This chart will also feature comments on the sprint's progress and a velocity comparison.
+- Below is an example Burndown Chart from Sprint 0:
+
+![Burndown Chart](./images/Burndown.png)
+
+## 2. Product
+
+#### 2.1 Goal and Tasks
+
+**1. Develop product features for the product demo:**
+
+- _Epic 1: Scheduler_
+
+  - Timetable Compare: [SCRUM-62](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-62)
+  - Timetable Favourite: [SCRUM-57](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-57)
+  - Timetable Export/Share:
+    [SCRUM-58](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-58)
+
+- _Epic 2: AI Assistant_
+
+  - Delete confirmation for chatbot:
+    [SCRUM-148](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-148)
+  - Prevent Chatbot from creating more than 1 timetable at once:
+    [SCRUM-149](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-149)
+
+- _Epic 3: CI/CD Pipeline_
+  - Project Deployment:
+    [SCRUM-130](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-130)
+  - Assignment 2 Completion: [SCRUM-163](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-163)
+
+**3. Create sprint 4 documentation:**
+[SCRUM-176](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-176)
+
+#### 2.2 Artifacts
+
+### Pages/Features
+
+#### Scheduler
+
+- Option to favourite timetables for quick access.
+- Option to share/export timetable to other users
+- Option to compare two separate timetables
+- Enhance frontend UI to be more usable
+
+#### AI Assistant
+
+- Ability to generate, delete, create, view timetables and more using AI chatbot
+- Deleting anything with chatbot must only be done after another user confirmation
diff --git a/doc/sprint4/schedule.pdf b/doc/sprint4/schedule.pdf
new file mode 100644
index 00000000..1983023d
Binary files /dev/null and b/doc/sprint4/schedule.pdf differ
diff --git a/doc/sprint4/sprint-04.review.md b/doc/sprint4/sprint-04.review.md
new file mode 100644
index 00000000..35cd651a
--- /dev/null
+++ b/doc/sprint4/sprint-04.review.md
@@ -0,0 +1,101 @@
+# Course Matrix/term-group-project-c01w25-project-course-matrix
+
+## Iteration 04 - Review & Retrospect
+
+When: 4/04/2025 at 9:00 pm
+
+Where: Online
+
+## Process - Reflection
+
+In Sprint 4, our team focused on finishing up any trailing features and then refining our application so that it has as few bugs as possible. Additionally, we refined our UI and added additional tests to resolve any potential bugs.
+Our team successfully generated and implemented the following features:
+
+- Refined timetable operations via AI
+- Timetable compare
+- Timetable share
+- Timetable favourite
+- Additional unit/integration testing our application
+
+By the end of sprint 4 we were able to complete all of our features, with the majority of our time this sprint spent finding and resolving bugs or adding additional unit/integration tests.
+
+Our timetable is now fully functional, now with additional features. Users can now share their timetables with other users using their emails. Additionally, users can favourite and compare their timetables.
+
+Our AI assistant’s functionality has been expanded upon and refined. Now, when sensitive operations are performed by our AI, various safeguards have been added (e.g. when deleting a timetable a further confirmation must be done). Additionally, various queries that could potentially break the chatbot have been patched.
+
+The setup for deploying our application has been completed, with the latest functional version of our application already deployed on google cloud with a CI/CD pipeline. Currently, if a new change is pushed to main and it passes all tests the application is then deployed on our google cloud virtual machine.
+
+In conclusion, during sprint 4 our application has been finished and further refined.
+
+### Decisions that turned out well
+
+1. **Finishing User Stories**
+
+One decision that turned out well for us was finishing as many user stories as possible in the previous sprints. By doing this we were able to focus the majority of our efforts this sprint in refining all our user stories making our application the best possible version of itself. We resolved countless bugs, pushed QOL features, and optimized our application greatly.
+
+2. **Rehearsing our Presentation**
+
+For our sprint 4 presentation, we decided to complete both the slides and the script ahead of time. This allowed us to rehearse our presentation multiple times and refine it to perfection. Due to this our presentation was excellent.
+
+### Decisions that did not turn out as well as we hoped
+
+1. **Leaving Sprint 4 Deliverables for Later**
+
+During sprint 4 we left completing our deliverables for later (e.g. NFR). We thought that focusing on refining our application should come first. This meant that we had to scramble to complete our sprint 4 documentations near the end of the sprint. This led to potential oversights in our documentation.
+
+2. **We didn’t use TDD**
+
+We set up our tests for our application quite late into its development. This meant that almost all of our tests were redundant, with us discovering bugs manually and the tests only being useful in defining our application’s behaviour.
+
+## Product - Review
+
+#### Goals and/or tasks that were met/completed
+
+- Fix text highlight on edit username [SCRUM-131](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-131)
+- Project deployment [SCRUM-130](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-130)
+- Timetable sharing [SCRUM–58](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-58)
+- Timetable favourite [SCRUM-57](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-57)
+- Timetable Compare [SCRUM-62](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-62)
+- Timetable Frontend Enhancements [SCRUM-145](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-145)
+- Fix creating Timetable with same name causes user to be stuck in loading screen [SCRUM-146](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-146)
+- Fix semester button non-functional [SCRUM-147](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-147)
+- Delete confirmation for chatbot [SCRUM-148](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-148)
+- Prevent chatbot from creating more than 1 timetable in a single cmd [SCRUM-149](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-149)
+- Fix timetable generate flow cannot edit manually after generation [SCRUM-150](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-150)
+- Fix timetable generation only generate partially [SCRUM-153](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-153)
+- Fix time strings sent to timetable generate [SCRUM-154](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-154)
+- Timetable generation refinement [SCRUM-155](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-155)
+- Timetable title max char limit [SCRUM-156](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-156)
+- Reading week inclusion for timetable [SCRUM-157](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-157)
+- Fix AI Hallucinating courses [SCRUM-158](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-158)
+- Timetables limit [SCRUM-159](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-159)
+- Fix favourite non functional [SCRUM-161](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-161)
+- Assignment 2 Completion [SCRUM-163](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-163)
+- Hide restriction config for manual flow & prevent modification of restrictions in edit flow [SCRUM-166](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-166)
+- Comparing shared timetables [SCRUM–167](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-167)
+- Add select all button [SCRUM-169](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-169)
+- Clean UserMenu so there are no useless fields [SCRUM-170](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-170)
+- Fix Misc. BUgs in Generation Flow [SCRUM-171](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-171)
+- Image improvements + logo + frontend tweaks [SCRUM-168](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-168)
+- Presentation [SCRUM-172](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-172)
+- Fix Restriction for type toggle persists old values [SCRUM-173](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-173)
+- Deployment Time Zone Hotfix [SCRUM-174](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-174)
+- Refactor constants.ts [SCRUM-177](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-177)
+- Finish auth.test.ts tests [SCRUM-178](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-178)
+- Fix frontend unit test mocking [SCRUM-179](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-179)
+- Add more frontend tests [SCRUM-175](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-175)
+- Backend integration tests [SCRUM-180](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-180)
+- Speed up test execution by running all tests serially in the current process [SCRUM-181](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-181)
+- Add some more frontend integration tests [SCRUM-182](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-182)
+- Organize backend tests into unit and integration tests [SCRUM-183](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-183)
+- Update REAME setup [SCRUM–184](https://cscc01-course-matrix.atlassian.net/browse/SCRUM-184)
+
+#### Goals and/or tasks that were planned but not met/completed
+
+We completed everything and are the best team.
+
+## Meeting Highlights
+
+We have decided to do the following from here on out:
+
+1. Study hard for our CSCC01 final exam.