Skip to content

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

13.9 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from "vitest";

/**
 * Exercises the segment auth rules end to end through the real handlers, with
 * the Postgres layer, the site-access lookup, and the org membership lookup
 * replaced by fixtures. The rule under test: anyone with site access can read
 * and apply; admins and owners create, edit, and delete anything; members
 * create their own and edit only those; viewers without access see only
 * public segments and can never write.
 */
const state = vi.hoisted(() => ({
  site: { organizationId: "org_1" } as { organizationId: string | null } | undefined,
  segments: [] as any[],
  siteAccess: false,
  membership: null as null | { role: string },
  systemAdmin: false,
  // A role on the site above the membership's, as a site grant or team gives.
  siteRole: null as string | null,
  writes: [] as Array<{ op: string; values?: unknown }>,
}));

vi.mock("../../../db/postgres/postgres.js", () => {
  const returningAll = () => Promise.resolve(state.segments);
  return {
    db: {
      query: {
        sites: { findFirst: async () => state.site },
        segments: {
          findFirst: async () => state.segments[0],
          findMany: async () => state.segments,
        },
      },
      insert: () => ({
        values: (values: unknown) => {
          state.writes.push({ op: "insert", values });
          return { returning: () => Promise.resolve([{ segmentId: 99, ...(values as object) }]) };
        },
      }),
      update: () => ({
        set: (values: unknown) => {
          state.writes.push({ op: "update", values });
          return {
            where: () => ({ returning: () => Promise.resolve([{ ...state.segments[0], ...(values as object) }]) }),
          };
        },
      }),
      delete: () => ({
        where: () => {
          state.writes.push({ op: "delete" });
          return { returning: returningAll };
        },
      }),
    },
  };
});

// getUserOrgRole folds system-admin authority into the org role; mirror that.
vi.mock("../../../lib/auth-utils.js", () => ({
  getUserSiteRole: async () =>
    state.siteAccess ? (state.systemAdmin ? "admin" : (state.siteRole ?? state.membership?.role ?? "member")) : null,
  getUserOrgRole: async () => (state.systemAdmin ? "admin" : (state.membership?.role ?? null)),
}));

import { createSegment } from "./createSegment.js";
import { deleteSegment } from "./deleteSegment.js";
import { getSegment } from "./getSegment.js";
import { getSegments } from "./getSegments.js";
import { canEditSegment, canReadSegment, resolveSegmentActor, segmentBelongsToSite } from "./segmentAccess.js";
import { updateSegment } from "./updateSegment.js";

const filters = [{ parameter: "device_type", type: "equals", value: ["Mobile"] }];

const segmentRow = (overrides: Partial<Record<string, unknown>> = {}) => ({
  segmentId: 7,
  organizationId: "org_1",
  siteId: 1,
  userId: "member_1",
  name: "Mobile",
  description: null,
  filters,
  isPublic: false,
  type: "segment",
  createdAt: "2026-09-01T00:00:00Z",
  updatedAt: "2026-09-01T00:00:00Z",
  ...overrides,
});

function fakeRequest(overrides: Record<string, unknown> = {}) {
  return {
    params: { siteId: "1", segmentId: "7" },
    body: {},
    query: {},
    headers: {},
    log: { error: vi.fn() },
    ...overrides,
  } as any;
}

function fakeReply() {
  const reply: any = { statusCode: 200 };
  reply.status = vi.fn((code: number) => {
    reply.statusCode = code;
    return reply;
  });
  reply.send = vi.fn((payload: unknown) => {
    reply.payload = payload;
    return reply;
  });
  return reply;
}

const asMember = (userId = "member_1") => {
  state.siteAccess = true;
  state.membership = { role: "member" };
  return fakeRequest({ user: { id: userId } });
};
const asAdmin = () => {
  state.siteAccess = true;
  state.membership = { role: "admin" };
  return fakeRequest({ user: { id: "admin_1" } });
};
const asViewer = () => {
  state.siteAccess = false;
  state.membership = null;
  return fakeRequest();
};

beforeEach(() => {
  state.site = { organizationId: "org_1" };
  state.segments = [];
  state.siteAccess = false;
  state.membership = null;
  state.systemAdmin = false;
  state.siteRole = null;
  state.writes = [];
});

describe("resolveSegmentActor", () => {
  it("treats an organization API key as an admin of its own org only", async () => {
    const own = await resolveSegmentActor(fakeRequest({ apiKeyOrganizationId: "org_1" }), 1, "org_1");
    expect(own).toEqual({ userId: null, hasSiteAccess: true, canManage: true, canManageSite: true });

    const other = await resolveSegmentActor(fakeRequest({ apiKeyOrganizationId: "org_2" }), 1, "org_1");
    expect(other).toEqual({ userId: null, hasSiteAccess: false, canManage: false, canManageSite: false });
  });

  it("gives an anonymous viewer no access at all", async () => {
    expect(await resolveSegmentActor(fakeRequest(), 1, "org_1")).toEqual({
      userId: null,
      hasSiteAccess: false,
      canManage: false,
      canManageSite: false,
    });
  });

  it("marks org owners, org admins, and system admins as admins", async () => {
    state.siteAccess = true;
    state.membership = { role: "owner" };
    expect((await resolveSegmentActor(fakeRequest({ user: { id: "u" } }), 1, "org_1")).canManage).toBe(true);

    state.membership = { role: "member" };
    expect((await resolveSegmentActor(fakeRequest({ user: { id: "u" } }), 1, "org_1")).canManage).toBe(false);

    state.systemAdmin = true;
    expect((await resolveSegmentActor(fakeRequest({ user: { id: "u" } }), 1, "org_1")).canManage).toBe(true);
  });
});

describe("rule predicates", () => {
  const admin = { userId: "a", hasSiteAccess: true, canManage: true, canManageSite: true };
  const member = { userId: "member_1", hasSiteAccess: true, canManage: false, canManageSite: false };
  const siteEditor = { userId: "e", hasSiteAccess: true, canManage: false, canManageSite: true };
  const viewer = { userId: null, hasSiteAccess: false, canManage: false, canManageSite: false };

  it("reads: site access sees everything, viewers see public only", () => {
    expect(canReadSegment({ isPublic: false }, member)).toBe(true);
    expect(canReadSegment({ isPublic: false }, viewer)).toBe(false);
    expect(canReadSegment({ isPublic: true }, viewer)).toBe(true);
  });

  it("edits: admins edit anything, members only their own, viewers nothing", () => {
    expect(canEditSegment({ userId: "someone_else", siteId: 1 }, admin)).toBe(true);
    expect(canEditSegment({ userId: "member_1", siteId: 1 }, member)).toBe(true);
    expect(canEditSegment({ userId: "someone_else", siteId: 1 }, member)).toBe(false);
    expect(canEditSegment({ userId: null, siteId: 1 }, member)).toBe(false);
    expect(canEditSegment({ userId: null, siteId: 1 }, viewer)).toBe(false);
  });

  it("per-site editors edit the site's segments, but only org-level managers edit org-wide ones", () => {
    expect(canEditSegment({ userId: "someone_else", siteId: 1 }, siteEditor)).toBe(true);
    expect(canEditSegment({ userId: "e", siteId: null }, siteEditor)).toBe(false);
    expect(canEditSegment({ userId: "someone_else", siteId: null }, admin)).toBe(true);
  });

  it("scopes a segment to its own site or its whole organization", () => {
    expect(segmentBelongsToSite({ siteId: 1, organizationId: "org_1" }, 1, "org_1")).toBe(true);
    expect(segmentBelongsToSite({ siteId: null, organizationId: "org_1" }, 2, "org_1")).toBe(true);
    expect(segmentBelongsToSite({ siteId: 2, organizationId: "org_1" }, 1, "org_1")).toBe(false);
    expect(segmentBelongsToSite({ siteId: null, organizationId: "org_2" }, 1, "org_1")).toBe(false);
  });
});

describe("GET /segments", () => {
  it("hides private segments from a public-dashboard viewer and marks nothing editable", async () => {
    state.segments = [segmentRow({ isPublic: true }), segmentRow({ segmentId: 8, isPublic: false })];
    const reply = fakeReply();
    await getSegments(asViewer(), reply);
    expect(reply.statusCode).toBe(200);
    expect(reply.payload.map((s: any) => s.segmentId)).toEqual([7]);
    expect(reply.payload[0].canEdit).toBe(false);
    expect(reply.payload[0].userId).toBeNull();
  });

  it("shows a member every segment and flags only their own as editable", async () => {
    state.segments = [segmentRow({ userId: "member_1" }), segmentRow({ segmentId: 8, userId: "admin_1" })];
    const reply = fakeReply();
    await getSegments(asMember(), reply);
    expect(reply.payload.map((s: any) => [s.segmentId, s.canEdit])).toEqual([
      [7, true],
      [8, false],
    ]);
  });

  it("returns 404 for a site that does not exist", async () => {
    state.site = undefined;
    const reply = fakeReply();
    await getSegments(asMember(), reply);
    expect(reply.statusCode).toBe(404);
  });
});

describe("GET /segments/:id", () => {
  it("answers 404, not 403, when a viewer asks for a private segment", async () => {
    state.segments = [segmentRow({ isPublic: false })];
    const reply = fakeReply();
    await getSegment(asViewer(), reply);
    expect(reply.statusCode).toBe(404);
  });

  it("refuses a segment that belongs to another site", async () => {
    state.segments = [segmentRow({ siteId: 2 })];
    const reply = fakeReply();
    await getSegment(asAdmin(), reply);
    expect(reply.statusCode).toBe(404);
  });
});

describe("POST /segments", () => {
  it("lets a member create a site segment and records them as its owner", async () => {
    const request = asMember();
    request.body = { name: "Mobile", filters };
    const reply = fakeReply();
    await createSegment(request, reply);
    expect(reply.statusCode).toBe(201);
    expect(state.writes[0]).toMatchObject({
      op: "insert",
      values: { organizationId: "org_1", siteId: 1, userId: "member_1", isPublic: false },
    });
    expect(reply.payload.canEdit).toBe(true);
  });

  it("refuses org-wide scope from a member but accepts it from an admin", async () => {
    const memberRequest = asMember();
    memberRequest.body = { name: "Paid", filters, scope: "organization" };
    const memberReply = fakeReply();
    await createSegment(memberRequest, memberReply);
    expect(memberReply.statusCode).toBe(403);
    expect(state.writes).toHaveLength(0);

    const adminRequest = asAdmin();
    adminRequest.body = { name: "Paid", filters, scope: "organization" };
    const adminReply = fakeReply();
    await createSegment(adminRequest, adminReply);
    expect(adminReply.statusCode).toBe(201);
    expect(state.writes[0]).toMatchObject({ values: { siteId: null } });
  });

  it("rejects a body whose filters would not survive the query validator", async () => {
    const request = asAdmin();
    request.body = { name: "Bad", filters: [{ parameter: "session_id", type: "equals", value: ["x"] }] };
    const reply = fakeReply();
    await createSegment(request, reply);
    expect(reply.statusCode).toBe(400);
    expect(reply.payload.error).toBe("Validation error");
    expect(state.writes).toHaveLength(0);
  });

  it("refuses a viewer even if the route guard let them through", async () => {
    const request = asViewer();
    request.body = { name: "Mobile", filters };
    const reply = fakeReply();
    await createSegment(request, reply);
    expect(reply.statusCode).toBe(403);
  });
});

describe("PUT /segments/:id", () => {
  it("lets a member edit their own segment", async () => {
    state.segments = [segmentRow({ userId: "member_1" })];
    const request = asMember();
    request.body = { name: "Renamed" };
    const reply = fakeReply();
    await updateSegment(request, reply);
    expect(reply.statusCode).toBe(200);
    expect(state.writes[0]).toMatchObject({ op: "update", values: { name: "Renamed" } });
  });

  it("stops a member editing someone else's segment", async () => {
    state.segments = [segmentRow({ userId: "admin_1" })];
    const request = asMember();
    request.body = { name: "Renamed" };
    const reply = fakeReply();
    await updateSegment(request, reply);
    expect(reply.statusCode).toBe(403);
    expect(state.writes).toHaveLength(0);
  });

  it("lets an admin edit anyone's segment", async () => {
    state.segments = [segmentRow({ userId: "member_1" })];
    const request = asAdmin();
    request.body = { isPublic: true };
    const reply = fakeReply();
    await updateSegment(request, reply);
    expect(reply.statusCode).toBe(200);
    expect(state.writes[0]).toMatchObject({ values: { isPublic: true } });
  });

  it("only an admin can widen a site segment to the whole organization", async () => {
    state.segments = [segmentRow({ userId: "member_1", siteId: 1 })];
    const request = asMember();
    request.body = { scope: "organization" };
    const reply = fakeReply();
    await updateSegment(request, reply);
    expect(reply.statusCode).toBe(403);
    expect(state.writes).toHaveLength(0);
  });

  it("validates replacement filters against the filter schema", async () => {
    state.segments = [segmentRow()];
    const request = asAdmin();
    request.body = { filters: [{ parameter: "browser", type: "equals", value: [] }] };
    const reply = fakeReply();
    await updateSegment(request, reply);
    expect(reply.statusCode).toBe(400);
  });
});

describe("DELETE /segments/:id", () => {
  it("member deletes own, not others; admin deletes any; viewer sees 404", async () => {
    state.segments = [segmentRow({ userId: "member_1" })];
    let reply = fakeReply();
    await deleteSegment(asMember(), reply);
    expect(reply.statusCode).toBe(200);
    expect(state.writes.map(w => w.op)).toEqual(["delete"]);

    state.writes = [];
    state.segments = [segmentRow({ userId: "admin_1" })];
    reply = fakeReply();
    await deleteSegment(asMember(), reply);
    expect(reply.statusCode).toBe(403);
    expect(state.writes).toHaveLength(0);

    reply = fakeReply();
    await deleteSegment(asAdmin(), reply);
    expect(reply.statusCode).toBe(200);

    state.writes = [];
    state.segments = [segmentRow({ isPublic: true })];
    reply = fakeReply();
    await deleteSegment(asViewer(), reply);
    expect(reply.statusCode).toBe(403);
    expect(state.writes).toHaveLength(0);
  });
});