Skip to content

🐸 Rybbit - open-source and privacy-friendly alternative to Google Analytics that is 10x more intuitive.

3.9 KB
Raw Blame
import { ClickHouseError } from "@clickhouse/client";
import Fastify, { FastifyInstance } from "fastify";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

const mocks = vi.hoisted(() => ({
  query: vi.fn(),
  getOrganizationSitesForCaller: vi.fn(),
  isQueryUserIsolated: vi.fn(async () => true),
}));
vi.mock("../../db/clickhouse/clickhouse.js", () => ({ clickhouseQuery: { query: mocks.query } }));
vi.mock("../../db/clickhouse/queryUser.js", async importOriginal => ({
  ...(await importOriginal<typeof import("../../db/clickhouse/queryUser.js")>()),
  isQueryUserIsolated: mocks.isQueryUserIsolated,
}));
vi.mock("../../lib/auth-utils.js", () => ({ getOrganizationSitesForCaller: mocks.getOrganizationSitesForCaller }));

import { runCustomQuery } from "./runCustomQuery.js";
import { runDashboardCardQuery } from "./runDashboardCardQuery.js";

let app: FastifyInstance;

beforeEach(async () => {
  vi.resetAllMocks();
  mocks.getOrganizationSitesForCaller.mockResolvedValue([{ siteId: 1, organizationId: "org-1" }]);
  mocks.isQueryUserIsolated.mockResolvedValue(true);
  app = Fastify();
  app.post<{ Params: { organizationId: string }; Body: unknown }>(
    "/organizations/:organizationId/query",
    runCustomQuery
  );
  app.post<{ Params: { siteId: string }; Body: unknown }>("/sites/:siteId/run-card", runDashboardCardQuery);
  await app.ready();
});

afterEach(async () => {
  await app.close();
});

describe.each(["/organizations/org-1/query", "/sites/1/run-card"])("custom SQL response at %s", url => {
  const request = () => app.inject({ method: "POST", url, payload: { query: "SELECT count() FROM scoped_events" } });

  it.each(["query", "json"])("returns an actionable SDK timeout raised during %s", async stage => {
    const error = new ClickHouseError({
      code: "159",
      type: "TIMEOUT_EXCEEDED",
      message: "Timeout exceeded: elapsed 60040 ms, maximum: 60000 ms.",
    });
    if (stage === "query") {
      mocks.query.mockRejectedValue(error);
    } else {
      mocks.query.mockResolvedValue({
        json: async () => {
          throw error;
        },
      });
    }

    const response = await request();
    expect(response.statusCode).toBe(400);
    expect(response.json()).toEqual({
      error: "Query exceeded the 60-second time limit. Try a shorter date range or simplify the query.",
    });
  });

  it("returns the SQL error instead of a generic failure", async () => {
    mocks.query.mockRejectedValue(
      new ClickHouseError({
        code: "47",
        type: "UNKNOWN_IDENTIFIER",
        message: "Unknown expression identifier 'missing_column'",
      })
    );

    const response = await request();
    expect(response.statusCode).toBe(400);
    expect(response.json()).toEqual({ error: "Unknown expression identifier 'missing_column'" });
  });

  it("sends the caller's site ids for the rybbit_query row policy", async () => {
    mocks.query.mockResolvedValue({ query_id: "test-query", json: async () => [] });
    await request();
    expect(mocks.query).toHaveBeenCalledWith(
      expect.objectContaining({
        http_headers: { "X-Rybbit-Site-Ids": "[1]" },
        query_params: expect.objectContaining({ siteIds: [1] }),
      })
    );
  });

  it("refuses to run while the query user's row policy is unverified", async () => {
    mocks.isQueryUserIsolated.mockResolvedValue(false);
    const response = await request();
    expect(response.statusCode).toBe(503);
    expect(mocks.query).not.toHaveBeenCalled();
  });

  it("reports the 60-second execution limit for successful queries", async () => {
    mocks.query.mockResolvedValue({ query_id: "test-query", json: async () => [{ count: 1 }] });
    const response = await request();
    expect(response.statusCode).toBe(200);
    expect(response.json().meta).toEqual({
      queryId: "test-query",
      rowCount: 1,
      maxExecutionTimeSeconds: 60,
      maxRows: 1000,
    });
  });
});