test: add test coverage

Author: RavelloH

package.json

@@ -152,7 +152,7 @@
   },
   "lint-staged": {
     "*.{js,jsx,ts,tsx}": [
-      "eslint --fix --max-warnings 0",
+      "eslint --fix --max-warnings 0 --no-warn-ignored",
       "prettier --write"
     ],
     "*.{json,css}": "prettier --write"

src/lib/__tests__/edge-client.test.ts

@@ -18,12 +18,14 @@ import {
   fetchAdminTeams,
   fetchAdminUsers,
   fetchNotificationEmailConfig,
+  fetchNotificationEmailPreview,
   fetchNotificationMessages,
   fetchNotificationPreferences,
   fetchNotificationRules,
   fetchPublicOverview,
   fetchPublicPages,
   fetchPublicReferrers,
+  fetchPublicSite,
   fetchPublicTrend,
   loginAdminAccount,
   markAllNotificationMessagesRead,
@@ -46,6 +48,7 @@ import {
   upsertAdminSiteConfig,
 } from "@/lib/edge-client";
 import { handleDemoRequest } from "@/lib/realtime/mock";
+import { handleDemoNotificationEmailPreview } from "@/lib/realtime/mock/notification-email-preview";
 
 vi.mock("@/lib/auth", () => ({
   getSessionToken: vi.fn(),
@@ -55,7 +58,14 @@ vi.mock("@/lib/realtime/mock", () => ({
   handleDemoRequest: vi.fn(),
 }));
 
+vi.mock("@/lib/realtime/mock/notification-email-preview", () => ({
+  handleDemoNotificationEmailPreview: vi.fn(),
+}));
+
 const getSessionTokenMock = vi.mocked(getSessionToken);
+const handleDemoNotificationEmailPreviewMock = vi.mocked(
+  handleDemoNotificationEmailPreview,
+);
 const handleDemoRequestMock = vi.mocked(handleDemoRequest);
 
 function fetchMock() {
@@ -121,6 +131,35 @@ describe("edge client request wrappers", () => {
     expect(getSessionTokenMock).not.toHaveBeenCalled();
   });
 
+  it("unwraps public site metadata and rejects missing public sites", async () => {
+    fetchMock().mockResolvedValueOnce(
+      jsonResponse({
+        ok: true,
+        data: {
+          id: "site-1",
+          slug: "public-site",
+          name: "Public Site",
+          domain: "example.test",
+        },
+      }),
+    );
+
+    await expect(fetchPublicSite("public site")).resolves.toEqual({
+      id: "site-1",
+      slug: "public-site",
+      name: "Public Site",
+      domain: "example.test",
+    });
+    expect(lastFetchCall()[0]).toBe(
+      "http://127.0.0.1:8787/api/public/share/public%20site/site",
+    );
+
+    fetchMock().mockResolvedValueOnce(jsonResponse({ ok: false, data: null }));
+    await expect(fetchPublicSite("missing")).rejects.toThrow(
+      "Public site not found",
+    );
+  });
+
   it("encodes public slugs and query params", async () => {
     await fetchPublicOverview("public/site?draft=true", { from: 0, to: 1 });
 
@@ -558,6 +597,64 @@ describe("edge client request wrappers", () => {
     );
   });
 
+  it("fetches notification email previews in every supported format", async () => {
+    fetchMock().mockResolvedValueOnce(
+      jsonResponse({
+        ok: true,
+        data: {
+          subject: "Demo subject",
+          html: "<p>Demo</p>",
+          text: "Demo",
+        },
+      }),
+    );
+
+    await expect(
+      fetchNotificationEmailPreview({
+        type: "report",
+        locale: "en",
+        format: "json",
+      }),
+    ).resolves.toEqual({
+      subject: "Demo subject",
+      html: "<p>Demo</p>",
+      text: "Demo",
+    });
+    expect(new URL(lastFetchCall()[0]).searchParams.get("format")).toBe("json");
+
+    fetchMock().mockResolvedValueOnce(new Response("<p>HTML</p>"));
+    await expect(
+      fetchNotificationEmailPreview({
+        type: "health",
+        locale: "zh",
+        format: "html",
+      }),
+    ).resolves.toBe("<p>HTML</p>");
+
+    fetchMock().mockResolvedValueOnce(new Response("plain text"));
+    await expect(
+      fetchNotificationEmailPreview({
+        type: "threshold",
+        locale: "en",
+        format: "text",
+      }),
+    ).resolves.toBe("plain text");
+  });
+
+  it("throws descriptive errors for failed notification email previews", async () => {
+    fetchMock().mockResolvedValueOnce(
+      new Response("preview denied", { status: 403 }),
+    );
+
+    await expect(
+      fetchNotificationEmailPreview({
+        type: "test",
+        locale: "en",
+        format: "html",
+      }),
+    ).rejects.toThrow("Email preview failed (403): preview denied");
+  });
+
   it("throws descriptive errors for non-OK edge responses", async () => {
     fetchMock().mockResolvedValueOnce(new Response("denied", { status: 403 }));
 
@@ -712,6 +809,34 @@ describe("edge client request wrappers", () => {
     expect(getSessionTokenMock).not.toHaveBeenCalled();
   });
 
+  it("delegates notification email previews to the demo handler in demo mode", async () => {
+    vi.stubEnv("NEXT_PUBLIC_DEMO_MODE", "1");
+    const preview = {
+      subject: "Demo",
+      html: "<p>Demo</p>",
+      text: "Demo",
+    };
+    const mockModule =
+      await import("@/lib/realtime/mock/notification-email-preview");
+    vi.mocked(mockModule.handleDemoNotificationEmailPreview).mockResolvedValue(
+      preview,
+    );
+
+    await expect(
+      fetchNotificationEmailPreview({
+        type: "test",
+        locale: "en",
+        format: "json",
+      }),
+    ).resolves.toBe(preview);
+    expect(mockModule.handleDemoNotificationEmailPreview).toHaveBeenCalledWith({
+      type: "test",
+      locale: "en",
+      format: "json",
+    });
+    expect(fetchMock()).not.toHaveBeenCalled();
+  });
+
   it("wires the edge-client filter helper into at least one exported request wrapper", () => {
     const source = readFileSync("src/lib/edge-client.ts", "utf8");
     const callSites = source.match(/\bwithFilters\s*\(/g) ?? [];

src/lib/dashboard/__tests__/client-core-data.test.ts

@@ -1,13 +1,16 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
+  createFunnel,
+  deleteFunnel,
   fetchEventRecordDetail,
   fetchEventsRecords,
   fetchEventsSummary,
   fetchEventsTrend,
   fetchEventTypeDetail,
   fetchEventTypeFieldValues,
   fetchFunnelDetail,
+  fetchFunnels,
   fetchPerformance,
   fetchSessionDetail,
   fetchSessions,
@@ -223,12 +226,49 @@ describe("fetchSessionDetail", () => {
 });
 
 describe("fetchFunnelDetail", () => {
+  it("fetches funnel lists by site", async () => {
+    fetchPrivateJsonMock.mockResolvedValueOnce({ funnels: [] } as any);
+
+    await fetchFunnels("site-1");
+
+    expect(fetchPrivateJsonMock).toHaveBeenCalledWith("/api/private/funnels", {
+      siteId: "site-1",
+    });
+  });
+
   it("throws for empty funnelId", async () => {
     await expect(fetchFunnelDetail("site-1", "  ", window)).rejects.toThrow(
       "Funnel id is required",
     );
     expect(fetchPrivateJsonMock).not.toHaveBeenCalled();
   });
+
+  it("creates and deletes funnels through mutation requests", async () => {
+    fetchPrivateJsonMutateMock.mockResolvedValueOnce({ ok: true } as any);
+    fetchPrivateJsonMutateMock.mockResolvedValueOnce({ ok: true } as any);
+
+    await createFunnel("site-1", "Signup", [
+      { id: "step-1", type: "page", value: "/signup" },
+    ] as any);
+    await deleteFunnel("site-1", "funnel-1");
+
+    expect(fetchPrivateJsonMutateMock).toHaveBeenNthCalledWith(
+      1,
+      "/api/private/funnels",
+      "POST",
+      { siteId: "site-1" },
+      {
+        name: "Signup",
+        steps: [{ id: "step-1", type: "page", value: "/signup" }],
+      },
+    );
+    expect(fetchPrivateJsonMutateMock).toHaveBeenNthCalledWith(
+      2,
+      "/api/private/funnels",
+      "DELETE",
+      { siteId: "site-1", id: "funnel-1" },
+    );
+  });
 });
 
 describe("fetchEventTypeDetail", () => {

src/lib/dashboard/__tests__/format.test.ts

@@ -7,6 +7,7 @@ import {
   percentFormat,
   shortDate,
   shortDateTime,
+  shortDateTimeWithSeconds,
 } from "@/lib/dashboard/format";
 
 describe("Dashboard Format Utilities", () => {
@@ -90,6 +91,7 @@ describe("Dashboard Format Utilities", () => {
       const isoStr = "2026-05-25T03:43:43Z";
       expect(shortDate("en", isoStr, "UTC")).toContain("May");
       expect(shortDateTime("en", isoStr, "UTC")).toContain("43");
+      expect(shortDateTimeWithSeconds("en", isoStr, "UTC")).toContain("43");
     });
 
     it("should format without a timezone override when one is not provided", () => {

src/lib/edge-client.ts

@@ -734,7 +734,7 @@ export async function fetchNotificationEmailPreview(input: {
 > {
   if (process.env.NEXT_PUBLIC_DEMO_MODE === "1") {
     const { handleDemoNotificationEmailPreview } =
-      await import("@/lib/realtime/mock");
+      await import("@/lib/realtime/mock/notification-email-preview");
     return handleDemoNotificationEmailPreview(input);
   }
   const baseUrl = await edgeBaseUrl();

src/lib/edge/__tests__/admin-notifications.test.ts

@@ -1,6 +1,7 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
 import {
+  handleNotificationEmailPreviewAdmin,
   handleNotificationPreferences,
   handleNotificationRead,
   handleNotificationRulePreviewAdmin,
@@ -31,6 +32,7 @@ const createManualTestNotification = vi.hoisted(() => vi.fn());
 const createNotificationRulePreview = vi.hoisted(() => vi.fn());
 const runNotificationRuleManually = vi.hoisted(() => vi.fn());
 const runScheduledTask = vi.hoisted(() => vi.fn());
+const renderNotificationEmail = vi.hoisted(() => vi.fn());
 
 vi.mock("@/lib/edge/admin-auth", () => ({
   requireActor,
@@ -75,6 +77,10 @@ vi.mock("@/lib/edge/scheduled-task-runner", () => ({
   runScheduledTask,
 }));
 
+vi.mock("@/lib/notifications/email-renderer", () => ({
+  renderNotificationEmail,
+}));
+
 function request(path: string, body: Record<string, unknown>): Request {
   return new Request(`https://edge.test${path}`, {
     method: "POST",
@@ -141,6 +147,11 @@ describe("admin notification handlers", () => {
       summary: { emailFailed: 0 },
       messageCount: 0,
     });
+    renderNotificationEmail.mockResolvedValue({
+      subject: "Preview",
+      html: "<p>Preview</p>",
+      text: "Preview text",
+    });
     createManualTestNotification.mockResolvedValue({
       message: { id: "msg-test", deliveryStatus: "sent" },
       summary: { messagesCreated: 1 },
@@ -723,13 +734,78 @@ describe("admin notification handlers", () => {
         request("/api/private/admin/notifications/test", { teamId: "team-1" }),
         {} as never,
       ),
+      handleNotificationEmailPreviewAdmin(
+        getRequest("/api/private/admin/notification-email-preview"),
+        {} as never,
+        new URL(
+          "https://edge.test/api/private/admin/notification-email-preview",
+        ),
+      ),
     ]);
 
     expect(responses.map((response) => response.status)).toEqual([
-      401, 401, 401, 401, 401, 401, 401,
+      401, 401, 401, 401, 401, 401, 401, 401,
     ]);
   });
 
+  it("renders notification email previews for admins", async () => {
+    requireActor.mockResolvedValue({
+      user: { id: "admin-1" },
+      isAdmin: true,
+    });
+
+    const html = await handleNotificationEmailPreviewAdmin(
+      getRequest("/api/private/admin/notification-email-preview?type=bad"),
+      {} as never,
+      new URL(
+        "https://edge.test/api/private/admin/notification-email-preview?type=bad&locale=bad",
+      ),
+    );
+    const text = await handleNotificationEmailPreviewAdmin(
+      getRequest("/api/private/admin/notification-email-preview?format=text"),
+      {} as never,
+      new URL(
+        "https://edge.test/api/private/admin/notification-email-preview?type=health&format=text",
+      ),
+    );
+    const json = await handleNotificationEmailPreviewAdmin(
+      getRequest("/api/private/admin/notification-email-preview?format=json"),
+      {} as never,
+      new URL(
+        "https://edge.test/api/private/admin/notification-email-preview?type=test&format=json",
+      ),
+    );
+
+    expect(html.headers.get("content-type")).toContain("text/html");
+    expect(await html.text()).toBe("<p>Preview</p>");
+    expect(await text.text()).toBe("Preview text");
+    expect(await json.json()).toMatchObject({
+      ok: true,
+      data: { subject: "Preview" },
+    });
+    expect(renderNotificationEmail).toHaveBeenCalledTimes(3);
+  });
+
+  it("rejects non-admin and non-GET email preview requests", async () => {
+    const forbidden = await handleNotificationEmailPreviewAdmin(
+      getRequest("/api/private/admin/notification-email-preview"),
+      {} as never,
+      new URL("https://edge.test/api/private/admin/notification-email-preview"),
+    );
+    requireActor.mockResolvedValueOnce({
+      user: { id: "admin-1" },
+      isAdmin: true,
+    });
+    const method = await handleNotificationEmailPreviewAdmin(
+      methodRequest("POST", "/api/private/admin/notification-email-preview"),
+      {} as never,
+      new URL("https://edge.test/api/private/admin/notification-email-preview"),
+    );
+
+    expect(forbidden.status).toBe(403);
+    expect(method.status).toBe(405);
+  });
+
   it("returns method and validation errors for preferences and read handlers", async () => {
     const unsupportedPreferences = await handleNotificationPreferences(
       methodRequest("POST", "/api/private/notification-preferences", {}),