@studious-lms/server 1.4.9 → 1.6.0

package/tests/{pipelines → integration/pipelines}/pdfToWorksheet.test.ts

@@ -1,18 +1,19 @@
 /**
- * `pdfToWorksheet` integration-style tests: real DB, mocked inference.
- * CI does not call the model, and the PDF URL is passed through directly.
+ * `pdfToWorksheet` integration-style tests: real DB, mocked OpenAI.
+ *
+ * We intercept the `responses.parse` method on the shared openAIClient
+ * instance instead of `vi.mock`ing the inference module: setupFiles loads
+ * the inference module (via appRouter) before any test file's vi.mock can
+ * register, so module mocks don't intercept those cached imports.
  */
 import { describe, test, expect, vi, beforeAll, beforeEach, afterEach } from "vitest";
 import { user1Caller } from "../setup";
-import { prisma } from "../../src/lib/prisma";
-import { logger } from "../../src/utils/logger";
+import { prisma } from "../../../src/lib/prisma";
+import { logger } from "../../../src/utils/logger";
+import { openAIClient } from "../../../src/utils/inference.js";
+import { pdfToWorksheet } from "../../../src/pipelines/pdfToWorksheet.js";
 
-vi.mock("../../src/utils/inference.js", () => ({
-  inference: vi.fn(),
-}));
-
-import { inference } from "../../src/utils/inference.js";
-import { pdfToWorksheet } from "../../src/pipelines/pdfToWorksheet.js";
+const mockedResponsesParse = vi.spyOn(openAIClient.responses, "parse");
 
 /** Same PDF path represented as a signed Google Cloud Storage URL. */
 export const CONV_TEST_PDF_GCS_URL =
@@ -68,7 +69,7 @@ describe("pdfToWorksheet", () => {
   });
 
   beforeEach(() => {
-    vi.mocked(inference).mockReset();
+    mockedResponsesParse.mockReset();
   });
 
   afterEach(async () => {
@@ -79,7 +80,7 @@ describe("pdfToWorksheet", () => {
 
   test("passes the PDF URL directly to inference and persists a worksheet with 8 questions", async () => {
     const draft = draftWithEightQuestions();
-    vi.mocked(inference).mockResolvedValue(draft);
+    mockedResponsesParse.mockResolvedValue({ output_parsed: draft } as any);
 
     const worksheet = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
     expect(worksheet).not.toBeNull();
@@ -87,6 +88,9 @@ describe("pdfToWorksheet", () => {
 
     expect(worksheet!.name).toBe(draft.title);
     expect(worksheet!.classId).toBe(classId);
+    expect(worksheet!.sourceUrl).toBe(
+      "https://storage.googleapis.com/studious-test-bucket/worksheets/conv-test.pdf"
+    );
 
     const questions = await prisma.worksheetQuestion.findMany({
       where: { worksheetId: worksheet!.id },
@@ -99,27 +103,17 @@ describe("pdfToWorksheet", () => {
     expect(questions.map((q) => q.order)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
     expect(questions.map((q) => q.points)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
 
-    expect(inference).toHaveBeenCalledTimes(1);
-    const input = vi.mocked(inference).mock.calls[0][0];
-    expect(Array.isArray(input)).toBe(true);
+    expect(mockedResponsesParse).toHaveBeenCalledTimes(1);
+    const callArgs = mockedResponsesParse.mock.calls[0][0] as { input: unknown };
     type InputPart = { type?: string; file_url?: string; text?: string };
-    const content = (input as { role: string; content: InputPart[] }[])[0].content;
+    const input = callArgs.input as { role: string; content: InputPart[] }[];
+    expect(Array.isArray(input)).toBe(true);
+    const content = input[0].content;
     const filePart = content.find((p) => p.type === "input_file");
     expect(filePart).toEqual({
       type: "input_file",
       file_url: CONV_TEST_PDF_GCS_URL,
     });
-    expect(vi.mocked(inference)).toHaveBeenCalledWith(
-      expect.any(Array),
-      expect.anything(),
-      expect.objectContaining({
-        reason: "pdf_to_worksheet_draft",
-        metadata: expect.objectContaining({
-          classId,
-          filename: "conv-test.pdf",
-        }),
-      })
-    );
   });
 
   test("rejects non-Google Cloud URLs and only logs a sanitized path", async () => {
@@ -133,23 +127,25 @@ describe("pdfToWorksheet", () => {
       "pdfToWorksheet: rejected unsupported PDF URL",
       { sanitizedUrl: "https://drive.google.com/file/d/1BfotteM60Ax0krHzE6rFN1Df8S8kT3kb/view" }
     );
-    expect(inference).not.toHaveBeenCalled();
+    expect(mockedResponsesParse).not.toHaveBeenCalled();
     warnSpy.mockRestore();
   });
 
   test("rounds persisted integer fields from model output", async () => {
-    vi.mocked(inference).mockResolvedValue({
-      title: "Rounded worksheet",
-      questions: [{
-        type: "SHORT_ANSWER",
-        question: "Rounded question",
-        answer: "Rounded answer",
-        options: [],
-        markScheme: [{ id: "step-1", points: 0.6, description: "Half step" }],
-        points: 1.7,
-        order: 1.2,
-      }],
-    } as Awaited<ReturnType<typeof inference>>);
+    mockedResponsesParse.mockResolvedValue({
+      output_parsed: {
+        title: "Rounded worksheet",
+        questions: [{
+          type: "SHORT_ANSWER",
+          question: "Rounded question",
+          answer: "Rounded answer",
+          options: [],
+          markScheme: [{ id: "step-1", points: 0.6, description: "Half step" }],
+          points: 1.7,
+          order: 1.2,
+        }],
+      },
+    } as any);
 
     const worksheet = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
     expect(worksheet).not.toBeNull();
@@ -165,12 +161,28 @@ describe("pdfToWorksheet", () => {
   });
 
   test("returns null when inference yields no parsed output", async () => {
-    vi.mocked(inference).mockResolvedValue(
-      null as unknown as Awaited<ReturnType<typeof inference>>
-    );
+    mockedResponsesParse.mockResolvedValue({ output_parsed: null } as any);
 
     const out = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
     expect(out).toBeNull();
   });
 
+  test("reuses an existing worksheet for the same PDF source", async () => {
+    mockedResponsesParse.mockResolvedValue({
+      output_parsed: draftWithEightQuestions("Idempotent worksheet"),
+    } as any);
+
+    const first = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
+    expect(first).not.toBeNull();
+    createdWorksheetIds.push(first!.id);
+
+    const second = await pdfToWorksheet(
+      "https://storage.googleapis.com/studious-test-bucket/worksheets/conv-test.pdf?X-Goog-Signature=retry-signature",
+      classId
+    );
+
+    expect(second?.id).toBe(first!.id);
+    expect(mockedResponsesParse).toHaveBeenCalledTimes(1);
+  });
+
 });

package/tests/{routers → integration/routers}/attendance.test.ts

@@ -1,7 +1,7 @@
 import { test, expect, describe, beforeEach } from 'vitest';
 import { user1Caller, user2Caller } from '../setup';
 import { expectUnauth } from '../helpers';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 
 describe('Attendance Router', () => {
   let testClass: any;
@@ -117,6 +117,66 @@ describe('Attendance Router', () => {
       expect(updatedRecord?.late.some((l: any) => l.id === student2.id)).toBe(true);
     });
 
+    test('should notify students newly marked late or absent', async () => {
+      await prisma.notification.deleteMany({
+        where: { receiverId: student2.id },
+      });
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [{ id: student2.id, username: student2.username }],
+          absent: [],
+        },
+      });
+
+      let notifications = await user2Caller.notification.list();
+      expect(
+        notifications.some(
+          (notification: any) =>
+            notification.title === `Marked late in ${testClass.name}` &&
+            notification.content.includes(testEvent.event.name) &&
+            notification.content.includes(`/class/${testClass.id}/attendance/${testEvent.event.id}`)
+        )
+      ).toBe(true);
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [{ id: student2.id, username: student2.username }],
+          absent: [],
+        },
+      });
+
+      notifications = await user2Caller.notification.list();
+      expect(
+        notifications.filter(
+          (notification: any) => notification.title === `Marked late in ${testClass.name}`
+        )
+      ).toHaveLength(1);
+
+      await user1Caller.attendance.update({
+        classId: testClass.id,
+        eventId: testEvent.event.id,
+        attendance: {
+          present: [{ id: student1.id, username: student1.username }],
+          late: [],
+          absent: [{ id: student2.id, username: student2.username }],
+        },
+      });
+
+      notifications = await user2Caller.notification.list();
+      expect(
+        notifications.some(
+          (notification: any) => notification.title === `Marked absent in ${testClass.name}`
+        )
+      ).toBe(true);
+    });
+
     test('should update attendance without event', async () => {
       const result = await user1Caller.attendance.update({
         classId: testClass.id,
@@ -157,4 +217,3 @@ describe('Attendance Router', () => {
       })));
   });
 });
-

package/tests/{routers → integration/routers}/auth.test.ts

@@ -3,9 +3,9 @@
 import { randomUUID } from 'crypto';
 import { SessionType } from '@prisma/client';
 import { test, expect, describe } from 'vitest';
-import { appRouter } from '../../src/routers/_app';
-import { createTRPCContext } from '../../src/trpc';
-import { prisma } from '../../src/lib/prisma';
+import { appRouter } from '../../../src/routers/_app';
+import { createTRPCContext } from '../../../src/trpc';
+import { prisma } from '../../../src/lib/prisma';
 import {
   caller,
   login1,

package/tests/{routers → integration/routers}/class.test.ts

@@ -1,10 +1,10 @@
 import { test, expect, describe, beforeEach, afterEach, vi } from 'vitest';
 import { expectForbidden, expectRejects, expectUnauth } from '../helpers';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 import { caller, user1Caller, user2Caller, user3Caller } from '../setup';
 
-vi.mock('../../src/lib/googleCloudStorage.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../src/lib/googleCloudStorage.js')>();
+vi.mock('../../../src/lib/googleCloudStorage.js', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../../src/lib/googleCloudStorage.js')>();
   return {
     ...actual,
     copyFile: vi.fn().mockResolvedValue(undefined),
@@ -340,19 +340,5 @@ describe('Class Router', () => {
       expect(rootFolder.name).toBe('Class Files');
     });
 
-
-    test('non-teacher cannot import class', async () => {
-      await user1Caller.folder.getRootFolder({ classId: testClass.id });
-      const exported = await user1Caller.class.exportClass({ classId: testClass.id });
-      const newClassId = `import-forbidden-${Date.now()}`;
-
-      await expect(
-        user3Caller.class.importClass({
-          classId: newClassId,
-          year: new Date().getFullYear(),
-          classData: exported,
-        })
-      ).rejects.toThrow();
-    });
   });
 }); 

package/tests/{routers → integration/routers}/conversation.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe, beforeAll } from 'vitest';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectUnauth } from '../helpers';
 

package/tests/{routers → integration/routers}/event.test.ts

@@ -1,7 +1,7 @@
 import { test, expect, describe, beforeEach } from 'vitest';
 import { user1Caller, user2Caller } from '../setup';
 import { expectRejects, expectUnauth } from '../helpers';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 import { startOfWeek } from 'date-fns';
 
 describe('Event Router', () => {

package/tests/{routers → integration/routers}/message.test.ts

@@ -1,6 +1,6 @@
 import { test, expect, describe, beforeAll } from 'vitest';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 
 const expectTRPCError = async (promise: Promise<unknown>, code: string) => {
   await expect(promise).rejects.toMatchObject({ code });

package/tests/{routers → integration/routers}/newtonChat.test.ts

@@ -1,5 +1,5 @@
 import { beforeAll, describe, expect, test } from 'vitest';
-import { prisma } from '../../src/lib/prisma';
+import { prisma } from '../../../src/lib/prisma';
 import { user1Caller, user2Caller } from '../setup';
 
 describe('Newton Chat Router', () => {

package/tests/{routers → integration/routers}/studentProgress.test.ts

@@ -1,5 +1,5 @@
 import { test, expect, describe, beforeEach, vi } from "vitest";
-import { openAIClient } from "../../src/utils/inference.js";
+import { openAIClient } from "../../../src/utils/inference.js";
 import { user1Caller, user2Caller, user3Caller } from "../setup";
 
 const mockedCompletionCreate = vi.spyOn(

package/tests/{user.test.ts → integration/routers/user.test.ts}

@@ -1,6 +1,6 @@
 import { test, expect, describe, beforeEach } from 'vitest';
-import { user1Caller, user2Caller } from './setup';
-import { expectUnauth } from './helpers';
+import { user1Caller, user2Caller } from '../setup';
+import { expectUnauth } from '../helpers';
 
 describe('User Router', () => {
   describe('getProfile', () => {