@studious-lms/server 1.11.0 → 1.12.0

package/tests/unit/services/discussion.test.ts

@@ -0,0 +1,356 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { TRPCError } from "@trpc/server";
+
+const { prismaMocks, pusherMocks, notificationMocks } = vi.hoisted(() => ({
+  prismaMocks: {
+    class: { findFirst: vi.fn(), findMany: vi.fn() },
+    discussion: {
+      findUnique: vi.fn(),
+      findUniqueOrThrow: vi.fn(),
+      findMany: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+    discussionReply: {
+      findUnique: vi.fn(),
+      findMany: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      updateMany: vi.fn(),
+      count: vi.fn(),
+      groupBy: vi.fn(),
+    },
+    discussionRead: {
+      findMany: vi.fn(),
+      upsert: vi.fn(),
+    },
+    reaction: {
+      findUnique: vi.fn(),
+      upsert: vi.fn(),
+      delete: vi.fn(),
+    },
+    file: { updateMany: vi.fn() },
+    user: { findMany: vi.fn() },
+    discussionTag: {
+      findMany: vi.fn(),
+      findUnique: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      delete: vi.fn(),
+    },
+    $transaction: vi.fn(),
+  },
+  pusherMocks: {
+    trigger: vi.fn(),
+  },
+  notificationMocks: {
+    sendNotification: vi.fn(),
+  },
+}));
+
+vi.mock("../../../src/lib/prisma.js", () => ({
+  prisma: prismaMocks,
+}));
+
+vi.mock("../../../src/lib/pusher.js", () => ({
+  pusher: pusherMocks,
+  discussionChannel: (classId: string) => `private-class-${classId}-discussions`,
+}));
+
+vi.mock("../../../src/services/notification.js", () => notificationMocks);
+
+import {
+  buildReplyTree,
+  createDiscussion,
+  getDiscussion,
+  getUnreadCounts,
+  markAcceptedAnswer,
+  replyToDiscussion,
+} from "../../../src/services/discussion.js";
+
+const author = {
+  id: "author-1",
+  username: "teacher",
+  profile: {
+    displayName: "Teacher",
+    profilePicture: null,
+    profilePictureThumbnail: null,
+  },
+};
+
+function enabledTeacherClass(overrides = {}) {
+  return {
+    id: "class-1",
+    name: "History",
+    discussionsEnabled: true,
+    studentsCanCreateDiscussions: true,
+    studentsCanReply: true,
+    students: [],
+    teachers: [{ id: "teacher-1" }],
+    school: { memberships: [] },
+    ...overrides,
+  };
+}
+
+function discussion(overrides = {}) {
+  return {
+    id: "discussion-1",
+    classId: "class-1",
+    authorId: "teacher-1",
+    title: "Question",
+    body: "Body",
+    type: "QUESTION",
+    isPinned: false,
+    isLocked: false,
+    allowReplies: true,
+    createdAt: new Date("2026-01-01T00:00:00Z"),
+    updatedAt: new Date("2026-01-01T00:00:00Z"),
+    lastActivityAt: new Date("2026-01-01T00:00:00Z"),
+    author,
+    attachments: [],
+    tags: [],
+    reactions: [],
+    _count: { replies: 0 },
+    ...overrides,
+  };
+}
+
+function reply(overrides = {}) {
+  return {
+    id: "reply-1",
+    discussionId: "discussion-1",
+    authorId: "student-1",
+    parentId: null,
+    body: "Reply",
+    deletedAt: null,
+    isAcceptedAnswer: false,
+    createdAt: new Date("2026-01-01T00:00:00Z"),
+    modifiedAt: null,
+    author,
+    attachments: [],
+    reactions: [],
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  prismaMocks.$transaction.mockImplementation((callback) => callback(prismaMocks));
+  pusherMocks.trigger.mockResolvedValue(undefined);
+  notificationMocks.sendNotification.mockResolvedValue({});
+  prismaMocks.user.findMany.mockResolvedValue([]);
+});
+
+describe("buildReplyTree", () => {
+  test("assembles nested replies and preserves soft-deleted parents", () => {
+    const tree = buildReplyTree(
+      [
+        reply({ id: "parent", body: "[deleted]", deletedAt: new Date("2026-01-02T00:00:00Z") }) as any,
+        reply({ id: "child", parentId: "parent", body: "Child" }) as any,
+      ],
+      "viewer-1"
+    );
+
+    expect(tree).toHaveLength(1);
+    expect(tree[0].body).toBe("[deleted]");
+    expect(tree[0].attachments).toEqual([]);
+    expect(tree[0].children[0].id).toBe("child");
+  });
+});
+
+describe("getDiscussion", () => {
+  test("marks the thread read and returns nested replies with permissions", async () => {
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+    prismaMocks.discussion.findUniqueOrThrow.mockResolvedValue(discussion());
+    prismaMocks.discussionReply.findMany.mockResolvedValue([
+      reply({ id: "parent" }),
+      reply({ id: "child", parentId: "parent" }),
+    ]);
+    prismaMocks.reaction.findUnique.mockResolvedValue({ type: "HEART" });
+    prismaMocks.discussionRead.upsert.mockResolvedValue({});
+
+    const result = await getDiscussion("teacher-1", "discussion-1");
+
+    expect(prismaMocks.discussionRead.upsert).toHaveBeenCalledWith({
+      where: { userId_discussionId: { userId: "teacher-1", discussionId: "discussion-1" } },
+      update: { lastReadAt: expect.any(Date) },
+      create: { userId: "teacher-1", discussionId: "discussion-1" },
+    });
+    expect(result.replies[0].children[0].id).toBe("child");
+    expect(result.canPin).toBe(true);
+    expect(result.canReply).toBe(true);
+    expect(result.myReaction).toBe("HEART");
+  });
+});
+
+describe("getUnreadCounts", () => {
+  test("computes per-class totals from unread replies", async () => {
+    prismaMocks.class.findMany.mockResolvedValue([{ id: "class-1" }]);
+    prismaMocks.discussion.findMany.mockResolvedValue([
+      { id: "discussion-1" },
+      { id: "discussion-2" },
+    ]);
+    prismaMocks.discussionRead.findMany.mockResolvedValue([
+      { discussionId: "discussion-1", lastReadAt: new Date("2026-01-01T00:00:00Z") },
+    ]);
+    prismaMocks.discussionReply.groupBy
+      .mockResolvedValueOnce([{ discussionId: "discussion-2", _count: 1 }])
+      .mockResolvedValueOnce([{ discussionId: "discussion-1", _count: 2 }]);
+
+    const result = await getUnreadCounts("student-1", ["class-1"]);
+
+    expect(prismaMocks.discussionReply.groupBy).toHaveBeenNthCalledWith(1, {
+      by: ["discussionId"],
+      where: {
+        discussionId: { in: ["discussion-2"] },
+        deletedAt: null,
+        authorId: { not: "student-1" },
+      },
+      _count: true,
+    });
+    expect(prismaMocks.discussionReply.groupBy).toHaveBeenNthCalledWith(2, {
+      by: ["discussionId"],
+      where: {
+        deletedAt: null,
+        authorId: { not: "student-1" },
+        OR: [
+          {
+            discussionId: "discussion-1",
+            createdAt: { gt: new Date("2026-01-01T00:00:00Z") },
+          },
+        ],
+      },
+      _count: true,
+    });
+    expect(result["class-1"].total).toBe(3);
+    expect(result["class-1"].perDiscussion).toEqual([
+      { discussionId: "discussion-2", count: 1 },
+      { discussionId: "discussion-1", count: 2 },
+    ]);
+  });
+});
+
+describe("createDiscussion authorization", () => {
+  test("blocks student-created announcement discussions", async () => {
+    prismaMocks.class.findFirst.mockResolvedValue(
+      enabledTeacherClass({
+        teachers: [],
+        students: [{ id: "student-1" }],
+      })
+    );
+
+    await expect(
+      createDiscussion("student-1", {
+        classId: "class-1",
+        title: "Update",
+        body: "Read this",
+        type: "ANNOUNCEMENT",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+
+  test("blocks student-created discussions when disabled", async () => {
+    prismaMocks.class.findFirst.mockResolvedValue(
+      enabledTeacherClass({
+        teachers: [],
+        students: [{ id: "student-1" }],
+        studentsCanCreateDiscussions: false,
+      })
+    );
+
+    await expect(
+      createDiscussion("student-1", {
+        classId: "class-1",
+        title: "Question",
+        body: "Can I ask this?",
+        type: "DISCUSSION",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+});
+
+describe("replyToDiscussion authorization", () => {
+  test("blocks student replies on locked discussions", async () => {
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion({ isLocked: true }),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [],
+        students: [{ id: "student-1" }],
+        school: { memberships: [] },
+      },
+    });
+
+    await expect(
+      replyToDiscussion("student-1", {
+        discussionId: "discussion-1",
+        body: "Reply",
+      })
+    ).rejects.toMatchObject({ code: "FORBIDDEN" });
+  });
+});
+
+describe("markAcceptedAnswer", () => {
+  test("unmarks previous answers before accepting a reply", async () => {
+    prismaMocks.discussionReply.findUnique.mockResolvedValue({
+      ...reply({ id: "reply-1", authorId: "student-1" }),
+      discussion: discussion({ type: "QUESTION", authorId: "teacher-1" }),
+    });
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+    prismaMocks.discussionReply.update.mockResolvedValue(
+      reply({ id: "reply-1", isAcceptedAnswer: true })
+    );
+
+    const result = await markAcceptedAnswer("teacher-1", "reply-1", true);
+
+    expect(prismaMocks.discussionReply.updateMany).toHaveBeenCalledWith({
+      where: { discussionId: "discussion-1", isAcceptedAnswer: true },
+      data: { isAcceptedAnswer: false },
+    });
+    expect(result.reply.isAcceptedAnswer).toBe(true);
+    expect(notificationMocks.sendNotification).toHaveBeenCalled();
+  });
+
+  test("rejects accepted answers on non-question discussions", async () => {
+    prismaMocks.discussionReply.findUnique.mockResolvedValue({
+      ...reply({ id: "reply-1" }),
+      discussion: discussion({ type: "DISCUSSION" }),
+    });
+    prismaMocks.discussion.findUnique.mockResolvedValue({
+      ...discussion(),
+      class: {
+        id: "class-1",
+        discussionsEnabled: true,
+        studentsCanReply: true,
+        teachers: [{ id: "teacher-1" }],
+        students: [],
+        school: { memberships: [] },
+      },
+    });
+
+    await expect(markAcceptedAnswer("teacher-1", "reply-1", true)).rejects.toBeInstanceOf(TRPCError);
+  });
+});