@studious-lms/server 1.4.0 → 1.4.2

package/tests/utils/studentProgress.test.ts

@@ -0,0 +1,361 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+const { prismaMocks, isTeacherInClass, inference, logger } = vi.hoisted(() => ({
+  prismaMocks: {
+    class: { findUnique: vi.fn() },
+    user: { findFirst: vi.fn() },
+    submission: { findMany: vi.fn(), update: vi.fn(), findFirst: vi.fn() },
+  },
+  isTeacherInClass: vi.fn(),
+  inference: vi.fn(),
+  logger: { error: vi.fn() },
+}));
+
+vi.mock("../../src/lib/prisma.js", () => ({
+  prisma: prismaMocks,
+}));
+
+vi.mock("../../src/models/class.js", () => ({
+  isTeacherInClass,
+}));
+
+vi.mock("../../src/utils/inference.js", () => ({
+  inference,
+}));
+
+vi.mock("../../src/utils/logger.js", () => ({
+  logger,
+}));
+
+import {
+  chatAboutStudentProgress,
+  dismissStudentRecommendation,
+  getClassProgressRecommendations,
+  getStudentProgressRecommendations,
+} from "../../src/services/studentProgress.js";
+
+function createSubmission(overrides: Partial<any> = {}) {
+  return {
+    id: overrides.id ?? "submission-1",
+    gradeReceived: overrides.gradeReceived ?? null,
+    submitted: overrides.submitted ?? false,
+    returned: overrides.returned ?? false,
+    submittedAt: overrides.submittedAt ?? null,
+    recommendationState: overrides.recommendationState ?? "NONE",
+    targetedAssignmentId: overrides.targetedAssignmentId ?? null,
+    assignment: {
+      id: overrides.assignment?.id ?? "assignment-1",
+      title: overrides.assignment?.title ?? "Assignment",
+      dueDate: overrides.assignment?.dueDate ?? daysFromNow(-2),
+      maxGrade: overrides.assignment?.maxGrade ?? 100,
+      weight: overrides.assignment?.weight ?? 1,
+      type: overrides.assignment?.type ?? "HOMEWORK",
+      section: overrides.assignment?.section ?? null,
+    },
+  };
+}
+
+function daysFromNow(days: number) {
+  return new Date(Date.now() + days * 24 * 60 * 60 * 1000);
+}
+
+describe("studentProgress service", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    prismaMocks.submission.update.mockResolvedValue({});
+    prismaMocks.submission.findFirst.mockResolvedValue({ id: "submission-1" });
+  });
+
+  test("returns prioritized student recommendations with normalized assignment types", async () => {
+    isTeacherInClass.mockResolvedValue(false);
+    prismaMocks.class.findUnique.mockResolvedValue({
+      id: "class-1",
+      name: "Algebra",
+      subject: "Math",
+    });
+    prismaMocks.user.findFirst.mockResolvedValue({
+      id: "student-1",
+      username: "student1",
+      profile: { displayName: "Student One" },
+    });
+    prismaMocks.submission.findMany.mockResolvedValue([
+      createSubmission({
+        id: "missing-submission",
+        assignment: {
+          id: "missing-assignment",
+          title: "Missing Quiz",
+          dueDate: daysFromNow(-2),
+          type: "QUIZ",
+          section: { id: "section-1", name: "Fractions" },
+        },
+      }),
+      createSubmission({
+        id: "low-score-submission",
+        gradeReceived: 60,
+        submitted: true,
+        submittedAt: daysFromNow(-4),
+        assignment: {
+          id: "low-score-assignment",
+          title: "Fractions Test",
+          dueDate: daysFromNow(-3),
+          type: "TEST",
+        },
+      }),
+    ]);
+
+    const result = await getStudentProgressRecommendations(
+      "student-1",
+      "class-1",
+      "student-1",
+    );
+
+    expect(result.student).toMatchObject({
+      id: "student-1",
+      displayName: "Student One",
+    });
+    expect(result.summary).toMatchObject({
+      overallGrade: 60,
+      completedAssignments: 1,
+      totalAssignments: 2,
+      missingCount: 1,
+      lowScoreCount: 1,
+    });
+    expect(result.recommendations).toHaveLength(2);
+    expect(result.recommendations[0]).toMatchObject({
+      assignmentId: "missing-assignment",
+      recommendationType: "missing",
+    });
+    expect(result.recommendations[0]?.suggestedAssignment).toMatchObject({
+      title: "Make-up: Missing Quiz",
+      type: "HOMEWORK",
+      sectionId: "section-1",
+      sourceAssignmentId: "missing-assignment",
+    });
+    expect(result.recommendations[1]).toMatchObject({
+      assignmentId: "low-score-assignment",
+      recommendationType: "low_score",
+      percentage: 60,
+    });
+    expect(result.recommendations[1]?.suggestedAssignment?.type).toBe(
+      "HOMEWORK",
+    );
+    expect(result.nextSteps).toContain("Prioritize 1 missing assignment.");
+    expect(result.nextSteps).toContain(
+      "Review 1 low-scoring assignment before introducing new material.",
+    );
+  });
+
+  test("aggregates class-wide recommendation counts for teachers", async () => {
+    isTeacherInClass.mockResolvedValue(true);
+    prismaMocks.class.findUnique.mockResolvedValue({
+      id: "class-1",
+      name: "Algebra",
+      subject: "Math",
+      students: [
+        {
+          id: "student-1",
+          username: "student1",
+          profile: { displayName: "Student One" },
+          submissions: [
+            createSubmission({
+              id: "student-1-missing",
+              assignment: {
+                id: "missing-assignment",
+                title: "Missed Homework",
+                dueDate: daysFromNow(-2),
+                type: "HOMEWORK",
+              },
+            }),
+            createSubmission({
+              id: "student-1-low",
+              gradeReceived: 62,
+              submitted: true,
+              submittedAt: daysFromNow(-4),
+              assignment: {
+                id: "student-1-low-assignment",
+                title: "Student 1 Test",
+                dueDate: daysFromNow(-3),
+                type: "TEST",
+              },
+            }),
+          ],
+        },
+        {
+          id: "student-2",
+          username: "student2",
+          profile: { displayName: "Student Two" },
+          submissions: [
+            createSubmission({
+              id: "student-2-low",
+              gradeReceived: 40,
+              submitted: true,
+              submittedAt: daysFromNow(-3),
+              assignment: {
+                id: "student-2-low-assignment",
+                title: "Student 2 Quiz",
+                dueDate: daysFromNow(-3),
+                type: "QUIZ",
+              },
+            }),
+          ],
+        },
+        {
+          id: "student-3",
+          username: "student3",
+          profile: { displayName: "Student Three" },
+          submissions: [
+            createSubmission({
+              id: "student-3-ok",
+              gradeReceived: 95,
+              submitted: true,
+              submittedAt: daysFromNow(-3),
+              assignment: {
+                id: "student-3-ok-assignment",
+                title: "Completed Work",
+                dueDate: daysFromNow(-3),
+                type: "HOMEWORK",
+              },
+            }),
+          ],
+        },
+      ],
+    });
+
+    const result = await getClassProgressRecommendations("teacher-1", "class-1");
+
+    expect(result.class).toMatchObject({
+      id: "class-1",
+      name: "Algebra",
+      subject: "Math",
+    });
+    expect(result.summary).toMatchObject({
+      studentsWithConcerns: 2,
+      totalRecommendations: 3,
+      totalMissingAssignments: 1,
+      totalLowScoreAssignments: 2,
+    });
+    expect(result.students).toHaveLength(2);
+    expect(result.students[0]?.student.id).toBe("student-1");
+    expect(result.students[0]?.recommendations[0]).toMatchObject({
+      assignmentId: "missing-assignment",
+      recommendationType: "missing",
+    });
+    expect(result.students[1]?.student.id).toBe("student-2");
+  });
+
+  test("rejects class-wide recommendations for non-teachers", async () => {
+    isTeacherInClass.mockResolvedValue(false);
+
+    await expect(
+      getClassProgressRecommendations("student-1", "class-1"),
+    ).rejects.toMatchObject({
+      code: "UNAUTHORIZED",
+    });
+  });
+
+  test("falls back to a deterministic chat summary when inference fails", async () => {
+    isTeacherInClass.mockResolvedValue(false);
+    inference.mockRejectedValue(new Error("upstream failure"));
+    prismaMocks.class.findUnique.mockResolvedValue({
+      id: "class-1",
+      name: "Algebra",
+      subject: "Math",
+    });
+    prismaMocks.user.findFirst.mockResolvedValue({
+      id: "student-1",
+      username: "student1",
+      profile: { displayName: "Student One" },
+    });
+    prismaMocks.submission.findMany.mockResolvedValue([
+      createSubmission({
+        id: "missing-submission",
+        assignment: {
+          id: "missing-assignment",
+          title: "Missing Quiz",
+          dueDate: daysFromNow(-2),
+          type: "QUIZ",
+        },
+      }),
+      createSubmission({
+        id: "low-score-submission",
+        gradeReceived: 60,
+        submitted: true,
+        submittedAt: daysFromNow(-4),
+        assignment: {
+          id: "low-score-assignment",
+          title: "Fractions Test",
+          dueDate: daysFromNow(-3),
+          type: "TEST",
+        },
+      }),
+    ]);
+
+    const result = await chatAboutStudentProgress("student-1", {
+      classId: "class-1",
+      studentId: "student-1",
+      message: "How is this student doing?",
+    });
+
+    expect(result.isFallback).toBe(true);
+    expect(result.message).toContain("Student One's current overall grade is 60%.");
+    expect(result.message).toContain("1 assignment appears overdue.");
+    expect(result.message).toContain("1 graded assignment is below 70%.");
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  test("suppresses recommendations for submissions marked ASSIGNED", async () => {
+    isTeacherInClass.mockResolvedValue(false);
+    prismaMocks.class.findUnique.mockResolvedValue({
+      id: "class-1",
+      name: "Algebra",
+      subject: "Math",
+    });
+    prismaMocks.user.findFirst.mockResolvedValue({
+      id: "student-1",
+      username: "student1",
+      profile: { displayName: "Student One" },
+    });
+    prismaMocks.submission.findMany.mockResolvedValue([
+      createSubmission({
+        id: "low-score-submission",
+        gradeReceived: 52,
+        submitted: true,
+        submittedAt: daysFromNow(-4),
+        recommendationState: "ASSIGNED",
+        assignment: {
+          id: "low-score-assignment",
+          title: "Fractions Test",
+          dueDate: daysFromNow(-3),
+          type: "TEST",
+        },
+      }),
+    ]);
+
+    const result = await getStudentProgressRecommendations(
+      "student-1",
+      "class-1",
+      "student-1",
+    );
+
+    expect(result.recommendations).toHaveLength(0);
+  });
+
+  test("allows teachers to dismiss a recommendation", async () => {
+    isTeacherInClass.mockResolvedValue(true);
+    prismaMocks.submission.findFirst.mockResolvedValue({ id: "submission-1" });
+
+    const result = await dismissStudentRecommendation("teacher-1", {
+      classId: "class-1",
+      studentId: "student-1",
+      submissionId: "submission-1",
+    });
+
+    expect(result).toEqual({ success: true });
+    expect(prismaMocks.submission.update).toHaveBeenCalledWith({
+      where: { id: "submission-1" },
+      data: expect.objectContaining({
+        recommendationState: "DISMISSED",
+      }),
+    });
+  });
+});

package/vitest.unit.config.ts

@@ -13,7 +13,14 @@ 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'],
+    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',
+    ],
     env: {
       NODE_ENV: 'test',
     },