Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

9.6 KB
Raw Blame
import type { ReactElement } from "react";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { beforeEach, describe, expect, test, vi } from "vitest";
import {
  DATABASE_ROUTE_DASHBOARD,
  WORKSPACE_ROUTE_LANDING,
  WORKSPACE_ROUTE_MEMBERS,
} from "@/app/router";

(
  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;

const mocks = vi.hoisted(() => ({
  currentRoute: {
    name: "workspace.landing",
    fullPath: "/",
    params: {},
    query: {},
  },
  isSaaSMode: false,
  project: undefined as { name: string; title: string } | undefined,
  workspace: {
    name: "workspaces/default",
    title: "Default Workspace",
    logo: "",
  },
  workspaceList: [
    {
      name: "workspaces/default",
      title: "Default Workspace",
    },
  ],
  subscription: {
    plan: 0,
  },
  record: vi.fn(),
  push: vi.fn(),
  resolve: vi.fn((target: string | { name?: string; path?: string }) => {
    const routePathByName: Record<string, string> = {
      "sql-editor.home": "/sql-editor",
      "workspace.database": "/databases",
      "workspace.environment": "/environments",
      "workspace.instance": "/instances",
      "workspace.landing": "/landing",
      "workspace.project": "/projects",
    };
    const href =
      typeof target === "string"
        ? target
        : (target.path ??
          (target.name
            ? (routePathByName[target.name] ?? `/${target.name}`)
            : "/"));
    return {
      href,
      fullPath: href,
    };
  }),
}));

const t = vi.hoisted(
  () => (key: string) =>
    ({
      "common.home": "Home",
      "common.projects": "Projects",
      "common.instances": "Instances",
      "common.databases": "Databases",
      "common.environments": "Environments",
      "common.users": "Users",
      "common.settings": "Settings",
      "project.select": "Select project",
      "subscription.plan.free.title": "Free",
      "subscription.plan.team.title": "Team",
      "subscription.plan.enterprise.title": "Enterprise",
      "settings.sidebar.iam-and-admin": "IAM & Admin",
      "settings.members.service-accounts": "Service Accounts",
      "settings.members.workload-identities": "Workload Identities",
      "settings.sidebar.members": "Members",
      "settings.members.groups.self": "Groups",
      "settings.sidebar.custom-roles": "Custom Roles",
      "settings.sidebar.sso": "SSO",
      "settings.sidebar.audit-log": "Audit Log",
      "sql-review.title": "SQL Review",
      "custom-approval.risk.self": "Risk Assessment",
      "custom-approval.self": "Custom Approval",
      "settings.sidebar.data-access": "Data Access",
      "settings.sensitive-data.semantic-types.self": "Semantic Types",
      "settings.sidebar.data-classification": "Data Classification",
      "settings.sidebar.global-masking": "Global Masking",
      "settings.sidebar.integration": "Integration",
      "settings.sidebar.im-integration": "IM Integration",
      "settings.sidebar.mcp": "MCP",
      "settings.sidebar.general": "General",
      "settings.sidebar.subscription": "Subscription",
    })[key] ?? key
);

vi.mock("react-i18next", () => ({
  useTranslation: () => ({
    t,
  }),
}));

vi.mock("@/hooks/useAppState", () => ({
  useIsSaaSMode: () => mocks.isSaaSMode,
  useProject: () => mocks.project,
  useRecentVisit: () => ({
    record: mocks.record,
  }),
  useSubscription: () => ({
    subscription: mocks.subscription,
  }),
  useSwitchWorkspace: () => vi.fn(),
  useWorkspace: () => mocks.workspace,
  useWorkspaceList: () => mocks.workspaceList,
}));

vi.mock("@/app/router", () => ({
  useCurrentRoute: () => mocks.currentRoute,
  useNavigate: () => ({
    push: mocks.push,
    resolve: mocks.resolve,
  }),
  router: {
    push: mocks.push,
    resolve: mocks.resolve,
  },
  DATABASE_ROUTE_DASHBOARD: "workspace.database",
  ENVIRONMENT_V1_ROUTE_DASHBOARD: "workspace.environment",
  INSTANCE_ROUTE_DASHBOARD: "workspace.instance",
  PROJECT_V1_ROUTE_DASHBOARD: "workspace.project",
  SETTING_ROUTE_WORKSPACE_GENERAL: "setting.workspace.general",
  SETTING_ROUTE_WORKSPACE_SUBSCRIPTION: "setting.workspace.subscription",
  WORKSPACE_ROUTE_AUDIT_LOG: "workspace.audit-log",
  WORKSPACE_ROUTE_CUSTOM_APPROVAL: "workspace.custom-approval",
  WORKSPACE_ROUTE_DATA_CLASSIFICATION: "workspace.data-classification",
  WORKSPACE_ROUTE_GLOBAL_MASKING: "workspace.global-masking",
  WORKSPACE_ROUTE_GROUPS: "workspace.groups",
  WORKSPACE_ROUTE_IDENTITY_PROVIDERS: "workspace.identity-providers",
  WORKSPACE_ROUTE_IM: "workspace.integration.im",
  WORKSPACE_ROUTE_LANDING: "workspace.landing",
  WORKSPACE_ROUTE_MCP: "workspace.integration.mcp",
  WORKSPACE_ROUTE_MEMBERS: "workspace.members",
  WORKSPACE_ROUTE_RISK_ASSESSMENT: "workspace.risk-assessment",
  WORKSPACE_ROUTE_ROLES: "workspace.roles",
  WORKSPACE_ROUTE_SEMANTIC_TYPES: "workspace.semantic-types",
  WORKSPACE_ROUTE_SERVICE_ACCOUNTS: "workspace.service-accounts",
  WORKSPACE_ROUTE_EXPORT_DESTINATIONS: "workspace.integration.export-destinations",
  WORKSPACE_ROUTE_SQL_REVIEW: "workspace.sql-review",
  WORKSPACE_ROUTE_USERS: "workspace.users",
  WORKSPACE_ROUTE_WORKLOAD_IDENTITIES: "workspace.workload-identities",
}));

vi.mock("@/components/header/ProjectCreateDialog", () => ({
  ProjectCreateDialog: () => null,
}));

vi.mock("@/components/header/ProjectSwitchPanel", () => ({
  ProjectSwitchPanel: () => <div data-testid="project-switch-panel" />,
}));

let DashboardSidebar: typeof import("./DashboardSidebar").DashboardSidebar;

const renderIntoContainer = (element: ReactElement) => {
  const container = document.createElement("div");
  document.body.appendChild(container);
  const root = createRoot(container);
  return {
    container,
    render: () => {
      act(() => {
        root.render(element);
      });
    },
    unmount: () =>
      act(() => {
        root.unmount();
        container.remove();
      }),
  };
};

beforeEach(async () => {
  vi.clearAllMocks();
  mocks.currentRoute.name = WORKSPACE_ROUTE_LANDING;
  mocks.currentRoute.fullPath = "/";
  mocks.currentRoute.params = {};
  mocks.isSaaSMode = false;
  mocks.project = undefined;
  mocks.workspace = {
    name: "workspaces/default",
    title: "Default Workspace",
    logo: "",
  };
  mocks.workspaceList = [
    {
      name: "workspaces/default",
      title: "Default Workspace",
    },
  ];
  ({ DashboardSidebar } = await import("./DashboardSidebar"));
});

describe("DashboardSidebar", () => {
  test("renders non-SaaS IAM routes and hides SaaS-only exclusions", () => {
    mocks.currentRoute.name = WORKSPACE_ROUTE_MEMBERS;
    const { container, render, unmount } = renderIntoContainer(
      <DashboardSidebar />
    );
    render();

    expect(container.textContent).toContain("Users");
    expect(container.textContent).toContain("Service Accounts");
    expect(container.textContent).toContain("Workload Identities");

    unmount();

    mocks.isSaaSMode = true;
    const saas = renderIntoContainer(<DashboardSidebar />);
    saas.render();

    expect(saas.container.textContent).not.toContain("Users");
    expect(saas.container.textContent).not.toContain("Service Accounts");
    expect(saas.container.textContent).not.toContain("Workload Identities");
    expect(saas.container.textContent).toContain("Members");

    saas.unmount();
  });

  test("does not render the workspace logo in the sidebar", () => {
    mocks.workspace.logo = "https://example.com/logo.png";
    const { container, render, unmount } = renderIntoContainer(
      <DashboardSidebar />
    );
    render();

    expect(container.querySelector("nav > a > img")).toBeNull();
    expect(
      container.querySelector("nav > div:last-child")?.className
    ).toContain("pt-3");
    expect(mocks.record).not.toHaveBeenCalled();

    unmount();
  });

  test("places workspace and project switchers in a mobile-only sidebar block", () => {
    const { container, render, unmount } = renderIntoContainer(
      <DashboardSidebar />
    );
    render();

    const switcherBlock = container.querySelector(
      '[data-label="bb-mobile-sidebar-switchers"]'
    );
    expect(switcherBlock).not.toBeNull();
    expect(switcherBlock?.className).toContain("md:hidden");
    expect(switcherBlock?.textContent).toContain("Default Workspace");
    expect(switcherBlock?.textContent).toContain("Select project");
    expect(switcherBlock?.previousElementSibling).toBeNull();

    unmount();
  });

  test("highlights the active route", () => {
    mocks.currentRoute.name = DATABASE_ROUTE_DASHBOARD;
    const { container, render, unmount } = renderIntoContainer(
      <DashboardSidebar />
    );
    render();

    const databaseLink = Array.from(container.querySelectorAll("a")).find(
      (link) => link.textContent?.includes("Databases")
    );
    expect(databaseLink?.className).toContain("router-link-active");

    unmount();
  });

  test("leaves modified and middle-click route navigation to the browser", () => {
    const { container, render, unmount } = renderIntoContainer(
      <DashboardSidebar />
    );
    render();

    const projectsLink = Array.from(container.querySelectorAll("a")).find(
      (link) => link.textContent?.includes("Projects")
    );
    expect(projectsLink).toBeInstanceOf(HTMLAnchorElement);

    const clickOptions: MouseEventInit[] = [
      { ctrlKey: true },
      { metaKey: true },
      { shiftKey: true },
      { altKey: true },
      { button: 1 },
    ];

    for (const options of clickOptions) {
      const event = new MouseEvent("click", {
        bubbles: true,
        cancelable: true,
        button: 0,
        ...options,
      });
      projectsLink?.dispatchEvent(event);

      expect(event.defaultPrevented).toBe(false);
    }

    expect(mocks.push).not.toHaveBeenCalled();

    unmount();
  });
});