@studious-lms/server 1.4.9 → 1.6.0

package/vitest.unit.config.ts

@@ -6,23 +6,23 @@ import { resolve } from 'path';
 config({ path: resolve(process.cwd(), '.env.test'), override: true });
 
 /**
- * Unit test config - no DB, no globalSetup.
- * Use: npm run test:unit
+ * Unit test config — no DB, no globalSetup, no shared tRPC callers.
+ * Files here mock every external boundary (prisma, openai, pusher, etc.).
+ *
+ * Vitest's default already parallelises across files via workers; tests
+ * within a single file run serially because many use shared `vi.hoisted`
+ * mocks or console spies that would race under in-file concurrency.
+ *
+ * Use: npm run test:unit.
  */
 export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    include: [
-      'tests/utils/**/*.test.ts',
-      'tests/server/**/*.test.ts',
-      'tests/middleware/**/*.test.ts',
-      'tests/lib/**/*.test.ts',
-      'tests/pipelines/**/*.test.ts',
-      'tests/routers/**/*.test.ts',
-    ],
+    include: ['tests/unit/**/*.test.ts'],
     env: {
       NODE_ENV: 'test',
+      OPENAI_API_KEY: 'test-openai-key',
     },
   },
 });

package/tests/routers/worksheet.test.ts

@@ -1,194 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import { user1Caller, user2Caller, user3Caller } from "../setup";
-
-const expectTRPCError = async (promise: Promise<unknown>, code: string) => {
-  await expect(promise).rejects.toMatchObject({ code });
-};
-
-describe("Worksheet Router Security", () => {
-  let testClass: any;
-  let worksheet: any;
-  let question: any;
-  let multipleChoiceQuestion: any;
-  let submission: any;
-  let worksheetResponse: any;
-  let progressId: string;
-
-  beforeEach(async () => {
-    testClass = await user1Caller.class.create({
-      name: `Worksheet Security ${Date.now()}`,
-      subject: "Physics",
-      section: "12th Grade",
-    });
-
-    const user2Profile = await user2Caller.user.getProfile();
-    await user1Caller.class.addStudent({
-      classId: testClass.id,
-      studentId: user2Profile.id,
-    });
-
-    worksheet = await user1Caller.worksheet.create({
-      classId: testClass.id,
-      name: "Security Worksheet",
-    });
-
-    question = await user1Caller.worksheet.addQuestion({
-      worksheetId: worksheet.id,
-      question: "What is force?",
-      answer: "Mass times acceleration",
-      points: 5,
-      type: "SHORT_ANSWER",
-    });
-
-    multipleChoiceQuestion = await user1Caller.worksheet.addQuestion({
-      worksheetId: worksheet.id,
-      question: "What is the SI unit of force?",
-      answer: "newton",
-      points: 1,
-      type: "MULTIPLE_CHOICE",
-      options: [
-        { id: "a", text: "Joule", isCorrect: false },
-        { id: "b", text: "Newton", isCorrect: true },
-      ],
-    });
-
-    const dueDate = new Date();
-    dueDate.setDate(dueDate.getDate() + 7);
-
-    const assignment = await user1Caller.assignment.create({
-      classId: testClass.id,
-      title: "Worksheet Assignment",
-      instructions: "Complete the worksheet.",
-      dueDate: dueDate.toISOString(),
-      acceptWorksheet: true,
-      gradeWithAI: true,
-      worksheetIds: [worksheet.id],
-      type: "HOMEWORK",
-    });
-
-    submission = await user2Caller.assignment.getSubmission({
-      classId: testClass.id,
-      assignmentId: assignment.id,
-    });
-
-    worksheetResponse = await user2Caller.worksheet.getWorksheetSubmission({
-      worksheetId: worksheet.id,
-      submissionId: submission.id,
-    });
-
-    const answered = await user2Caller.worksheet.answerQuestion({
-      worksheetResponseId: worksheetResponse.id,
-      questionId: question.id,
-      response: "Mass times acceleration",
-    });
-
-    progressId = answered.responses[0].id;
-  });
-
-  test("redacts worksheet answers and correctness metadata for students", async () => {
-    const studentWorksheet = await user2Caller.worksheet.getWorksheet({
-      worksheetId: worksheet.id,
-    });
-
-    const shortAnswerQuestion = studentWorksheet.questions.find(
-      (item: any) => item.id === question.id,
-    );
-    expect(shortAnswerQuestion.answer).toBe("");
-    expect(shortAnswerQuestion.markScheme).toBeNull();
-
-    const studentMcq = studentWorksheet.questions.find(
-      (item: any) => item.id === multipleChoiceQuestion.id,
-    );
-    expect(studentMcq.answer).toBe("");
-    expect(studentMcq.options).toEqual([
-      { id: "a", text: "Joule" },
-      { id: "b", text: "Newton" },
-    ]);
-  });
-
-  test("blocks cross-class worksheet reads by id", async () => {
-    await expectTRPCError(
-      user3Caller.worksheet.getWorksheet({ worksheetId: worksheet.id }),
-      "FORBIDDEN",
-    );
-  });
-
-  test("blocks cross-class worksheet submission reads by id", async () => {
-    await expectTRPCError(
-      user3Caller.worksheet.getWorksheetSubmission({
-        worksheetId: worksheet.id,
-        submissionId: submission.id,
-      }),
-      "FORBIDDEN",
-    );
-  });
-
-  test("blocks cross-class worksheet answer mutations", async () => {
-    await expectTRPCError(
-      user3Caller.worksheet.answerQuestion({
-        worksheetResponseId: worksheetResponse.id,
-        questionId: question.id,
-        response: "Unauthorized answer",
-      }),
-      "FORBIDDEN",
-    );
-  });
-
-  test("blocks students from teacher worksheet mutations", async () => {
-    await expectTRPCError(
-      user2Caller.worksheet.updateWorksheet({
-        worksheetId: worksheet.id,
-        name: "Student update",
-      }),
-      "FORBIDDEN",
-    );
-
-    await expectTRPCError(
-      user2Caller.worksheet.addQuestion({
-        worksheetId: worksheet.id,
-        question: "Student-created question",
-        answer: "Nope",
-        type: "SHORT_ANSWER",
-      }),
-      "FORBIDDEN",
-    );
-  });
-
-  test("blocks students from grading and feedback actions", async () => {
-    await expectTRPCError(
-      user2Caller.worksheet.gradeAnswer({
-        questionId: question.id,
-        responseId: progressId,
-        studentWorksheetResponseId: worksheetResponse.id,
-        isCorrect: true,
-        feedback: "Nice work",
-        points: 5,
-      }),
-      "FORBIDDEN",
-    );
-
-    await expectTRPCError(
-      user2Caller.worksheet.addComment({
-        responseId: progressId,
-        comment: "Teacher feedback",
-      }),
-      "FORBIDDEN",
-    );
-
-    await expectTRPCError(
-      user2Caller.worksheet.cancelGrading({
-        worksheetResponseId: worksheetResponse.id,
-        progressId,
-      }),
-      "FORBIDDEN",
-    );
-
-    await expectTRPCError(
-      user2Caller.worksheet.regradeQuestion({
-        worksheetResponseId: worksheetResponse.id,
-        progressId,
-      }),
-      "FORBIDDEN",
-    );
-  });
-});

package/tests/startup.test.ts

@@ -1,5 +0,0 @@
-import { expect, test } from "vitest";
-
-test('setup works', () => {
-    expect(1).toBe(1);
-});

package/tests/worksheet.test.ts

@@ -1,181 +0,0 @@
-import { test, expect, describe, beforeAll } from 'vitest';
-import { user1Caller } from './setup';
-
-describe('Worksheet Router', () => {
-  let testClass: any;
-  let worksheetId: string;
-  let questionId: string;
-  let secondQuestionId: string;
-
-  beforeAll(async () => {
-    testClass = await user1Caller.class.create({
-      name: 'Worksheet Test Class',
-      subject: 'Physics',
-      section: '12th Grade',
-    });
-  });
-
-  describe('create', () => {
-    test('should create a worksheet', async () => {
-      const worksheet = await user1Caller.worksheet.create({
-        classId: testClass.id,
-        name: 'Chapter 1 Quiz',
-      });
-
-      expect(worksheet).toBeDefined();
-      expect(worksheet.name).toBe('Chapter 1 Quiz');
-      expect(worksheet.classId).toBe(testClass.id);
-      worksheetId = worksheet.id;
-    });
-  });
-
-  describe('listWorksheets', () => {
-    test('should list worksheets for a class', async () => {
-      const worksheets = await user1Caller.worksheet.listWorksheets({
-        classId: testClass.id,
-      });
-
-      expect(Array.isArray(worksheets)).toBe(true);
-      expect(worksheets.length).toBeGreaterThanOrEqual(1);
-      expect(worksheets.some((w) => w.id === worksheetId)).toBe(true);
-    });
-  });
-
-  describe('getWorksheet', () => {
-    test('should get a worksheet by ID', async () => {
-      const worksheet = await user1Caller.worksheet.getWorksheet({
-        worksheetId,
-      });
-
-      expect(worksheet).toBeDefined();
-      expect(worksheet.id).toBe(worksheetId);
-      expect(worksheet.name).toBe('Chapter 1 Quiz');
-    });
-
-    test('should fail for non-existent worksheet', async () => {
-      await expect(
-        user1Caller.worksheet.getWorksheet({ worksheetId: 'nonexistent' }),
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('updateWorksheet', () => {
-    test('should update worksheet name', async () => {
-      const updated = await user1Caller.worksheet.updateWorksheet({
-        worksheetId,
-        name: 'Chapter 1 Test',
-      });
-
-      expect(updated.name).toBe('Chapter 1 Test');
-    });
-  });
-
-  describe('addQuestion', () => {
-    test('should add a short answer question', async () => {
-      const question = await user1Caller.worksheet.addQuestion({
-        worksheetId,
-        question: 'What is Newton\'s second law?',
-        answer: 'F = ma',
-        points: 5,
-        type: 'SHORT_ANSWER',
-      });
-
-      expect(question).toBeDefined();
-      expect(question.question).toBe('What is Newton\'s second law?');
-      expect(question.answer).toBe('F = ma');
-      expect(question.points).toBe(5);
-      questionId = question.id;
-    });
-
-    test('should add a multiple choice question', async () => {
-      const question = await user1Caller.worksheet.addQuestion({
-        worksheetId,
-        question: 'What is the SI unit of force?',
-        answer: 'Newton',
-        points: 3,
-        type: 'MULTIPLE_CHOICE',
-        options: [
-          { id: 'a', text: 'Joule', isCorrect: false },
-          { id: 'b', text: 'Newton', isCorrect: true },
-          { id: 'c', text: 'Watt', isCorrect: false },
-          { id: 'd', text: 'Pascal', isCorrect: false },
-        ],
-      });
-
-      expect(question).toBeDefined();
-      expect(question.type).toBe('MULTIPLE_CHOICE');
-      secondQuestionId = question.id;
-    });
-
-    test('should fail for non-existent worksheet', async () => {
-      await expect(
-        user1Caller.worksheet.addQuestion({
-          worksheetId: 'nonexistent',
-          question: 'Test',
-          answer: 'Test',
-          type: 'SHORT_ANSWER',
-        }),
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('updateQuestion', () => {
-    test('should update a question', async () => {
-      const updated = await user1Caller.worksheet.updateQuestion({
-        worksheetId,
-        questionId,
-        question: 'State Newton\'s second law of motion.',
-        points: 10,
-      });
-
-      expect(updated.question).toBe('State Newton\'s second law of motion.');
-      expect(updated.points).toBe(10);
-    });
-  });
-
-  describe('reorderQuestions', () => {
-    test('should reorder questions', async () => {
-      const result = await user1Caller.worksheet.reorderQuestions({
-        worksheetId,
-        movedId: secondQuestionId,
-        position: 'before',
-        targetId: questionId,
-      });
-
-      expect(Array.isArray(result)).toBe(true);
-      expect(result.length).toBe(2);
-      const ids = result.map((r) => r.id);
-      expect(ids).toContain(questionId);
-      expect(ids).toContain(secondQuestionId);
-    });
-  });
-
-  describe('deleteQuestion', () => {
-    test('should delete a question', async () => {
-      const result = await user1Caller.worksheet.deleteQuestion({
-        worksheetId,
-        questionId: secondQuestionId,
-      });
-
-      expect(result.id).toBe(secondQuestionId);
-
-      const worksheet = await user1Caller.worksheet.getWorksheet({ worksheetId });
-      expect(worksheet.questions.length).toBe(1);
-    });
-  });
-
-  describe('deleteWorksheet', () => {
-    test('should delete a worksheet', async () => {
-      const toDelete = await user1Caller.worksheet.create({
-        classId: testClass.id,
-        name: 'Temporary Worksheet',
-      });
-
-      const result = await user1Caller.worksheet.deleteWorksheet({
-        worksheetId: toDelete.id,
-      });
-
-      expect(result.id).toBe(toDelete.id);
-    });
-  });
-});