Kuma/tests/notifications/notification-settings-actions.test.ts

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

vi.mock("@/src/lib/prisma", () => ({
  prisma: {
    business: { findUnique: vi.fn(), update: vi.fn() },
  },
}));

vi.mock("@/src/lib/auth/getUser", () => ({
  requireManager: vi.fn(),
}));

vi.mock("next/cache", () => ({
  revalidatePath: vi.fn(),
}));

import { prisma } from "@/src/lib/prisma";
import { requireManager } from "@/src/lib/auth/getUser";
import {
  getNotificationSettings,
  saveNotificationSettings,
} from "@/src/modules/settings/actions/notification-settings-actions";
import { NOTIFICATION_TYPES } from "@/src/modules/notifications/lib/notification-types";

const findUnique = vi.mocked(prisma.business.findUnique);
const update = vi.mocked(prisma.business.update);
const requireMgr = vi.mocked(requireManager);

beforeEach(() => {
  vi.clearAllMocks();
  requireMgr.mockResolvedValue({ id: "mgr-1" } as never);
});

describe("getNotificationSettings", () => {
  it("verweigert ein Business, das dem Manager nicht gehört", async () => {
    findUnique.mockResolvedValueOnce({
      managerId: "someone-else",
      notificationSettings: null,
    } as never);
    const result = await getNotificationSettings("b1");
    expect(result.success).toBe(false);
  });

  it("liefert die aufgelösten Defaults bei null", async () => {
    findUnique.mockResolvedValueOnce({ managerId: "mgr-1", notificationSettings: null } as never);
    const result = await getNotificationSettings("b1");
    expect(result.success).toBe(true);
    if (result.success) {
      expect(result.settings["booking.created"]).toBe(
        NOTIFICATION_TYPES["booking.created"].defaultOn
      );
    }
  });
});

describe("saveNotificationSettings", () => {
  it("lehnt unbekannte Keys ab (strict schema)", async () => {
    const result = await saveNotificationSettings("b1", {
      "not.a.real.type": false,
    } as never);
    expect(result.success).toBe(false);
    expect(findUnique).not.toHaveBeenCalled();
  });

  it("merged partielle Änderungen auf die volle Map und persistiert sie", async () => {
    findUnique.mockResolvedValueOnce({
      managerId: "mgr-1",
      notificationSettings: null,
    } as never);
    update.mockResolvedValueOnce({} as never);

    const result = await saveNotificationSettings("b1", { "booking.created": false });
    expect(result.success).toBe(true);

    const written = update.mock.calls[0][0].data.notificationSettings as Record<string, boolean>;
    expect(written["booking.created"]).toBe(false);
    // alle anderen Keys sind ebenfalls enthalten (volle Map)
    expect(Object.keys(written).sort()).toEqual(Object.keys(NOTIFICATION_TYPES).sort());
    expect(written["course.cancelled"]).toBe(NOTIFICATION_TYPES["course.cancelled"].defaultOn);
  });

  it("verweigert ein fremdes Business auch beim Speichern", async () => {
    findUnique.mockResolvedValueOnce({ managerId: "x", notificationSettings: null } as never);
    const result = await saveNotificationSettings("b1", { "booking.created": true });
    expect(result.success).toBe(false);
    expect(update).not.toHaveBeenCalled();
  });
});