Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

18.1 KB
Raw Blame
import {
  getQuestionsList,
  getQuestionById,
  createQuestion,
  updateQuestion,
  deleteQuestion,
  getTagsWithQuestionCounts,
} from "@/actions/question.actions";
import { getCurrentUser } from "@/utils/user.utils";
import { PrismaClient } from "@prisma/client";

const prisma = new PrismaClient();

vi.mock("@prisma/client", () => {
  const mPrismaClient = {
    question: {
      findMany: vi.fn(),
      findFirst: vi.fn(),
      create: vi.fn(),
      update: vi.fn(),
      delete: vi.fn(),
      count: vi.fn(),
    },
    tag: {
      findMany: vi.fn(),
    },
    jobStagePrepQuestion: {
      count: vi.fn(),
    },
  };
  return { PrismaClient: vi.fn(function() { return mPrismaClient; }) };
});

vi.mock("@/utils/user.utils", () => ({
  getCurrentUser: vi.fn(),
}));

describe("Question Actions", () => {
  const mockUser = { id: "user-id" };

  const mockQuestion = {
    id: "q-1",
    question: "What is React?",
    answer: "<p>A JS library</p>",
    createdBy: mockUser.id,
    tags: [{ id: "tag-1", label: "React", value: "react" }],
    createdAt: new Date(),
    updatedAt: new Date(),
  };

  beforeEach(() => {
    vi.clearAllMocks();
    (prisma.jobStagePrepQuestion.count as any).mockResolvedValue(0);
  });

  // getQuestionsList
  describe("getQuestionsList", () => {
    it("should return paginated questions", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([mockQuestion]);
      (prisma.question.count as any).mockResolvedValue(1);

      const result = await getQuestionsList(1, 10);

      expect(result).toEqual({ success: true, data: [mockQuestion], total: 1 });
      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({
          where: { createdBy: mockUser.id },
          skip: 0,
          take: 10,
          orderBy: [{ createdAt: "desc" }],
          include: { tags: true },
        }),
      );
    });

    it("should calculate offset for page 2", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getQuestionsList(2, 10);

      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({ skip: 10, take: 10 }),
      );
    });

    it("should filter by tag when filter is provided", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getQuestionsList(1, 10, "tag-1");

      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({
          where: {
            createdBy: mockUser.id,
            tags: { some: { id: "tag-1" } },
          },
        }),
      );
    });

    it("should filter to one owned interview round when stageId is provided", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getQuestionsList(1, 10, undefined, undefined, "stage-1");

      const where = {
        createdBy: mockUser.id,
        prepLinks: {
          some: { stageId: "stage-1", Stage: { Job: { userId: mockUser.id } } },
        },
      };
      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({ where }),
      );
      expect(prisma.question.count).toHaveBeenCalledWith({ where });
    });

    it("should search by question and answer content", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getQuestionsList(1, 10, undefined, "react");

      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({
          where: {
            createdBy: mockUser.id,
            OR: [
              { question: { contains: "react" } },
              { answer: { contains: "react" } },
            ],
          },
        }),
      );
    });

    it("should apply both filter and search together", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getQuestionsList(1, 10, "tag-1", "react");

      expect(prisma.question.findMany).toHaveBeenCalledWith(
        expect.objectContaining({
          where: {
            createdBy: mockUser.id,
            tags: { some: { id: "tag-1" } },
            OR: [
              { question: { contains: "react" } },
              { answer: { contains: "react" } },
            ],
          },
        }),
      );
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await getQuestionsList(1, 10);

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.question.findMany).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findMany as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await getQuestionsList(1, 10);

      expect(result).toEqual({ success: false, message: "DB error" });
    });
  });

  // getQuestionById
  describe("getQuestionById", () => {
    it("should return question by id", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findFirst as any).mockResolvedValue(mockQuestion);

      const result = await getQuestionById("q-1");

      expect(result).toEqual({ success: true, data: mockQuestion });
      expect(prisma.question.findFirst).toHaveBeenCalledWith({
        where: { id: "q-1", createdBy: mockUser.id },
        include: { tags: true },
      });
    });

    it("should return not found when question does not exist", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findFirst as any).mockResolvedValue(null);

      const result = await getQuestionById("nonexistent");

      expect(result).toEqual({
        success: false,
        message: "Question not found",
      });
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await getQuestionById("q-1");

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.question.findFirst).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.findFirst as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await getQuestionById("q-1");

      expect(result).toEqual({ success: false, message: "DB error" });
    });
  });

  // createQuestion
  describe("createQuestion", () => {
    it("should create a question with tags", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.create as any).mockResolvedValue(mockQuestion);

      const result = await createQuestion({
        question: "What is React?",
        answer: "<p>A JS library</p>",
        tagIds: ["tag-1"],
      });

      expect(result).toEqual({ success: true, data: mockQuestion });
      expect(prisma.question.create).toHaveBeenCalledWith({
        data: {
          question: "What is React?",
          answer: "<p>A JS library</p>",
          createdBy: mockUser.id,
          tags: { connect: [{ id: "tag-1" }] },
        },
        include: { tags: true },
      });
    });

    it("should create a question without tags", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.create as any).mockResolvedValue({
        ...mockQuestion,
        tags: [],
      });

      const result = await createQuestion({
        question: "What is React?",
        answer: "<p>A JS library</p>",
      });

      expect(result?.success).toBe(true);
      expect(prisma.question.create).toHaveBeenCalledWith({
        data: {
          question: "What is React?",
          answer: "<p>A JS library</p>",
          createdBy: mockUser.id,
          tags: undefined,
        },
        include: { tags: true },
      });
    });

    it("should reject invalid data (null answer)", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);

      const result = await createQuestion({ question: "What?", answer: null } as any);

      expect(result?.success).toBe(false);
      expect(prisma.question.create).not.toHaveBeenCalled();
    });

    it("should reject invalid data (question too short)", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);

      const result = await createQuestion({
        question: "a",
        answer: "<p>A JS library</p>",
      });

      expect(result?.success).toBe(false);
      expect(prisma.question.create).not.toHaveBeenCalled();
    });

    it("should reject invalid data (answer too short)", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);

      const result = await createQuestion({
        question: "What is React?",
        answer: "short",
      });

      expect(result?.success).toBe(false);
      expect(prisma.question.create).not.toHaveBeenCalled();
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await createQuestion({
        question: "What is React?",
        answer: "<p>A JS library</p>",
      });

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.question.create).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.create as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await createQuestion({
        question: "What is React?",
        answer: "<p>A JS library</p>",
      });

      expect(result).toEqual({ success: false, message: "DB error" });
    });
  });

  // updateQuestion
  describe("updateQuestion", () => {
    it("should update a question with new tags", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.update as any).mockResolvedValue(mockQuestion);

      const result = await updateQuestion({
        id: "q-1",
        question: "Updated question?",
        answer: "<p>Updated answer</p>",
        tagIds: ["tag-1", "tag-2"],
      });

      expect(result).toEqual({ success: true, data: mockQuestion });
      expect(prisma.question.update).toHaveBeenCalledWith({
        where: { id: "q-1", createdBy: mockUser.id },
        data: {
          question: "Updated question?",
          answer: "<p>Updated answer</p>",
          tags: { set: [{ id: "tag-1" }, { id: "tag-2" }] },
        },
        include: { tags: true },
      });
    });

    it("should clear tags when tagIds is empty", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.update as any).mockResolvedValue(mockQuestion);

      await updateQuestion({
        id: "q-1",
        question: "Updated?",
        answer: "<p>Updated answer</p>",
        tagIds: [],
      });

      expect(prisma.question.update).toHaveBeenCalledWith(
        expect.objectContaining({
          data: expect.objectContaining({
            tags: { set: [] },
          }),
        }),
      );
    });

    it("should return error when id is missing", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);

      const result = await updateQuestion({
        question: "No ID?",
        answer: "<p>Updated answer</p>",
      });

      expect(result?.success).toBe(false);
      expect(prisma.question.update).not.toHaveBeenCalled();
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await updateQuestion({
        id: "q-1",
        question: "Updated?",
        answer: "<p>Updated answer</p>",
      });

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.question.update).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.update as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await updateQuestion({
        id: "q-1",
        question: "Updated?",
        answer: "<p>Updated answer</p>",
      });

      expect(result).toEqual({ success: false, message: "DB error" });
    });
  });

  // deleteQuestion
  describe("deleteQuestion", () => {
    it("should delete a question", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.delete as any).mockResolvedValue(mockQuestion);

      const result = await deleteQuestion("q-1");

      expect(result).toEqual({ success: true });
      expect(prisma.question.delete).toHaveBeenCalledWith({
        where: { id: "q-1", createdBy: mockUser.id },
      });
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await deleteQuestion("q-1");

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.question.delete).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.question.delete as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await deleteQuestion("q-1");

      expect(result).toEqual({ success: false, message: "DB error" });
    });

    it("blocks deleting a question that sits on a prep list, naming the count", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.jobStagePrepQuestion.count as any).mockResolvedValue(3);

      const result = await deleteQuestion("q-1");

      expect(result.success).toBe(false);
      expect(result.message).toContain("3");
      expect(prisma.question.delete).not.toHaveBeenCalled();
    });

    it("deletes a question that is on no prep list", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.jobStagePrepQuestion.count as any).mockResolvedValue(0);
      (prisma.question.delete as any).mockResolvedValue(mockQuestion);

      const result = await deleteQuestion("q-1");

      expect(result.success).toBe(true);
      expect(prisma.question.delete).toHaveBeenCalled();
    });
  });

  // getTagsWithQuestionCounts
  describe("getTagsWithQuestionCounts", () => {
    it("should return tags with question counts", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      const mockTags = [
        {
          id: "tag-1",
          label: "React",
          value: "react",
          _count: { questions: 5 },
        },
        {
          id: "tag-2",
          label: "TypeScript",
          value: "typescript",
          _count: { questions: 3 },
        },
      ];
      (prisma.tag.findMany as any).mockResolvedValue(mockTags);
      (prisma.question.count as any).mockResolvedValue(8);

      const result = await getTagsWithQuestionCounts();

      expect(result).toEqual({
        success: true,
        data: [
          { id: "tag-1", label: "React", value: "react", questionCount: 5 },
          {
            id: "tag-2",
            label: "TypeScript",
            value: "typescript",
            questionCount: 3,
          },
        ],
        totalQuestions: 8,
      });
    });

    it("should count only one owned interview round's questions when stageId is provided", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.tag.findMany as any).mockResolvedValue([]);
      (prisma.question.count as any).mockResolvedValue(0);

      await getTagsWithQuestionCounts("stage-1");

      const prepLinks = {
        some: { stageId: "stage-1", Stage: { Job: { userId: mockUser.id } } },
      };
      expect(prisma.tag.findMany).toHaveBeenCalledWith(
        expect.objectContaining({
          include: {
            _count: { select: { questions: { where: { prepLinks } } } },
          },
        }),
      );
      expect(prisma.question.count).toHaveBeenCalledWith({
        where: { createdBy: mockUser.id, prepLinks },
      });
    });

    it("should filter out tags with zero questions", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      const mockTags = [
        {
          id: "tag-1",
          label: "React",
          value: "react",
          _count: { questions: 2 },
        },
        {
          id: "tag-2",
          label: "Unused",
          value: "unused",
          _count: { questions: 0 },
        },
      ];
      (prisma.tag.findMany as any).mockResolvedValue(mockTags);
      (prisma.question.count as any).mockResolvedValue(2);

      const result = await getTagsWithQuestionCounts();

      expect(result?.data).toHaveLength(1);
      expect(result?.data[0].label).toBe("React");
    });

    it("should return error for unauthenticated user", async () => {
      (getCurrentUser as any).mockResolvedValue(null);

      const result = await getTagsWithQuestionCounts();

      expect(result).toEqual({
        success: false,
        message: "Not authenticated",
      });
      expect(prisma.tag.findMany).not.toHaveBeenCalled();
    });

    it("should handle database errors", async () => {
      (getCurrentUser as any).mockResolvedValue(mockUser);
      (prisma.tag.findMany as any).mockRejectedValue(
        new Error("DB error"),
      );

      const result = await getTagsWithQuestionCounts();

      expect(result).toEqual({ success: false, message: "DB error" });
    });
  });
});