Release/1.3 [main]

README.md

@@ -61,6 +61,8 @@ The `DATABASE_URL` variable should contain your Supabase project url and the `DA
 
 ```
 VITE_SERVER_URL="http://localhost:8081"
+VITE_PUBLIC_ASSISTANT_BASE_URL=[Insert vite public assistant bas URL]
+VITE_ASSISTANT_UI_KEY=[Insert vite assistant UI key]
 ```
 
 ### Running the Application

course-matrix/backend/__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");
+    });
+  });
+});

course-matrix/backend/__tests__/auth.test.ts

@@ -0,0 +1,81 @@
+import request from "supertest";
+import { describe, expect, it, test } from "@jest/globals";
+import app from "../src/index";
+
+describe("Authentication API", () => {
+  // The unit tests below are currently commented out because they require a database connection.
+  // They will be uncommented out once all the necessary mocks are in place.
+
+  // describe('POST /auth/login', () => {
+  //     it('should return 200 and a token for valid credentials', async () => {
+  //         const response = await request(app)
+  //             .post('/auth/login')
+  //             .send({ username: '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({ username: 'invalidUser', password: 'wrongPassword' });
+  //         expect(response.status).toBe(401);
+  //         expect(response.body).toHaveProperty('error', 'Invalid credentials');
+  //     });
+  //     it('should return 400 if username or password is missing', async () => {
+  //         const response = await request(app)
+  //             .post('/auth/login')
+  //             .send({ username: 'validUser' });
+  //         expect(response.status).toBe(400);
+  //         expect(response.body).toHaveProperty('error', 'Username and password are required');
+  //     });
+  // });
+  // describe('POST /auth/register', () => {
+  //     it('should return 201 and create a new user for valid input', async () => {
+  //         const response = await request(app)
+  //             .post('/auth/register')
+  //             .send({ username: 'newUser', password: 'newPassword' });
+  //         expect(response.status).toBe(201);
+  //         expect(response.body).toHaveProperty('message', 'User registered successfully');
+  //     });
+  //     it('should return 400 if username is already taken', async () => {
+  //         await request(app)
+  //             .post('/auth/register')
+  //             .send({ username: 'existingUser', password: 'password123' });
+  //         const response = await request(app)
+  //             .post('/auth/register')
+  //             .send({ username: 'existingUser', password: 'password123' });
+  //         expect(response.status).toBe(400);
+  //         expect(response.body).toHaveProperty('error', 'Username is already taken');
+  //     });
+  //     it('should return 400 if username or password is missing', async () => {
+  //         const response = await request(app)
+  //             .post('/auth/register')
+  //             .send({ username: '' });
+  //         expect(response.status).toBe(400);
+  //         expect(response.body).toHaveProperty('error', 'Username and password are required');
+  //     });
+  // });
+  // describe('GET /auth/profile', () => {
+  //     it('should return 200 and user profile for valid token', async () => {
+  //         const loginResponse = await request(app)
+  //             .post('/auth/login')
+  //             .send({ username: 'validUser', password: 'validPassword' });
+  //         const token = loginResponse.body.token;
+  //         const response = await request(app)
+  //             .get('/auth/profile')
+  //             .set('Authorization', `Bearer ${token}`);
+  //         expect(response.status).toBe(200);
+  //         expect(response.body).toHaveProperty('username', 'validUser');
+  //     });
+  //     it('should return 401 if token is missing or invalid', async () => {
+  //         const response = await request(app)
+  //             .get('/auth/profile')
+  //             .set('Authorization', 'Bearer invalidToken');
+  //         expect(response.status).toBe(401);
+  //         expect(response.body).toHaveProperty('error', 'Unauthorized');
+  //     });
+  // });
+  it("template test", () => {
+    expect(2 + 3).toEqual(5);
+  });
+});

course-matrix/backend/__tests__/canInsert.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it, test } from "@jest/globals";
+
+import { createOffering, canInsert } from "../src/utils/generatorHelpers";
+import { Offering } from "../src/types/generatorTypes";
+
+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
+  });
+});