chore: adding test coverage for dashboards/charts CRUD actions

apps/web/modules/ee/analysis/api/lib/cube-client.test.ts

@@ -27,4 +27,17 @@ describe("executeQuery", () => {
     expect(mockTablePivot).toHaveBeenCalled();
     expect(result).toEqual([{ id: "1", count: 42 }]);
   });
+
+  test("preserves API URL when it already contains /cubejs-api/v1", async () => {
+    const fullUrl = "https://cube.example.com/cubejs-api/v1";
+    vi.stubEnv("CUBEJS_API_URL", fullUrl);
+    const { executeQuery } = await import("./cube-client");
+
+    await executeQuery({ measures: ["FeedbackRecords.count"] });
+
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const cubejs = ((await vi.importMock("@cubejs-client/core")) as any).default;
+    expect(cubejs).toHaveBeenCalledWith(expect.any(String), { apiUrl: fullUrl });
+    vi.unstubAllEnvs();
+  });
 });

apps/web/modules/ee/analysis/charts/lib/charts.test.ts

@@ -0,0 +1,288 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { prisma } from "@formbricks/database";
+
+vi.mock("server-only", () => ({}));
+
+var mockTxChart: {
+  // NOSONAR / test code
+  findFirst: ReturnType<typeof vi.fn>;
+  update: ReturnType<typeof vi.fn>;
+  delete: ReturnType<typeof vi.fn>;
+};
+
+vi.mock("@formbricks/database", () => {
+  const tx = {
+    findFirst: vi.fn(),
+    update: vi.fn(),
+    delete: vi.fn(),
+  };
+  mockTxChart = tx;
+  return {
+    prisma: {
+      chart: {
+        create: vi.fn(),
+        findFirst: vi.fn(),
+        findMany: vi.fn(),
+      },
+      $transaction: vi.fn((cb: any) => cb({ chart: tx })),
+    },
+  };
+});
+
+vi.mock("@/lib/utils/validate", () => ({
+  validateInputs: vi.fn(),
+}));
+
+const mockChartId = "chart-abc-123";
+const mockProjectId = "project-abc-123";
+const mockUserId = "user-abc-123";
+
+const mockChart = {
+  id: mockChartId,
+  name: "Test Chart",
+  type: "bar",
+  query: { measures: ["Responses.count"] },
+  config: { showLegend: true },
+  projectId: mockProjectId,
+  createdBy: mockUserId,
+  createdAt: new Date("2025-01-01"),
+  updatedAt: new Date("2025-01-01"),
+};
+
+describe("Chart Service", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("createChart", () => {
+    test("creates a chart successfully", async () => {
+      vi.mocked(prisma.chart.create).mockResolvedValue(mockChart as any);
+      const { createChart } = await import("./charts");
+
+      const result = await createChart({
+        projectId: mockProjectId,
+        name: "Test Chart",
+        type: "bar",
+        query: { measures: ["Responses.count"] },
+        config: { showLegend: true },
+        createdBy: mockUserId,
+      });
+
+      expect(result).toEqual(mockChart);
+      expect(prisma.chart.create).toHaveBeenCalledWith({
+        data: {
+          name: "Test Chart",
+          type: "bar",
+          projectId: mockProjectId,
+          query: { measures: ["Responses.count"] },
+          config: { showLegend: true },
+          createdBy: mockUserId,
+        },
+      });
+    });
+  });
+
+  describe("updateChart", () => {
+    test("updates a chart successfully", async () => {
+      const updatedChart = { ...mockChart, name: "Updated Chart" };
+      mockTxChart.findFirst.mockResolvedValue(mockChart);
+      mockTxChart.update.mockResolvedValue(updatedChart);
+      const { updateChart } = await import("./charts");
+
+      const result = await updateChart(mockChartId, mockProjectId, { name: "Updated Chart" });
+
+      expect(result).toEqual({ chart: mockChart, updatedChart });
+      expect(mockTxChart.findFirst).toHaveBeenCalledWith({
+        where: { id: mockChartId, projectId: mockProjectId },
+      });
+      expect(mockTxChart.update).toHaveBeenCalledWith({
+        where: { id: mockChartId },
+        data: { name: "Updated Chart", type: undefined, query: undefined, config: undefined },
+      });
+    });
+
+    test("throws ResourceNotFoundError when chart does not exist", async () => {
+      mockTxChart.findFirst.mockResolvedValue(null);
+      const { updateChart } = await import("./charts");
+
+      await expect(updateChart(mockChartId, mockProjectId, { name: "Updated" })).rejects.toMatchObject({
+        name: "ResourceNotFoundError",
+        resourceType: "Chart",
+        resourceId: mockChartId,
+      });
+      expect(mockTxChart.update).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("duplicateChart", () => {
+    test("duplicates a chart with '(copy)' suffix", async () => {
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(mockChart as any);
+      vi.mocked(prisma.chart.findMany).mockResolvedValue([]);
+      vi.mocked(prisma.chart.create).mockResolvedValue({ ...mockChart, name: "Test Chart (copy)" } as any);
+      const { duplicateChart } = await import("./charts");
+
+      await duplicateChart(mockChartId, mockProjectId, mockUserId);
+
+      expect(prisma.chart.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ name: "Test Chart (copy)" }),
+      });
+    });
+
+    test("increments copy number when '(copy)' already exists", async () => {
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(mockChart as any);
+      vi.mocked(prisma.chart.findMany).mockResolvedValue([{ name: "Test Chart (copy)" }] as any);
+      vi.mocked(prisma.chart.create).mockResolvedValue({
+        ...mockChart,
+        name: "Test Chart (copy 2)",
+      } as any);
+      const { duplicateChart } = await import("./charts");
+
+      await duplicateChart(mockChartId, mockProjectId, mockUserId);
+
+      expect(prisma.chart.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ name: "Test Chart (copy 2)" }),
+      });
+    });
+
+    test("finds next available copy number", async () => {
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(mockChart as any);
+      vi.mocked(prisma.chart.findMany).mockResolvedValue([
+        { name: "Test Chart (copy)" },
+        { name: "Test Chart (copy 2)" },
+      ] as any);
+      vi.mocked(prisma.chart.create).mockResolvedValue({
+        ...mockChart,
+        name: "Test Chart (copy 3)",
+      } as any);
+      const { duplicateChart } = await import("./charts");
+
+      await duplicateChart(mockChartId, mockProjectId, mockUserId);
+
+      expect(prisma.chart.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({ name: "Test Chart (copy 3)" }),
+      });
+    });
+
+    test("strips existing copy suffix before generating new name", async () => {
+      const chartWithCopy = { ...mockChart, name: "Test Chart (copy)" };
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(chartWithCopy as any);
+      vi.mocked(prisma.chart.findMany).mockResolvedValue([{ name: "Test Chart (copy)" }] as any);
+      vi.mocked(prisma.chart.create).mockResolvedValue({
+        ...mockChart,
+        name: "Test Chart (copy 2)",
+      } as any);
+      const { duplicateChart } = await import("./charts");
+
+      await duplicateChart(mockChartId, mockProjectId, mockUserId);
+
+      expect(prisma.chart.findMany).toHaveBeenCalledWith({
+        where: { projectId: mockProjectId, name: { startsWith: "Test Chart (copy" } },
+        select: { name: true },
+      });
+    });
+
+    test("throws ResourceNotFoundError when source chart does not exist", async () => {
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(null);
+      const { duplicateChart } = await import("./charts");
+
+      await expect(duplicateChart(mockChartId, mockProjectId, mockUserId)).rejects.toMatchObject({
+        name: "ResourceNotFoundError",
+        resourceType: "Chart",
+        resourceId: mockChartId,
+      });
+    });
+  });
+
+  describe("deleteChart", () => {
+    test("deletes a chart successfully", async () => {
+      mockTxChart.findFirst.mockResolvedValue(mockChart);
+      mockTxChart.delete.mockResolvedValue(undefined);
+      const { deleteChart } = await import("./charts");
+
+      const result = await deleteChart(mockChartId, mockProjectId);
+
+      expect(result).toEqual(mockChart);
+      expect(mockTxChart.delete).toHaveBeenCalledWith({ where: { id: mockChartId } });
+    });
+
+    test("throws ResourceNotFoundError when chart does not exist", async () => {
+      mockTxChart.findFirst.mockResolvedValue(null);
+      const { deleteChart } = await import("./charts");
+
+      await expect(deleteChart(mockChartId, mockProjectId)).rejects.toMatchObject({
+        name: "ResourceNotFoundError",
+        resourceType: "Chart",
+        resourceId: mockChartId,
+      });
+      expect(mockTxChart.delete).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("getChart", () => {
+    test("returns a chart successfully", async () => {
+      const chartResult = {
+        id: mockChartId,
+        name: "Test Chart",
+        type: "bar",
+        query: { measures: ["Responses.count"] },
+        config: { showLegend: true },
+        createdAt: new Date("2025-01-01"),
+        updatedAt: new Date("2025-01-01"),
+      };
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(chartResult as any);
+      const { getChart } = await import("./charts");
+
+      const result = await getChart(mockChartId, mockProjectId);
+
+      expect(result).toEqual(chartResult);
+      expect(prisma.chart.findFirst).toHaveBeenCalledWith({
+        where: { id: mockChartId, projectId: mockProjectId },
+        select: expect.objectContaining({ id: true, name: true, type: true }),
+      });
+    });
+
+    test("throws ResourceNotFoundError when chart does not exist", async () => {
+      vi.mocked(prisma.chart.findFirst).mockResolvedValue(null);
+      const { getChart } = await import("./charts");
+
+      await expect(getChart(mockChartId, mockProjectId)).rejects.toMatchObject({
+        name: "ResourceNotFoundError",
+        resourceType: "Chart",
+        resourceId: mockChartId,
+      });
+    });
+  });
+
+  describe("getCharts", () => {
+    test("returns all charts for a project", async () => {
+      const charts = [
+        { ...mockChart, widgets: [{ dashboardId: "dash-1" }] },
+        { ...mockChart, id: "chart-2", name: "Chart 2", widgets: [] },
+      ];
+      vi.mocked(prisma.chart.findMany).mockResolvedValue(charts as any);
+      const { getCharts } = await import("./charts");
+
+      const result = await getCharts(mockProjectId);
+
+      expect(result).toEqual(charts);
+      expect(prisma.chart.findMany).toHaveBeenCalledWith({
+        where: { projectId: mockProjectId },
+        orderBy: { createdAt: "desc" },
+        select: expect.objectContaining({
+          id: true,
+          name: true,
+          widgets: { select: { dashboardId: true } },
+        }),
+      });
+    });
+
+    test("returns empty array when no charts exist", async () => {
+      vi.mocked(prisma.chart.findMany).mockResolvedValue([]);
+      const { getCharts } = await import("./charts");
+
+      const result = await getCharts(mockProjectId);
+
+      expect(result).toEqual([]);
+    });
+  });
+});

apps/web/modules/ee/analysis/lib/access.test.ts

@@ -0,0 +1,73 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+
+vi.mock("server-only", () => ({}));
+
+const mockGetEnvironment = vi.fn();
+const mockGetOrganizationIdFromProjectId = vi.fn();
+const mockCheckAuthorizationUpdated = vi.fn();
+
+vi.mock("@/lib/environment/service", () => ({
+  getEnvironment: (...args: any[]) => mockGetEnvironment(...args),
+}));
+
+vi.mock("@/lib/utils/helper", () => ({
+  getOrganizationIdFromProjectId: (...args: any[]) => mockGetOrganizationIdFromProjectId(...args),
+}));
+
+vi.mock("@/lib/utils/action-client/action-client-middleware", () => ({
+  checkAuthorizationUpdated: (...args: any[]) => mockCheckAuthorizationUpdated(...args),
+}));
+
+const mockUserId = "user-abc-123";
+const mockEnvironmentId = "env-abc-123";
+const mockProjectId = "project-abc-123";
+const mockOrganizationId = "org-abc-123";
+
+describe("checkProjectAccess", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("returns organizationId and projectId on successful access check", async () => {
+    mockGetEnvironment.mockResolvedValue({ projectId: mockProjectId });
+    mockGetOrganizationIdFromProjectId.mockResolvedValue(mockOrganizationId);
+    mockCheckAuthorizationUpdated.mockResolvedValue(undefined);
+    const { checkProjectAccess } = await import("./access");
+
+    const result = await checkProjectAccess(mockUserId, mockEnvironmentId, "readWrite");
+
+    expect(result).toEqual({ organizationId: mockOrganizationId, projectId: mockProjectId });
+    expect(mockGetEnvironment).toHaveBeenCalledWith(mockEnvironmentId);
+    expect(mockGetOrganizationIdFromProjectId).toHaveBeenCalledWith(mockProjectId);
+    expect(mockCheckAuthorizationUpdated).toHaveBeenCalledWith({
+      userId: mockUserId,
+      organizationId: mockOrganizationId,
+      access: [
+        { type: "organization", roles: ["owner", "manager"] },
+        { type: "projectTeam", minPermission: "readWrite", projectId: mockProjectId },
+      ],
+    });
+  });
+
+  test("throws ResourceNotFoundError when environment is not found", async () => {
+    mockGetEnvironment.mockResolvedValue(null);
+    const { checkProjectAccess } = await import("./access");
+
+    await expect(checkProjectAccess(mockUserId, mockEnvironmentId, "read")).rejects.toMatchObject({
+      name: "ResourceNotFoundError",
+      resourceType: "environment",
+      resourceId: mockEnvironmentId,
+    });
+    expect(mockGetOrganizationIdFromProjectId).not.toHaveBeenCalled();
+    expect(mockCheckAuthorizationUpdated).not.toHaveBeenCalled();
+  });
+
+  test("propagates authorization errors from checkAuthorizationUpdated", async () => {
+    mockGetEnvironment.mockResolvedValue({ projectId: mockProjectId });
+    mockGetOrganizationIdFromProjectId.mockResolvedValue(mockOrganizationId);
+    mockCheckAuthorizationUpdated.mockRejectedValue(new Error("Unauthorized"));
+    const { checkProjectAccess } = await import("./access");
+
+    await expect(checkProjectAccess(mockUserId, mockEnvironmentId, "manage")).rejects.toThrow("Unauthorized");
+  });
+});

apps/web/modules/ee/audit-logs/lib/handler.test.ts

@@ -229,4 +229,49 @@ describe("withAuditLogging", () => {
     // Reset for other tests; clearAllMockHandles will also do this in the next beforeEach
     if (mutableConstants) mutableConstants.AUDIT_LOG_ENABLED = true;
   });
+
+  test("resolves targetId for chart target type", async () => {
+    const chartCtx = {
+      ...mockCtxBase,
+      auditLoggingCtx: { ...mockCtxBase.auditLoggingCtx, chartId: "chart-1" },
+    };
+    const handlerImpl = vi.fn().mockResolvedValue("ok");
+    const wrapped = OriginalHandler.withAuditLogging("created", "chart", handlerImpl);
+    await wrapped({ ctx: chartCtx as any, parsedInput: mockParsedInput });
+    await new Promise(setImmediate);
+    expect(serviceLogAuditEventMockHandle).toHaveBeenCalled();
+    const callArgs = serviceLogAuditEventMockHandle.mock.calls[0][0];
+    expect(callArgs.target.type).toBe("chart");
+    expect(callArgs.target.id).toBe("chart-1");
+  });
+
+  test("resolves targetId for dashboard target type", async () => {
+    const dashCtx = {
+      ...mockCtxBase,
+      auditLoggingCtx: { ...mockCtxBase.auditLoggingCtx, dashboardId: "dash-1" },
+    };
+    const handlerImpl = vi.fn().mockResolvedValue("ok");
+    const wrapped = OriginalHandler.withAuditLogging("created", "dashboard", handlerImpl);
+    await wrapped({ ctx: dashCtx as any, parsedInput: mockParsedInput });
+    await new Promise(setImmediate);
+    expect(serviceLogAuditEventMockHandle).toHaveBeenCalled();
+    const callArgs = serviceLogAuditEventMockHandle.mock.calls[0][0];
+    expect(callArgs.target.type).toBe("dashboard");
+    expect(callArgs.target.id).toBe("dash-1");
+  });
+
+  test("resolves targetId for dashboardWidget target type", async () => {
+    const widgetCtx = {
+      ...mockCtxBase,
+      auditLoggingCtx: { ...mockCtxBase.auditLoggingCtx, dashboardWidgetId: "widget-1" },
+    };
+    const handlerImpl = vi.fn().mockResolvedValue("ok");
+    const wrapped = OriginalHandler.withAuditLogging("created", "dashboardWidget", handlerImpl);
+    await wrapped({ ctx: widgetCtx as any, parsedInput: mockParsedInput });
+    await new Promise(setImmediate);
+    expect(serviceLogAuditEventMockHandle).toHaveBeenCalled();
+    const callArgs = serviceLogAuditEventMockHandle.mock.calls[0][0];
+    expect(callArgs.target.type).toBe("dashboardWidget");
+    expect(callArgs.target.id).toBe("widget-1");
+  });
 });