Kuma/tests/courses/delete-course.test.ts

import { describe, it, expect, vi, beforeEach } from "vitest";

vi.mock("@/src/lib/prisma", () => ({
  prisma: {
    course: { findUnique: vi.fn(), delete: vi.fn(), deleteMany: vi.fn() },
    courseBooking: { count: vi.fn() },
  },
}));
vi.mock("@/src/lib/auth/getUser", () => ({
  getUserData: vi.fn(),
  isManager: () => true,
  isEmployee: () => false,
  getEffectiveManagerId: (user: { id: string }) => user.id,
}));
vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
vi.mock("@/src/modules/courses/lib/public-courses-cache", () => ({
  refreshPublicCourses: vi.fn(),
}));

import { deleteCourse } from "@/src/modules/courses/actions/course-actions";
import { prisma } from "@/src/lib/prisma";
import { getUserData } from "@/src/lib/auth/getUser";

const instance = {
  id: "course-2",
  createdBy: "mgr-1",
  parentCourseId: "template-1",
  date: new Date("2099-01-08"),
  businessId: "biz-1",
};

beforeEach(() => {
  vi.clearAllMocks();
  vi.mocked(getUserData).mockResolvedValue({ id: "mgr-1", role: "manager" } as never);
  vi.mocked(prisma.course.findUnique).mockResolvedValue(instance as never);
  vi.mocked(prisma.courseBooking.count).mockResolvedValue(0 as never);
});

describe("deleteCourse – Buchungen mit Zahlungen", () => {
  it("löscht keinen Kurs mit bezahlten Buchungen oder Rechnungen", async () => {
    vi.mocked(prisma.courseBooking.count).mockResolvedValue(2 as never);

    const result = await deleteCourse("course-2");

    expect(result.success).toBe(false);
    expect(prisma.course.delete).not.toHaveBeenCalled();
    const { where } = vi.mocked(prisma.courseBooking.count).mock.calls[0][0]!;
    expect(where).toMatchObject({
      course: { id: "course-2" },
      OR: [
        { paymentStatus: { in: ["paid", "refunding", "partially_refunded"] } },
        { invoiceNumber: { not: null } },
      ],
    });
  });

  it("prüft bei 'diesen und folgende' alle betroffenen Termine", async () => {
    await deleteCourse("course-2", "this_and_following");

    expect(vi.mocked(prisma.courseBooking.count).mock.calls[0][0]?.where?.course).toEqual({
      parentCourseId: "template-1",
      date: { gte: instance.date },
    });
    expect(prisma.course.deleteMany).toHaveBeenCalled();
  });

  it("prüft beim Löschen einer Vorlage auch alle Termine, die mitgelöscht werden", async () => {
    vi.mocked(prisma.course.findUnique).mockResolvedValue({
      ...instance,
      id: "template-1",
      parentCourseId: null,
    } as never);

    await deleteCourse("template-1");

    expect(vi.mocked(prisma.courseBooking.count).mock.calls[0][0]?.where?.course).toEqual({
      OR: [{ id: "template-1" }, { parentCourseId: "template-1" }],
    });
  });

  it("löscht Kurse ohne solche Buchungen wie bisher", async () => {
    const result = await deleteCourse("course-2");
    expect(result.success).toBe(true);
    expect(prisma.course.delete).toHaveBeenCalledWith({ where: { id: "course-2" } });
  });
});