Files
HiveGrid-Wireframes/hivegrid-cloud/apps/web/app/routes/app.$tenant/settings/notifications.test.tsx
T

221 lines
9.2 KiB
TypeScript

import "@testing-library/jest-dom";
import { render, screen } from "@testing-library/react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { MemoryRouter } from "react-router";
vi.mock("@toolctrl/db/notifications.server", () => ({
getUserNotificationPreferences: vi.fn(),
upsertUserNotificationPreference: vi.fn(),
}));
vi.mock("~/utils/loaders.middleware", () => ({
requireAuth: vi.fn(),
}));
vi.mock("~/utils/services/.server/urlService", () => ({
getTenantIdFromUrl: vi.fn(),
}));
vi.mock("~/utils/session.server", () => ({
getUserInfo: vi.fn(),
validateCSRFToken: vi.fn(),
}));
vi.mock("~/utils/data/useRootData", () => ({
useRootData: () => ({ csrf: "csrf-test-token" }),
}));
const routeTranslations: Record<string, string> = {
"settings.notifications.heading": "Notification preferences",
"settings.notifications.description": "Choose which workspace updates you receive in-app and by email. Preferences are scoped to your current workspace and user account.",
"settings.notifications.saved": "Notification preference saved.",
"settings.notifications.categories.default": "Default",
"settings.notifications.categories.billing": "Billing",
"settings.notifications.categories.team": "Team",
"settings.notifications.channels.inApp": "In-app",
"settings.notifications.channels.email": "Email",
"settings.notifications.errors.invalidPreferenceAction": "Invalid notification preference action.",
"settings.notifications.errors.invalidPreferenceCategory": "Invalid notification preference category.",
"settings.notifications.errors.invalidPreferenceChannel": "Invalid notification preference channel.",
"shared.save": "Save",
};
vi.mock("~/locale/i18next.server", () => ({
getTranslations: vi.fn(async () => ({
t: (key: string) => routeTranslations[key] ?? key,
})),
}));
vi.mock("react-i18next", () => ({
useTranslation: () => ({
t: (key: string, options?: Record<string, string>) => {
if (key === "settings.notifications.categoryDescription") {
return `Manage ${options?.category ?? ""} workspace notifications.`;
}
return routeTranslations[key] ?? key;
},
}),
}));
vi.mock("react-router", async () => {
const actual = await vi.importActual<typeof import("react-router")>("react-router");
return {
...actual,
useActionData: () => routeActionData,
useLoaderData: () => routeLoaderData,
};
});
import { getUserNotificationPreferences, upsertUserNotificationPreference } from "@toolctrl/db/notifications.server";
import { requireAuth } from "~/utils/loaders.middleware";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { getUserInfo } from "~/utils/session.server";
import WorkspaceNotificationSettingsRoute, { action, loader } from "./notifications";
let routeLoaderData: unknown;
let routeActionData: unknown;
const request = new Request("https://app.example.test/acme/settings/notifications");
const params = { tenant: "acme" };
function routeArgs(customRequest: Request = request) {
return { request: customRequest, params, context: {}, unstable_pattern: "app.$tenant/settings/notifications" };
}
function postFormRequest(formData: FormData) {
return new Request(request.url, {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams(formData as unknown as Record<string, string>),
});
}
function preferenceForm(overrides?: Record<string, string>) {
const form = new FormData();
form.set("action", "update-preference");
form.set("category", "billing");
form.set("channel", "EMAIL");
form.set("enabled", "on");
Object.entries(overrides ?? {}).forEach(([key, value]) => form.set(key, value));
return form;
}
describe("workspace notification settings route", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(getTenantIdFromUrl).mockResolvedValue("tenant_1");
vi.mocked(getUserInfo).mockResolvedValue({ userId: "user_1" } as never);
vi.mocked(getUserNotificationPreferences).mockResolvedValue([]);
vi.mocked(upsertUserNotificationPreference).mockResolvedValue({ id: "pref_1" });
routeLoaderData = {
preferences: {
default: { IN_APP: true, EMAIL: true },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: false, EMAIL: true },
},
};
routeActionData = undefined;
});
it("requires auth and loads notification preferences only for the current tenant and user", async () => {
vi.mocked(getUserNotificationPreferences).mockResolvedValue([
{ tenantId: "tenant_1", userId: "user_1", category: "billing", channel: "EMAIL", enabled: false },
{ tenantId: "tenant_1", userId: "user_1", category: "team", channel: "IN_APP", enabled: false },
{ tenantId: "tenant_1", userId: "user_1", category: "unknown", channel: "EMAIL", enabled: false },
] as never);
const response = (await loader(routeArgs())) as Response;
const body = await response.json();
expect(requireAuth).toHaveBeenCalledWith({ request, params });
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(getUserInfo).toHaveBeenCalledWith(request);
expect(getUserNotificationPreferences).toHaveBeenCalledWith({ tenantId: "tenant_1", userId: "user_1" });
expect(body).toEqual({
preferences: {
default: { IN_APP: true, EMAIL: true },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: false, EMAIL: true },
},
});
expect(JSON.stringify(body)).not.toContain("unknown");
});
it("shows category preferences using the same default fallback as the worker", async () => {
vi.mocked(getUserNotificationPreferences).mockResolvedValue([{ tenantId: "tenant_1", userId: "user_1", category: "default", channel: "EMAIL", enabled: false }] as never);
const response = (await loader(routeArgs())) as Response;
const body = await response.json();
expect(body).toEqual({
preferences: {
default: { IN_APP: true, EMAIL: false },
billing: { IN_APP: true, EMAIL: false },
team: { IN_APP: true, EMAIL: false },
},
});
});
it("returns bounded 400 JSON for an invalid category without calling upsert", async () => {
const form = preferenceForm({ category: "security" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference category." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("returns bounded 400 JSON for an invalid notification action without calling upsert", async () => {
const form = preferenceForm({ action: "delete-preference" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference action." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("returns bounded 400 JSON for an invalid channel without calling upsert", async () => {
const form = preferenceForm({ channel: "SMS" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(response.status).toBe(400);
expect(body).toEqual({ error: "Invalid notification preference channel." });
expect(upsertUserNotificationPreference).not.toHaveBeenCalled();
});
it("writes a valid preference update with tenant, user, normalized category, channel, and enabled state", async () => {
const form = preferenceForm({ category: " Team ", channel: "in-app", enabled: "true" });
const response = (await action(routeArgs(postFormRequest(form)))) as Response;
const body = await response.json();
expect(requireAuth).toHaveBeenCalledWith({ request: expect.any(Request), params });
expect(getTenantIdFromUrl).toHaveBeenCalledWith(params);
expect(getUserInfo).toHaveBeenCalledWith(expect.any(Request));
expect(upsertUserNotificationPreference).toHaveBeenCalledWith({
tenantId: "tenant_1",
userId: "user_1",
channel: "IN_APP",
category: "team",
enabled: true,
});
expect(body).toEqual({ ok: true });
});
it("renders compact controls for default, billing, and team notification preferences", () => {
render(
<MemoryRouter>
<WorkspaceNotificationSettingsRoute />
</MemoryRouter>,
);
expect(screen.getByRole("heading", { name: "Notification preferences" })).toBeInTheDocument();
expect(screen.getByText("Preferences are scoped to your current workspace and user account.", { exact: false })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Default" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Billing" })).toBeInTheDocument();
expect(screen.getByRole("heading", { name: "Team" })).toBeInTheDocument();
expect(screen.getAllByLabelText("In-app")).toHaveLength(3);
expect(screen.getAllByLabelText("Email")).toHaveLength(3);
expect(screen.getByLabelText("Email", { selector: "input#notification-billing-EMAIL" })).not.toBeChecked();
expect(screen.getByLabelText("In-app", { selector: "input#notification-team-IN_APP" })).not.toBeChecked();
});
});