@studious-lms/server 1.4.3 → 1.4.5

package/tests/pipelines/pdfToWorksheet.test.ts

@@ -0,0 +1,176 @@
+/**
+ * `pdfToWorksheet` integration-style tests: real DB, mocked inference.
+ * CI does not call the model, and the PDF URL is passed through directly.
+ */
+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";
+
+vi.mock("../../src/utils/inference.js", () => ({
+  inference: vi.fn(),
+}));
+
+import { inference } from "../../src/utils/inference.js";
+import { pdfToWorksheet } from "../../src/pipelines/pdfToWorksheet.js";
+
+/** Same PDF path represented as a signed Google Cloud Storage URL. */
+export const CONV_TEST_PDF_GCS_URL =
+  "https://storage.googleapis.com/studious-test-bucket/worksheets/conv-test.pdf?X-Goog-Algorithm=GOOG4-RSA-SHA256&X-Goog-Signature=test-signature";
+
+export const NON_GCS_PDF_URL =
+  "https://drive.google.com/file/d/1BfotteM60Ax0krHzE6rFN1Df8S8kT3kb/view?usp=drive_link";
+
+/** Mirrors the 8-question conv-test worksheet shape the model is expected to return. */
+function draftWithEightQuestions(title = "Conv test worksheet") {
+  const types = [
+    "SHORT_ANSWER",
+    "MULTIPLE_CHOICE",
+    "TRUE_FALSE",
+    "SHORT_ANSWER",
+    "LONG_ANSWER",
+    "MATH_EXPRESSION",
+    "ESSAY",
+    "SHORT_ANSWER",
+  ] as const;
+
+  return {
+    title,
+    questions: types.map((type, i) => ({
+      type,
+      question: `Question ${i + 1}`,
+      answer: `Answer ${i + 1}`,
+      options:
+        type === "MULTIPLE_CHOICE"
+          ? [
+              { id: "a", text: "Wrong", isCorrect: false },
+              { id: "b", text: "Right", isCorrect: true },
+            ]
+          : [],
+      markScheme: [] as { id: string; points: number; description: string }[],
+      points: i + 1,
+      order: i + 1,
+    })),
+  };
+}
+
+describe("pdfToWorksheet", () => {
+  let classId: string;
+  const createdWorksheetIds: string[] = [];
+
+  beforeAll(async () => {
+    const cls = await user1Caller.class.create({
+      name: "pdfToWorksheet pipeline class",
+      subject: "Science",
+      section: "Test",
+    });
+    classId = cls.id;
+  });
+
+  beforeEach(() => {
+    vi.mocked(inference).mockReset();
+  });
+
+  afterEach(async () => {
+    for (const id of createdWorksheetIds.splice(0)) {
+      await prisma.worksheet.delete({ where: { id } }).catch(() => undefined);
+    }
+  });
+
+  test("passes the PDF URL directly to inference and persists a worksheet with 8 questions", async () => {
+    const draft = draftWithEightQuestions();
+    vi.mocked(inference).mockResolvedValue(draft);
+
+    const worksheet = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
+    expect(worksheet).not.toBeNull();
+    createdWorksheetIds.push(worksheet!.id);
+
+    expect(worksheet!.name).toBe(draft.title);
+    expect(worksheet!.classId).toBe(classId);
+
+    const questions = await prisma.worksheetQuestion.findMany({
+      where: { worksheetId: worksheet!.id },
+      orderBy: { order: "asc" },
+    });
+    expect(questions).toHaveLength(8);
+    expect(questions.map((q) => q.question)).toEqual(
+      draft.questions.map((q) => q.question)
+    );
+    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);
+    type InputPart = { type?: string; file_url?: string; text?: string };
+    const content = (input as { role: string; content: InputPart[] }[])[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 () => {
+    const warnSpy = vi.spyOn(logger, "warn").mockImplementation(() => undefined);
+
+    await expect(pdfToWorksheet(NON_GCS_PDF_URL, classId)).rejects.toThrow(
+      "Only Google Cloud Storage URLs are supported"
+    );
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      "pdfToWorksheet: rejected unsupported PDF URL",
+      { sanitizedUrl: "https://drive.google.com/file/d/1BfotteM60Ax0krHzE6rFN1Df8S8kT3kb/view" }
+    );
+    expect(inference).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>>);
+
+    const worksheet = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
+    expect(worksheet).not.toBeNull();
+    createdWorksheetIds.push(worksheet!.id);
+
+    const [question] = await prisma.worksheetQuestion.findMany({
+      where: { worksheetId: worksheet!.id },
+    });
+
+    expect(question.points).toBe(2);
+    expect(question.order).toBe(1);
+    expect(question.markScheme).toEqual([{ id: "step-1", points: 1, description: "Half step" }]);
+  });
+
+  test("returns null when inference yields no parsed output", async () => {
+    vi.mocked(inference).mockResolvedValue(
+      null as unknown as Awaited<ReturnType<typeof inference>>
+    );
+
+    const out = await pdfToWorksheet(CONV_TEST_PDF_GCS_URL, classId);
+    expect(out).toBeNull();
+  });
+
+});

package/tests/routers/conversation.test.ts

@@ -1,17 +1,35 @@
 import { test, expect, describe, beforeAll } from 'vitest';
+import { prisma } from '../../src/lib/prisma';
 import { user1Caller, user2Caller, user3Caller } from '../setup';
 import { expectUnauth } from '../helpers';
 
 describe('Conversation Router', () => {
   let dmConversation: any;
   let groupConversation: any;
+  let user1Id: string;
   let user3Id: string;
+  let hideConversationCounter = 0;
 
   beforeAll(async () => {
-    const profile = await user3Caller.user.getProfile();
-    user3Id = profile.id;
+    const [user1Profile, user3Profile] = await Promise.all([
+      user1Caller.user.getProfile(),
+      user3Caller.user.getProfile(),
+    ]);
+
+    user1Id = user1Profile.id;
+    user3Id = user3Profile.id;
   });
 
+  async function createHideableConversation() {
+    hideConversationCounter += 1;
+
+    return user1Caller.conversation.create({
+      type: 'GROUP',
+      name: `Hide Test Group Chat ${hideConversationCounter}`,
+      memberIds: ['testuser2'],
+    });
+  }
+
   describe('create', () => {
     test('should create a DM conversation', async () => {
       dmConversation = await user1Caller.conversation.create({
@@ -36,6 +54,13 @@ describe('Conversation Router', () => {
       expect(groupConversation.name).toBe('Test Group Chat');
     });
 
+    test('should create a hideable GROUP conversation', async () => {
+      const conversation = await createHideableConversation();
+
+      expect(conversation).toBeDefined();
+      expect(conversation.type).toBe('GROUP');
+    });
+
     test('should fail to create duplicate DM', async () => {
       await expect(
         user1Caller.conversation.create({
@@ -125,6 +150,93 @@ describe('Conversation Router', () => {
     });
   });
 
+  describe('hide', () => {
+    test('should hide a conversation only for the requesting member', async () => {
+      const conversation = await createHideableConversation();
+
+      const result = await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      expect(result).toEqual({ success: true });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).not.toBeNull();
+
+      const user1Conversations = await user1Caller.conversation.list();
+      const user2Conversations = await user2Caller.conversation.list();
+
+      expect(user1Conversations.map((item) => item.id)).not.toContain(
+        conversation.id,
+      );
+      expect(user2Conversations.map((item) => item.id)).toContain(
+        conversation.id,
+      );
+    });
+
+    test('should keep hidden conversations accessible by id', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      const hiddenConversation = await user1Caller.conversation.get({
+        conversationId: conversation.id,
+      });
+
+      expect(hiddenConversation.id).toBe(conversation.id);
+    });
+
+    test('should unhide a hidden conversation after new activity', async () => {
+      const conversation = await createHideableConversation();
+
+      await user1Caller.conversation.hide({
+        conversationId: conversation.id,
+      });
+
+      await user2Caller.message.send({
+        conversationId: conversation.id,
+        content: 'Bringing this conversation back',
+      });
+
+      const membership = await prisma.conversationMember.findUniqueOrThrow({
+        where: {
+          userId_conversationId: {
+            userId: user1Id,
+            conversationId: conversation.id,
+          },
+        },
+        select: { hiddenAt: true },
+      });
+
+      expect(membership.hiddenAt).toBeNull();
+
+      const conversations = await user1Caller.conversation.list();
+
+      expect(conversations.map((item) => item.id)).toContain(conversation.id);
+    });
+
+    test('should fail for non-members', async () => {
+      const conversation = await createHideableConversation();
+
+      await expect(
+        user3Caller.conversation.hide({
+          conversationId: conversation.id,
+        }),
+      ).rejects.toThrow('Not a member of this conversation');
+    });
+  });
+
   describe('removeMember', () => {
     test('should remove member from conversation', async () => {
       await user1Caller.conversation.removeMember({

package/tests/routers/search.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test, beforeAll } from "vitest";
+import { expectUnauth } from "../helpers";
+import { user1Caller, user2Caller, user3Caller } from "../setup";
+
+describe("Search Router", () => {
+  let testClass: any;
+  let assignment: any;
+  let event: any;
+  let worksheet: any;
+
+  beforeAll(async () => {
+    testClass = await user1Caller.class.create({
+      name: "Global Search Biology",
+      subject: "Biology",
+      section: "STU-65",
+    });
+
+    await user1Caller.class.addStudent({
+      classId: testClass.id,
+      studentId: (await user2Caller.user.getProfile()).id,
+    });
+
+    await user1Caller.class.updateSyllabus({
+      classId: testClass.id,
+      contents: "Photosynthesis lab policies and chlorophyll grading overview.",
+    });
+
+    assignment = await user1Caller.assignment.create({
+      classId: testClass.id,
+      title: "Chlorophyll Response",
+      instructions: "Explain the photosynthesis command palette experiment.",
+      dueDate: new Date(Date.now() + 86400000).toISOString(),
+      type: "HOMEWORK",
+    });
+
+    event = await user1Caller.event.create({
+      classId: testClass.id,
+      name: "Photosynthesis Attendance Lab",
+      location: "Room 65",
+      startTime: new Date(Date.now() + 3600000).toISOString(),
+      endTime: new Date(Date.now() + 7200000).toISOString(),
+    });
+
+    worksheet = await user1Caller.worksheet.create({
+      classId: testClass.id,
+      name: "Chloroplast Worksheet",
+    });
+  });
+
+  test("returns matching class resources for a teacher", async () => {
+    const results = await user1Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.query).toBe("photosynthesis");
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "assignment",
+          id: assignment.id,
+          href: `/class/${testClass.id}/assignment/${assignment.id}`,
+        }),
+        expect.objectContaining({
+          type: "event",
+          id: event.event.id,
+          href: `/class/${testClass.id}/attendance/${event.event.id}`,
+        }),
+        expect.objectContaining({
+          type: "syllabus",
+          href: `/class/${testClass.id}/syllabus`,
+        }),
+      ])
+    );
+  });
+
+  test("returns visible class resources for an enrolled student", async () => {
+    const results = await user2Caller.search.global({
+      query: "chloroplast",
+      limit: 20,
+    });
+
+    expect(results.results).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: "worksheet",
+          id: worksheet.id,
+          href: `/class/${testClass.id}/worksheets`,
+        }),
+      ])
+    );
+  });
+
+  test("does not expose resources to non-members", async () => {
+    const results = await user3Caller.search.global({
+      query: "photosynthesis",
+      limit: 20,
+    });
+
+    expect(results.results).not.toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ classId: testClass.id }),
+      ])
+    );
+  });
+
+  test("fails without authentication", () =>
+    expectUnauth((c) => c.search.global({ query: "biology" })));
+});

package/tests/utils/inference.test.ts

@@ -186,6 +186,43 @@ describe('inference', () => {
         metadata: { worksheetResponseId: 'response-1' },
       }),
     });
+    expect(responseParseMock).toHaveBeenCalledWith({
+      model: 'gpt-5-nano',
+      input: [{
+        role: 'user',
+        content: [{ type: 'input_text', text: 'Grade this' }],
+      }],
+      text: {
+        format: expect.any(Object),
+      },
+    });
+  });
+
+  test('rejects ResponseInput content with input parts when format is missing', async () => {
+    await expect(
+      inference<string>([
+        {
+          role: 'user',
+          content: [
+            { type: 'input_text', text: 'Read this PDF' },
+            { type: 'input_file', file_url: 'https://storage.googleapis.com/bucket/file.pdf' },
+          ],
+        },
+      ] as any, undefined, {
+        reason: 'pdf_without_format',
+      }),
+    ).rejects.toThrow(
+      'normalizeInferenceInput cannot handle ResponseInput content with input_* parts when format is undefined; pass a format to use responses.parse.',
+    );
+
+    expect(chatCreateMock).not.toHaveBeenCalled();
+    expect(prismaMocks.aiUsageLog.create).toHaveBeenCalledWith({
+      data: expect.objectContaining({
+        reason: 'pdf_without_format',
+        operation: 'chat.completions',
+        success: false,
+      }),
+    });
   });
 
   test('logs failed attempts before rethrowing', async () => {