Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
import { create } from "@bufbuild/protobuf";
import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
import { useRef, useState } from "react";
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
import { getLayerRoot } from "@/components/ui/layer";
import { DEBOUNCE_SEARCH_DELAY } from "@/types/common";
import { State } from "@/types/proto-es/v1/common_pb";
import type { Database } from "@/types/proto-es/v1/database_service_pb";
import { DatabaseSchema$ } from "@/types/proto-es/v1/database_service_pb";
import { type Issue, IssueSchema } from "@/types/proto-es/v1/issue_service_pb";
import type { Project } from "@/types/proto-es/v1/project_service_pb";
import { ProjectSchema } from "@/types/proto-es/v1/project_service_pb";
import { PlanSchema } from "@/types/proto-es/v1/plan_service_pb";
import { InstanceResourceSchema } from "@/types/proto-es/v1/instance_service_pb";
const mocks = vi.hoisted(() => ({
searchAgentProjects: vi.fn(),
searchAgentDatabases: vi.fn(),
searchAgentIssues: vi.fn(),
searchAgentPlans: vi.fn(),
onSelectProject: vi.fn(),
onSelectDatabase: vi.fn(),
onSelectIssue: vi.fn(),
onSelectPlan: vi.fn(),
onOpenChange: vi.fn(),
fetchProject: vi.fn(),
loadProjectIamPolicy: vi.fn(),
canListWorkspaceProjects: true,
canListWorkspaceDatabases: true,
canGetWorkspaceDatabases: undefined as boolean | undefined,
canGetWorkspaceProjects: true,
canListWorkspacePlans: true,
canGetWorkspacePlans: true,
projectGetPermissions: {} as Record<string, boolean>,
projectDatabaseListPermissions: {} as Record<string, boolean>,
projectDatabaseGetPermissions: {} as Record<string, boolean>,
projectPlanListPermissions: {} as Record<string, boolean>,
projectPlanGetPermissions: {} as Record<string, boolean>,
projectsByName: {} as Record<string, Project>,
projectPoliciesByName: {} as Record<string, object>,
permissionDataReady: true,
}));
vi.mock("../logic/resourceSearch", () => ({
searchAgentProjects: mocks.searchAgentProjects,
searchAgentDatabases: mocks.searchAgentDatabases,
searchAgentIssues: mocks.searchAgentIssues,
searchAgentPlans: mocks.searchAgentPlans,
}));
vi.mock("@/stores/app", () => ({
useAppStore: (selector: (state: {
hasWorkspacePermission: (permission: string) => boolean;
hasProjectPermission: (project: Project, permission: string) => boolean;
projectsByName: Record<string, Project>;
projectPoliciesByName: Record<string, object>;
currentUser: object | undefined;
roles: object[];
workspacePolicy: object | undefined;
fetchProject: typeof mocks.fetchProject;
loadProjectIamPolicy: typeof mocks.loadProjectIamPolicy;
getUserByIdentifier: (identifier: string) => undefined;
}) => unknown) =>
selector({
hasWorkspacePermission: (permission) =>
(permission === "bb.projects.list" && mocks.canListWorkspaceProjects) ||
(permission === "bb.databases.list" && mocks.canListWorkspaceDatabases) ||
(permission === "bb.databases.get" &&
(mocks.canGetWorkspaceDatabases ?? mocks.canListWorkspaceDatabases)) ||
(permission === "bb.projects.get" && mocks.canGetWorkspaceProjects) ||
(permission === "bb.plans.list" && mocks.canListWorkspacePlans) ||
(permission === "bb.plans.get" && mocks.canGetWorkspacePlans),
hasProjectPermission: (project, permission) =>
Boolean(mocks.projectPoliciesByName[project.name]) &&
((permission === "bb.databases.list" &&
mocks.projectDatabaseListPermissions[project.name] === true) ||
(permission === "bb.databases.get" &&
(mocks.projectDatabaseGetPermissions[project.name] ??
mocks.projectDatabaseListPermissions[project.name]) === true) ||
(permission === "bb.projects.get" &&
mocks.projectGetPermissions[project.name] === true) ||
(permission === "bb.plans.list" &&
mocks.projectPlanListPermissions[project.name] === true) ||
(permission === "bb.plans.get" &&
mocks.projectPlanGetPermissions[project.name] === true)),
projectsByName: mocks.projectsByName,
projectPoliciesByName: mocks.projectPoliciesByName,
currentUser: mocks.permissionDataReady ? {} : undefined,
roles: mocks.permissionDataReady ? [{}] : [],
workspacePolicy: mocks.permissionDataReady ? {} : undefined,
fetchProject: mocks.fetchProject,
loadProjectIamPolicy: mocks.loadProjectIamPolicy,
getUserByIdentifier: () => undefined,
}),
}));
vi.mock("react-i18next", async (importOriginal) => ({
...(await importOriginal<typeof import("react-i18next")>()),
useTranslation: () => ({
t: (key: string) =>
({
"agent.resource-picker.add-context": "Add context",
"agent.resource-picker.projects": "Projects",
"agent.resource-picker.databases": "Databases",
"agent.resource-picker.issues": "Issues",
"agent.resource-picker.plans": "Plans",
"agent.resource-picker.search-projects": "Search projects",
"agent.resource-picker.search-databases": "Search databases",
"agent.resource-picker.search-issues": "Search issues",
"agent.resource-picker.search-plans": "Search plans",
"agent.resource-picker.no-projects": "No projects found",
"agent.resource-picker.no-databases": "No databases found",
"agent.resource-picker.no-issues": "No issues found",
"agent.resource-picker.no-plans": "No plans found",
"agent.resource-picker.load-error": "Could not load projects",
"agent.resource-picker.load-databases-error": "Could not load databases",
"agent.resource-picker.load-issues-error": "Could not load issues",
"agent.resource-picker.load-plans-error": "Could not load plans",
"agent.resource-picker.retry": "Retry",
"agent.resource-picker.reference-limit":
"You can reference one project and one of its databases, issues, or plans per message. To use both, select the project first. Ask about another resource in a separate message.",
"common.back": "Back",
"common.close": "Close",
"common.loading": "Loading",
"common.load-more": "Load more",
})[key] ?? key,
}),
}));
import { AgentResourcePicker } from "./AgentResourcePicker";
const project = create(ProjectSchema, {
name: "projects/orders",
title: "Orders",
});
const secondProject = create(ProjectSchema, {
name: "projects/payments",
title: "Payments",
});
const database = create(DatabaseSchema$, {
name: "instances/main/databases/orders",
project: project.name,
});
const secondDatabase = create(DatabaseSchema$, {
name: "instances/reporting/databases/orders",
project: project.name,
});
const issue = create(IssueSchema, {
name: "projects/orders/issues/123",
title: "Add an orders index",
});
const secondIssue = create(IssueSchema, {
name: "projects/orders/issues/124",
title: "Review query access",
});
const otherProjectIssue = create(IssueSchema, {
name: "projects/payments/issues/125",
title: "Review payment changes",
});
const plan = create(PlanSchema, {
name: "projects/orders/plans/42",
title: "Add an orders index",
state: State.ACTIVE,
});
const secondPlan = create(PlanSchema, {
name: "projects/orders/plans/43",
title: "Review query access",
state: State.ACTIVE,
});
function deferredPage() {
let resolve!: (page: { items: Project[]; nextPageToken: string }) => void;
const promise = new Promise<{ items: Project[]; nextPageToken: string }>(
(complete) => { resolve = complete; }
);
return { promise, resolve };
}
function PickerHarness({
workspaceName = "workspaces/default",
projectName,
selectedProjectName,
hasSelectedReference = false,
}: {
workspaceName?: string;
projectName?: string;
selectedProjectName?: string;
hasSelectedReference?: boolean;
} = {}) {
const anchorRef = useRef<HTMLTextAreaElement>(null);
const [open, setOpen] = useState(true);
return (
<>
<textarea ref={anchorRef} aria-label="Question" />
<AgentResourcePicker
open={open}
onOpenChange={(nextOpen) => {
mocks.onOpenChange(nextOpen);
setOpen(nextOpen);
}}
anchorRef={anchorRef}
workspaceName={workspaceName}
projectName={projectName}
selectedProjectName={selectedProjectName}
hasSelectedReference={hasSelectedReference}
onSelectProject={mocks.onSelectProject}
onSelectDatabase={mocks.onSelectDatabase}
onSelectIssue={mocks.onSelectIssue}
onSelectPlan={mocks.onSelectPlan}
/>
</>
);
}
beforeEach(() => {
mocks.searchAgentProjects.mockReset();
mocks.searchAgentDatabases.mockReset();
mocks.searchAgentIssues.mockReset();
mocks.searchAgentPlans.mockReset();
mocks.onSelectProject.mockReset();
mocks.onSelectDatabase.mockReset();
mocks.onSelectIssue.mockReset();
mocks.onSelectPlan.mockReset();
mocks.onOpenChange.mockReset();
mocks.fetchProject.mockReset();
mocks.loadProjectIamPolicy.mockReset();
mocks.canListWorkspaceProjects = true;
mocks.canListWorkspaceDatabases = true;
mocks.canGetWorkspaceDatabases = undefined;
mocks.canGetWorkspaceProjects = true;
mocks.canListWorkspacePlans = true;
mocks.canGetWorkspacePlans = true;
mocks.projectGetPermissions = {
[project.name]: true,
[secondProject.name]: true,
};
mocks.projectDatabaseListPermissions = {
[project.name]: true,
[secondProject.name]: true,
};
mocks.projectDatabaseGetPermissions = {};
mocks.projectPlanListPermissions = {
[project.name]: true,
[secondProject.name]: true,
};
mocks.projectPlanGetPermissions = {
[project.name]: true,
[secondProject.name]: true,
};
mocks.projectsByName = {
[project.name]: project,
[secondProject.name]: secondProject,
};
mocks.projectPoliciesByName = {
[project.name]: {},
[secondProject.name]: {},
};
mocks.permissionDataReady = true;
mocks.fetchProject.mockImplementation(async (name: string) =>
mocks.projectsByName[name]
);
mocks.loadProjectIamPolicy.mockImplementation(async (name: string) =>
mocks.projectPoliciesByName[name]
);
});
afterEach(() => {
vi.useRealTimers();
});
describe("AgentResourcePicker", () => {
test("offers Plans only after a concrete project is in context or mentioned", () => {
const { rerender } = render(<PickerHarness />);
expect(screen.queryByRole("button", { name: "Plans" })).toBeNull();
rerender(<PickerHarness projectName="projects/-" />);
expect(screen.queryByRole("button", { name: "Plans" })).toBeNull();
rerender(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Plans" })).toBeInTheDocument();
rerender(<PickerHarness selectedProjectName={secondProject.name} />);
expect(screen.getByRole("button", { name: "Plans" })).toBeInTheDocument();
expect(mocks.searchAgentPlans).not.toHaveBeenCalled();
});
test("hides Plans when either required project permission is known denied", () => {
mocks.canListWorkspacePlans = false;
mocks.canGetWorkspacePlans = false;
mocks.projectPlanListPermissions[project.name] = false;
const { rerender } = render(<PickerHarness projectName={project.name} />);
expect(screen.queryByRole("button", { name: "Plans" })).toBeNull();
mocks.projectPlanListPermissions[project.name] = true;
mocks.projectPlanGetPermissions[project.name] = false;
rerender(<PickerHarness projectName={project.name} />);
expect(screen.queryByRole("button", { name: "Plans" })).toBeNull();
expect(mocks.searchAgentPlans).not.toHaveBeenCalled();
});
test("lets the API decide when project Plan permissions are unavailable", async () => {
mocks.canListWorkspacePlans = false;
mocks.canGetWorkspacePlans = false;
mocks.projectPoliciesByName = {};
const { rerender } = render(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Plans" })).toBeInTheDocument();
await waitFor(() =>
expect(mocks.loadProjectIamPolicy).toHaveBeenCalledWith(
project.name,
true
)
);
mocks.projectPoliciesByName = { [project.name]: {} };
rerender(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Plans" })).toBeInTheDocument();
});
test("searches and selects Plans in an inline project, not the chat project", async () => {
mocks.searchAgentPlans.mockResolvedValueOnce({
items: [plan],
nextPageToken: "",
});
render(
<PickerHarness
projectName={secondProject.name}
selectedProjectName={project.name}
/>
);
fireEvent.click(screen.getByRole("button", { name: "Plans" }));
const row = await screen.findByRole("button", {
name: /Add an orders index.*#42/,
});
expect(mocks.searchAgentPlans).toHaveBeenCalledExactlyOnceWith(
project.name,
"",
"",
expect.any(AbortSignal)
);
fireEvent.click(row);
expect(mocks.onSelectPlan).toHaveBeenCalledExactlyOnceWith(plan);
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
});
test("filters malformed, inactive, and other-project Plans from results", async () => {
mocks.searchAgentPlans.mockResolvedValueOnce({
items: [
create(PlanSchema, {
name: "projects/payments/plans/42",
title: "Other project",
state: State.ACTIVE,
}),
create(PlanSchema, {
name: "projects/orders/plans/not-an-id",
title: "Malformed",
state: State.ACTIVE,
}),
create(PlanSchema, {
name: "projects/orders/plans/44",
title: "Deleted",
state: State.DELETED,
}),
],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Plans" }));
expect(await screen.findByText("No plans found")).toBeInTheDocument();
expect(mocks.onSelectPlan).not.toHaveBeenCalled();
});
test("paginates Plan results and selects the active keyboard row", async () => {
mocks.searchAgentPlans
.mockResolvedValueOnce({ items: [plan], nextPageToken: "next" })
.mockResolvedValueOnce({ items: [secondPlan], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Plans" }));
const first = await screen.findByRole("button", {
name: /Add an orders index.*#42/,
});
const search = screen.getByRole("textbox", { name: "Search plans" });
fireEvent.keyDown(search, { key: "ArrowDown" });
expect(first).toHaveFocus();
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
const second = await screen.findByRole("button", {
name: /Review query access.*#43/,
});
expect(mocks.searchAgentPlans).toHaveBeenLastCalledWith(
project.name,
"",
"next",
expect.any(AbortSignal)
);
fireEvent.keyDown(first, { key: "ArrowDown" });
expect(second).toHaveFocus();
fireEvent.keyDown(second, { key: "Enter" });
expect(mocks.onSelectPlan).toHaveBeenCalledExactlyOnceWith(secondPlan);
});
test("keeps a failed Plan search retryable instead of showing an empty state", async () => {
mocks.searchAgentPlans
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ items: [plan], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Plans" }));
expect(await screen.findByRole("alert")).toHaveTextContent(
"Could not load plans"
);
expect(screen.queryByText("No plans found")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
expect(
await screen.findByRole("button", { name: /Add an orders index.*#42/ })
).toBeInTheDocument();
});
test("moves the active category to the hovered option", async () => {
render(<PickerHarness />);
const projects = screen.getByRole("button", { name: "Projects" });
const databases = screen.getByRole("button", { name: "Databases" });
const issues = screen.getByRole("button", { name: "Issues" });
await waitFor(() => expect(projects).toHaveFocus());
fireEvent.mouseEnter(issues);
expect(issues).toHaveFocus();
expect(issues).toHaveClass("focus:ring-2");
fireEvent.keyDown(issues, { key: "ArrowUp" });
expect(databases).toHaveFocus();
fireEvent.mouseEnter(projects);
expect(projects).toHaveFocus();
});
test("moves the active result to the hovered option", async () => {
mocks.searchAgentProjects.mockResolvedValueOnce({
items: [project, secondProject],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const first = await screen.findByRole("button", {
name: "Orders projects/orders",
});
const second = screen.getByRole("button", {
name: "Payments projects/payments",
});
fireEvent.keyDown(screen.getByRole("textbox", { name: "Search projects" }), {
key: "ArrowDown",
});
expect(first).toHaveFocus();
fireEvent.mouseEnter(second);
expect(second).toHaveFocus();
expect(second).toHaveClass("focus:ring-2");
expect(second).toHaveClass("focus:ring-offset-2");
fireEvent.keyDown(second, { key: "Enter" });
expect(mocks.onSelectProject).toHaveBeenCalledExactlyOnceWith(secondProject);
});
test("hides Projects without workspace list permission", async () => {
mocks.canListWorkspaceProjects = false;
render(<PickerHarness />);
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
const databaseCategory = screen.getByRole("button", { name: "Databases" });
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
await waitFor(() => expect(databaseCategory).toHaveFocus());
fireEvent.keyDown(databaseCategory, { key: "ArrowDown" });
expect(screen.getByRole("button", { name: "Issues" })).toHaveFocus();
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
});
test("leaves project search when list permission is revoked", async () => {
const oldPage = deferredPage();
mocks.searchAgentProjects.mockReturnValueOnce(oldPage.promise);
const { rerender } = render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() => expect(mocks.searchAgentProjects).toHaveBeenCalledTimes(1));
const oldSignal = mocks.searchAgentProjects.mock.calls[0][2] as AbortSignal;
mocks.canListWorkspaceProjects = false;
rerender(<PickerHarness />);
expect(oldSignal.aborted).toBe(true);
expect(screen.queryByRole("textbox", { name: "Search projects" })).toBeNull();
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
await act(async () => {
oldPage.resolve({ items: [project], nextPageToken: "" });
await oldPage.promise;
});
expect(screen.queryByRole("button", { name: "Orders projects/orders" })).toBeNull();
});
test("searches databases across projects without workspace or project list permission", async () => {
mocks.canListWorkspaceProjects = false;
mocks.canListWorkspaceDatabases = false;
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
"workspaces/default", "", "", expect.any(AbortSignal)
);
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole("button", { name: /main.*orders/ }));
expect(mocks.onSelectDatabase).toHaveBeenCalledExactlyOnceWith(database);
expect(mocks.onSelectProject).not.toHaveBeenCalled();
});
test("keeps Issues and database search available when list permissions are denied", async () => {
mocks.canListWorkspaceProjects = false;
mocks.canListWorkspaceDatabases = false;
mocks.searchAgentIssues.mockResolvedValueOnce({
items: [issue],
nextPageToken: "",
});
render(<PickerHarness />);
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
const issueCategory = screen.getByRole("button", { name: "Issues" });
await waitFor(() =>
expect(screen.getByRole("button", { name: "Databases" })).toHaveFocus()
);
fireEvent.click(issueCategory);
expect(await screen.findByRole("button", {
name: /Add an orders index.*#123/,
})).toBeInTheDocument();
expect(mocks.searchAgentIssues).toHaveBeenCalledWith(
"projects/-", "", "", expect.any(AbortSignal)
);
});
test("uses project-scoped database get permission when workspace get is denied", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.canGetWorkspaceProjects = false;
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name, "", "", expect.any(AbortSignal)
);
});
test("shows project databases when get is granted but list is denied", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.canGetWorkspaceDatabases = false;
mocks.projectDatabaseListPermissions[project.name] = false;
mocks.projectDatabaseGetPermissions[project.name] = true;
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name, "", "", expect.any(AbortSignal)
);
});
test("loads a project policy by name without requiring the project resource", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectsByName = {};
mocks.projectPoliciesByName = {};
const { rerender } = render(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
expect(mocks.fetchProject).not.toHaveBeenCalled();
await waitFor(() =>
expect(mocks.loadProjectIamPolicy).toHaveBeenCalledWith(project.name, true)
);
mocks.projectPoliciesByName = { [project.name]: {} };
rerender(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
});
test("allows an inline project's database search when its policy is unavailable", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectPoliciesByName = {};
const { rerender } = render(
<PickerHarness selectedProjectName={secondProject.name} />
);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
await waitFor(() =>
expect(mocks.loadProjectIamPolicy).toHaveBeenCalledWith(
secondProject.name,
true
)
);
expect(mocks.fetchProject).not.toHaveBeenCalled();
mocks.projectPoliciesByName = { [secondProject.name]: {} };
rerender(<PickerHarness selectedProjectName={secondProject.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
});
test("lets the database API decide when the project policy cannot be loaded", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectsByName = {};
mocks.projectPoliciesByName = {};
mocks.loadProjectIamPolicy.mockResolvedValue(undefined);
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name, "", "", expect.any(AbortSignal)
);
expect(mocks.fetchProject).not.toHaveBeenCalled();
});
test("does not load project policy when workspace database get is granted", () => {
mocks.projectPoliciesByName = {};
render(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
expect(mocks.loadProjectIamPolicy).not.toHaveBeenCalled();
});
test("hides project Databases when project get permission is denied", () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectDatabaseListPermissions[project.name] = false;
render(<PickerHarness projectName={project.name} />);
expect(screen.queryByRole("button", { name: "Databases" })).toBeNull();
expect(screen.getByRole("button", { name: "Projects" })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
});
test("does not substitute list permission for database get permission", () => {
mocks.canListWorkspaceDatabases = true;
mocks.canGetWorkspaceDatabases = false;
mocks.projectDatabaseGetPermissions[project.name] = false;
render(<PickerHarness projectName={project.name} />);
expect(screen.queryByRole("button", { name: "Databases" })).toBeNull();
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
});
test("defers to the database API when local permission data is incomplete", () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectDatabaseListPermissions[project.name] = false;
mocks.permissionDataReady = false;
render(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
});
test("does not require project get permission to list its databases", () => {
mocks.canGetWorkspaceProjects = false;
mocks.projectGetPermissions[project.name] = false;
mocks.canListWorkspaceDatabases = false;
render(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Databases" })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
});
test("uses an inline project's database permission over the chat project", () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectDatabaseListPermissions[project.name] = false;
render(
<PickerHarness
projectName={secondProject.name}
selectedProjectName={project.name}
/>
);
expect(screen.queryByRole("button", { name: "Databases" })).toBeNull();
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
});
test("gives issue results more room without widening other picker views", async () => {
mocks.searchAgentIssues.mockResolvedValueOnce({
items: [issue],
nextPageToken: "",
});
render(<PickerHarness />);
const popup = screen.getByRole("dialog", { name: "Add context" });
expect(popup).toHaveClass("w-80");
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
await screen.findByRole("button", { name: /Add an orders index.*#123/ });
expect(popup).toHaveClass("w-112");
expect(popup).toHaveClass("max-w-[calc(100vw-2rem)]");
fireEvent.click(screen.getByRole("button", { name: "Back" }));
expect(popup).toHaveClass("w-80");
});
test("offers Issues in workspace and project contexts", async () => {
const { rerender } = render(<PickerHarness />);
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
expect(mocks.searchAgentIssues).not.toHaveBeenCalled();
rerender(<PickerHarness projectName="projects/-" />);
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
rerender(<PickerHarness projectName={project.name} />);
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
rerender(<PickerHarness selectedProjectName={secondProject.name} />);
expect(screen.getByRole("button", { name: "Issues" })).toBeInTheDocument();
});
test("searches accessible issues across projects from workspace context", async () => {
mocks.searchAgentIssues.mockResolvedValueOnce({
items: [issue, otherProjectIssue],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
const row = await screen.findByRole("button", {
name: /Review payment changes.*#125/,
});
expect(row).toHaveClass("focus:ring-offset-2");
expect(row).toHaveTextContent("Payments");
expect(screen.getByRole("button", { name: /Add an orders index.*#123/ })).toHaveTextContent("Orders");
expect(mocks.searchAgentIssues).toHaveBeenCalledExactlyOnceWith(
"projects/-", "", "", expect.any(AbortSignal)
);
fireEvent.click(row);
expect(mocks.onSelectIssue).toHaveBeenCalledExactlyOnceWith(otherProjectIssue);
});
test("disambiguates same-number issues from different projects", async () => {
const matchingIssue = create(IssueSchema, {
name: "projects/payments/issues/123",
title: issue.title,
});
mocks.searchAgentIssues.mockResolvedValueOnce({
items: [issue, matchingIssue],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
const ordersRow = await screen.findByRole("button", {
name: /Add an orders index.*#123.*Orders/,
});
const paymentsRow = screen.getByRole("button", {
name: /Add an orders index.*#123.*Payments/,
});
expect(ordersRow).not.toBe(paymentsRow);
});
test("does not offer malformed issue names from a workspace search", async () => {
mocks.searchAgentIssues.mockResolvedValueOnce({
items: [create(IssueSchema, { name: "projects/-/issues/1", title: "Invalid issue" })],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
expect(await screen.findByText("No issues found")).toBeInTheDocument();
expect(mocks.onSelectIssue).not.toHaveBeenCalled();
});
test("searches issues in the inline project instead of chat context", async () => {
mocks.searchAgentIssues.mockResolvedValueOnce({ items: [issue], nextPageToken: "" });
render(<PickerHarness projectName={secondProject.name} selectedProjectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
const row = await screen.findByRole("button", {
name: /Add an orders index.*#123/,
});
expect(mocks.searchAgentIssues).toHaveBeenCalledExactlyOnceWith(
project.name, "", "", expect.any(AbortSignal)
);
expect(row).toHaveTextContent(issue.title);
expect(row).toHaveTextContent("#123");
expect(row).not.toHaveTextContent(issue.name);
fireEvent.click(row);
expect(mocks.onSelectIssue).toHaveBeenCalledExactlyOnceWith(issue);
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
});
test("filters out issues outside the selected project", async () => {
mocks.searchAgentIssues.mockResolvedValueOnce({ items: [issue], nextPageToken: "" });
render(<PickerHarness selectedProjectName={secondProject.name} />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
expect(await screen.findByText("No issues found")).toBeInTheDocument();
expect(mocks.searchAgentIssues).toHaveBeenCalledWith(
secondProject.name, "", "", expect.any(AbortSignal)
);
expect(mocks.onSelectIssue).not.toHaveBeenCalled();
});
test("searches and paginates issues with shared loading and keyboard UX", async () => {
mocks.searchAgentIssues
.mockResolvedValueOnce({ items: [issue], nextPageToken: "" })
.mockResolvedValueOnce({ items: [issue], nextPageToken: "next" })
.mockResolvedValueOnce({ items: [secondIssue], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
await screen.findByRole("button", { name: /Add an orders index.*#123/ });
const search = screen.getByRole("textbox", { name: "Search issues" });
fireEvent.change(search, { target: { value: "review" } });
expect(screen.getByRole("status")).toHaveTextContent("Loading");
expect(screen.queryByRole("button", { name: /Add an orders index.*#123/ })).toBeNull();
expect(await screen.findByRole("button", { name: "Load more" })).toBeInTheDocument();
expect(mocks.searchAgentIssues).toHaveBeenCalledWith(
project.name, "review", "", expect.any(AbortSignal)
);
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
const secondRow = await screen.findByRole("button", {
name: /Review query access.*#124/,
});
expect(mocks.searchAgentIssues).toHaveBeenLastCalledWith(
project.name, "review", "next", expect.any(AbortSignal)
);
fireEvent.keyDown(search, { key: "ArrowDown" });
fireEvent.keyDown(document.activeElement as HTMLElement, { key: "ArrowDown" });
expect(secondRow).toHaveFocus();
fireEvent.keyDown(secondRow, { key: "Enter" });
expect(mocks.onSelectIssue).toHaveBeenCalledExactlyOnceWith(secondIssue);
});
test("retries an issue search failure", async () => {
mocks.searchAgentIssues
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ items: [issue], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
expect(await screen.findByRole("alert")).toHaveTextContent("Could not load issues");
expect(screen.queryByText("No issues found")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
expect(await screen.findByRole("button", {
name: /Add an orders index.*#123/,
})).toBeInTheDocument();
});
test("discards an old issue search when the selected project changes", async () => {
let resolveOldPage!: (page: { items: Issue[]; nextPageToken: string }) => void;
const oldPage = new Promise<{ items: Issue[]; nextPageToken: string }>(
(resolve) => { resolveOldPage = resolve; }
);
mocks.searchAgentIssues
.mockReturnValueOnce(oldPage)
.mockResolvedValueOnce({ items: [otherProjectIssue], nextPageToken: "" });
const { rerender } = render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Issues" }));
await waitFor(() => expect(mocks.searchAgentIssues).toHaveBeenCalledTimes(1));
const oldSignal = mocks.searchAgentIssues.mock.calls[0][3] as AbortSignal;
rerender(<PickerHarness projectName={project.name} selectedProjectName={secondProject.name} />);
expect(oldSignal.aborted).toBe(true);
expect(await screen.findByRole("button", {
name: /Review payment changes.*#125/,
})).toBeInTheDocument();
expect(mocks.searchAgentIssues).toHaveBeenLastCalledWith(
secondProject.name, "", "", expect.any(AbortSignal)
);
await act(async () => {
resolveOldPage({ items: [issue], nextPageToken: "" });
await oldPage;
});
expect(screen.queryByRole("button", {
name: /Add an orders index.*#123/,
})).toBeNull();
});
test("explains the project and database limit when another reference is blocked", async () => {
render(<PickerHarness hasSelectedReference />);
expect(screen.getByRole("status")).toHaveTextContent(
"You can reference one project and one of its databases, issues, or plans per message. To use both, select the project first. Ask about another resource in a separate message."
);
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
expect(screen.queryByRole("button", { name: "Databases" })).toBeNull();
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
expect(mocks.onSelectProject).not.toHaveBeenCalled();
await waitFor(() =>
expect(screen.getByRole("button", { name: "Close" })).toHaveFocus()
);
fireEvent.click(screen.getByRole("button", { name: "Close" }));
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
});
test("blocks a third reference after a project and database pair", async () => {
render(<PickerHarness selectedProjectName={project.name} hasSelectedReference />);
expect(screen.getByRole("status")).toHaveTextContent(
"You can reference one project and one of its databases, issues, or plans per message. To use both, select the project first. Ask about another resource in a separate message."
);
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
expect(screen.queryByRole("button", { name: "Databases" })).toBeNull();
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
});
test("browses projects without a request until the category is chosen", async () => {
mocks.searchAgentProjects.mockResolvedValueOnce({
items: [project],
nextPageToken: "",
});
render(<PickerHarness />);
await waitFor(() =>
expect(screen.getByRole("button", { name: "Projects" })).toHaveFocus()
);
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
expect(
getLayerRoot("agent").querySelector("[data-agent-resource-picker]")
).not.toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument()
);
expect(mocks.searchAgentProjects).toHaveBeenCalledWith(
"",
"",
expect.any(AbortSignal)
);
await waitFor(() =>
expect(screen.getByRole("textbox", { name: "Search projects" })).toHaveFocus()
);
fireEvent.click(screen.getByRole("button", { name: "Orders projects/orders" }));
expect(mocks.onSelectProject).toHaveBeenCalledExactlyOnceWith(project);
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
});
test("browses the current project's databases without choosing a project again", async () => {
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
expect(mocks.searchAgentDatabases).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
const row = await screen.findByRole("button", {
name: /main.*orders/,
});
expect(row).toHaveClass("focus:ring-offset-2");
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name,
"",
"",
expect.any(AbortSignal)
);
expect(row).toHaveTextContent("main / orders");
expect(row).not.toHaveTextContent(database.name);
fireEvent.click(row);
expect(mocks.onSelectDatabase).toHaveBeenCalledExactlyOnceWith(database);
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
});
test("uses an inline project instead of chat context for database search", async () => {
mocks.canListWorkspaceDatabases = false;
mocks.projectDatabaseListPermissions[secondProject.name] = false;
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(
<PickerHarness
projectName={secondProject.name}
selectedProjectName={project.name}
/>
);
expect(screen.queryByRole("button", { name: "Projects" })).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name,
"",
"",
expect.any(AbortSignal)
);
});
test("rejects a database returned outside the selected inline project", async () => {
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database],
nextPageToken: "",
});
render(<PickerHarness selectedProjectName={secondProject.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByText("No databases found")).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
secondProject.name,
"",
"",
expect.any(AbortSignal)
);
expect(mocks.onSelectDatabase).not.toHaveBeenCalled();
});
test("shows instance and database names instead of resource paths", async () => {
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [database, secondDatabase],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: /main.*orders/ })).toBeInTheDocument();
expect(screen.getByRole("button", { name: /reporting.*orders/ })).toBeInTheDocument();
expect(screen.queryByText(database.name)).toBeNull();
expect(screen.queryByText(secondDatabase.name)).toBeNull();
});
test("uses the unified database display with the instance title", async () => {
const titledDatabase = create(DatabaseSchema$, {
name: database.name,
project: project.name,
instanceResource: create(InstanceResourceSchema, {
title: "Main production",
}),
});
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [titledDatabase],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(
await screen.findByRole("button", { name: /Main production.*orders/ })
).toBeInTheDocument();
});
test("browses and selects workspace databases directly when permitted", async () => {
mocks.canListWorkspaceDatabases = true;
mocks.searchAgentDatabases
.mockResolvedValueOnce({ items: [database], nextPageToken: "next" })
.mockResolvedValueOnce({ items: [secondDatabase], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
expect(screen.queryByText("Choose a project to browse databases")).toBeNull();
expect(await screen.findByRole("button", {
name: /main.*orders/,
})).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
"workspaces/default",
"",
"",
expect.any(AbortSignal)
);
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
fireEvent.click(await screen.findByRole("button", {
name: /reporting.*orders/,
}));
expect(mocks.searchAgentDatabases).toHaveBeenLastCalledWith(
"workspaces/default",
"",
"next",
expect.any(AbortSignal)
);
expect(mocks.onSelectDatabase).toHaveBeenCalledExactlyOnceWith(secondDatabase);
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
await waitFor(() =>
expect(screen.queryByRole("dialog", { name: "Add context" })).toBeNull()
);
});
test("does not select a workspace database with a noncanonical owner", async () => {
mocks.canListWorkspaceDatabases = true;
const invalidDatabase = create(DatabaseSchema$, {
name: "instances/main/databases/invalid-owner",
project: "orders",
});
mocks.searchAgentDatabases.mockResolvedValueOnce({
items: [invalidDatabase],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByText("No databases found")).toBeInTheDocument();
expect(screen.queryByRole("button", {
name: /main.*invalid-owner/,
})).toBeNull();
expect(mocks.onSelectDatabase).not.toHaveBeenCalled();
expect(mocks.onOpenChange).not.toHaveBeenCalled();
});
test("does not call a filtered first page empty when later databases remain", async () => {
mocks.canListWorkspaceDatabases = true;
const invalidDatabase = create(DatabaseSchema$, {
name: "instances/main/databases/invalid-owner",
project: "orders",
});
mocks.searchAgentDatabases
.mockResolvedValueOnce({
items: [invalidDatabase],
nextPageToken: "next",
})
.mockResolvedValueOnce({ items: [database], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("button", { name: "Load more" })).toBeInTheDocument();
expect(screen.queryByText("No databases found")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
expect(await screen.findByRole("button", {
name: /main.*orders/,
})).toBeInTheDocument();
});
test("keeps workspace database search when workspace list permission is revoked", async () => {
let resolveOldPage!: (page: {
items: Database[];
nextPageToken: string;
}) => void;
const oldPage = new Promise<{ items: Database[]; nextPageToken: string }>(
(resolve) => { resolveOldPage = resolve; }
);
mocks.searchAgentDatabases.mockReturnValueOnce(oldPage);
const { rerender } = render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
await waitFor(() => expect(mocks.searchAgentDatabases).toHaveBeenCalledTimes(1));
const oldSignal = mocks.searchAgentDatabases.mock.calls[0][3] as AbortSignal;
mocks.canListWorkspaceDatabases = false;
rerender(<PickerHarness />);
expect(oldSignal.aborted).toBe(false);
expect(screen.getByRole("textbox", { name: "Search databases" })).toBeInTheDocument();
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
await act(async () => {
resolveOldPage({ items: [database], nextPageToken: "" });
await oldPage;
});
expect(screen.getByRole("button", {
name: /main.*orders/,
})).toBeInTheDocument();
});
test("searches and paginates databases remotely without dropping earlier results", async () => {
mocks.searchAgentDatabases
.mockResolvedValueOnce({ items: [database], nextPageToken: "" })
.mockResolvedValueOnce({ items: [database], nextPageToken: "next" })
.mockResolvedValueOnce({ items: [secondDatabase], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
const search = await screen.findByRole("textbox", {
name: "Search databases",
});
await screen.findByRole("button", {
name: /main.*orders/,
});
fireEvent.change(search, { target: { value: "orders" } });
await waitFor(() =>
expect(mocks.searchAgentDatabases).toHaveBeenCalledWith(
project.name,
"orders",
"",
expect.any(AbortSignal)
)
);
fireEvent.click(await screen.findByRole("button", { name: "Load more" }));
expect(await screen.findByRole("button", {
name: /reporting.*orders/,
})).toBeInTheDocument();
expect(screen.getByRole("button", {
name: /main.*orders/,
})).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenLastCalledWith(
project.name,
"orders",
"next",
expect.any(AbortSignal)
);
});
test("shows a loading indicator immediately while database search is debounced", async () => {
mocks.searchAgentDatabases
.mockResolvedValueOnce({ items: [database], nextPageToken: "" })
.mockResolvedValueOnce({ items: [secondDatabase], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
await screen.findByRole("button", { name: /main.*orders/ });
fireEvent.change(screen.getByRole("textbox", { name: "Search databases" }), {
target: { value: "reporting" },
});
const loading = screen.getByRole("status");
expect(loading).toHaveTextContent("Loading");
expect(loading.querySelector(".animate-spin")).not.toBeNull();
expect(screen.queryByRole("button", { name: /main.*orders/ })).toBeNull();
await screen.findByRole("button", { name: /reporting.*orders/ });
expect(screen.queryByRole("status")).toBeNull();
});
test("retries a failed database search without calling it empty", async () => {
mocks.searchAgentDatabases
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ items: [database], nextPageToken: "" });
render(<PickerHarness projectName={project.name} />);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
expect(await screen.findByRole("alert")).toHaveTextContent("Could not load databases");
expect(screen.queryByText("No databases found")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
expect(await screen.findByRole("button", {
name: /main.*orders/,
})).toBeInTheDocument();
});
test("selects a database with keyboard navigation", async () => {
mocks.searchAgentDatabases.mockResolvedValue({
items: [database, secondDatabase],
nextPageToken: "",
});
render(<PickerHarness projectName={project.name} />);
const category = screen.getByRole("button", { name: "Projects" });
await waitFor(() => expect(category).toHaveFocus());
fireEvent.keyDown(category, { key: "ArrowDown" });
const databaseCategory = screen.getByRole("button", { name: "Databases" });
expect(databaseCategory).toHaveFocus();
fireEvent.keyDown(databaseCategory, { key: "Enter" });
const search = await screen.findByRole("textbox", { name: "Search databases" });
await waitFor(() => expect(search).toHaveFocus());
await screen.findByRole("button", {
name: /reporting.*orders/,
});
fireEvent.keyDown(search, { key: "ArrowDown" });
fireEvent.keyDown(document.activeElement as HTMLElement, { key: "ArrowDown" });
const second = screen.getByRole("button", {
name: /reporting.*orders/,
});
expect(second).toHaveFocus();
fireEvent.keyDown(second, { key: "Enter" });
expect(mocks.onSelectDatabase).toHaveBeenCalledExactlyOnceWith(secondDatabase);
});
test("switches database search to the new workspace when context changes", async () => {
let resolveOldPage!: (page: {
items: Database[];
nextPageToken: string;
}) => void;
const oldPage = new Promise<{ items: Database[]; nextPageToken: string }>(
(resolve) => { resolveOldPage = resolve; }
);
mocks.searchAgentDatabases
.mockReturnValueOnce(oldPage)
.mockResolvedValueOnce({ items: [secondDatabase], nextPageToken: "" });
const { rerender } = render(
<PickerHarness workspaceName="workspaces/first" />
);
fireEvent.click(screen.getByRole("button", { name: "Databases" }));
await waitFor(() => expect(mocks.searchAgentDatabases).toHaveBeenCalledTimes(1));
const oldSignal = mocks.searchAgentDatabases.mock.calls[0][3] as AbortSignal;
rerender(<PickerHarness workspaceName="workspaces/second" />);
expect(oldSignal.aborted).toBe(true);
expect(await screen.findByRole("button", { name: /reporting.*orders/ })).toBeInTheDocument();
expect(mocks.searchAgentDatabases).toHaveBeenLastCalledWith(
"workspaces/second", "", "", expect.any(AbortSignal)
);
expect(mocks.searchAgentProjects).not.toHaveBeenCalled();
await act(async () => {
resolveOldPage({ items: [database], nextPageToken: "" });
await oldPage;
});
expect(screen.queryByRole("button", {
name: /main.*orders/,
})).toBeNull();
});
test("loads another page without dropping the first page", async () => {
mocks.searchAgentProjects
.mockResolvedValueOnce({ items: [project], nextPageToken: "next" })
.mockResolvedValueOnce({ items: [secondProject], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument()
);
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toBeInTheDocument()
);
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument();
expect(mocks.searchAgentProjects).toHaveBeenNthCalledWith(
2, "", "next", expect.any(AbortSignal)
);
});
test("shows a loading indicator while fetching the next page", async () => {
const nextPage = deferredPage();
mocks.searchAgentProjects
.mockResolvedValueOnce({ items: [project], nextPageToken: "next" })
.mockReturnValueOnce(nextPage.promise);
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const loadMore = await screen.findByRole("button", { name: "Load more" });
fireEvent.click(loadMore);
const loading = screen.getByRole("button", { name: "Loading" });
expect(loading).toBeDisabled();
expect(loading.querySelector(".animate-spin")).not.toBeNull();
expect(screen.getByRole("button", {
name: "Orders projects/orders",
})).toBeInTheDocument();
await act(async () => {
nextPage.resolve({ items: [secondProject], nextPageToken: "" });
await nextPage.promise;
});
expect(screen.queryByRole("button", { name: "Loading" })).toBeNull();
expect(screen.getByRole("button", {
name: "Payments projects/payments",
})).toBeInTheDocument();
});
test("shows each project's canonical resource ID beneath its title", async () => {
const idLikeTitle = create(ProjectSchema, {
name: "projects/actual-id",
title: "projects/looks-like-an-id",
});
const matchingTitle = create(ProjectSchema, {
name: "projects/same",
title: "projects/same",
});
mocks.searchAgentProjects.mockResolvedValueOnce({
items: [project, idLikeTitle, matchingTitle],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
for (const item of [project, idLikeTitle, matchingTitle]) {
const row = await screen.findByRole("button", {
name: `${item.title} ${item.name}`,
});
const titleAndId = row.querySelector("span.flex-col");
expect(titleAndId).toHaveClass("flex-col");
expect(titleAndId?.children).toHaveLength(2);
expect(titleAndId?.children[0]).toHaveTextContent(item.title);
expect(titleAndId?.children[1]).toHaveTextContent(item.name);
}
});
test("disambiguates duplicate project titles after loading another page", async () => {
const first = create(ProjectSchema, {
name: "projects/new-one",
title: "New Project",
});
const second = create(ProjectSchema, {
name: "projects/new-two",
title: "New Project",
});
mocks.searchAgentProjects
.mockResolvedValueOnce({
items: [first, secondProject],
nextPageToken: "next",
})
.mockResolvedValueOnce({ items: [second], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const firstRow = await screen.findByRole("button", { name: "New Project projects/new-one" });
expect(firstRow).toHaveTextContent(first.name);
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
await waitFor(() =>
expect(
document.querySelector('[data-agent-resource-project="projects/new-two"]')
).not.toBeNull()
);
expect(
document.querySelector('[data-agent-resource-project="projects/new-one"]')
).toHaveTextContent(first.name);
expect(
document.querySelector('[data-agent-resource-project="projects/new-two"]')
).toHaveTextContent(second.name);
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toHaveTextContent(
secondProject.name
);
fireEvent.click(
document.querySelector<HTMLButtonElement>(
'[data-agent-resource-project="projects/new-two"]'
)!
);
expect(mocks.onSelectProject).toHaveBeenCalledExactlyOnceWith(second);
});
test("shows a retryable error instead of an empty result", async () => {
mocks.searchAgentProjects
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ items: [project], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("alert")).toHaveTextContent("Could not load projects")
);
expect(screen.queryByText("No projects found")).toBeNull();
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument()
);
});
test("shows a loading indicator immediately while project search is debounced", async () => {
mocks.searchAgentProjects
.mockResolvedValueOnce({ items: [project], nextPageToken: "" })
.mockResolvedValueOnce({ items: [secondProject], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await screen.findByRole("button", { name: "Orders projects/orders" });
fireEvent.change(screen.getByRole("textbox", { name: "Search projects" }), {
target: { value: "payments" },
});
const loading = screen.getByRole("status");
expect(loading).toHaveTextContent("Loading");
expect(loading.querySelector(".animate-spin")).not.toBeNull();
expect(screen.queryByRole("button", { name: "Orders projects/orders" })).toBeNull();
await screen.findByRole("button", { name: "Payments projects/payments" });
expect(screen.queryByRole("status")).toBeNull();
});
test("reloads results when the pending search returns to the current query", async () => {
mocks.searchAgentProjects.mockResolvedValue({
items: [project],
nextPageToken: "",
});
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await screen.findByRole("button", { name: "Orders projects/orders" });
const search = screen.getByRole("textbox", { name: "Search projects" });
fireEvent.change(search, { target: { value: "pay" } });
fireEvent.change(search, { target: { value: "" } });
expect(screen.getByRole("status")).toHaveTextContent("Loading");
await waitFor(() => expect(mocks.searchAgentProjects).toHaveBeenCalledTimes(2), {
timeout: DEBOUNCE_SEARCH_DELAY + 1000,
});
expect(await screen.findByRole("button", {
name: "Orders projects/orders",
})).toBeInTheDocument();
expect(screen.queryByRole("status")).toBeNull();
});
test("distinguishes an empty project search from a failed search", async () => {
mocks.searchAgentProjects.mockResolvedValueOnce({ items: [], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByText("No projects found")).toBeInTheDocument()
);
expect(screen.queryByRole("alert")).toBeNull();
});
test("retries a failed continuation without replacing earlier results", async () => {
mocks.searchAgentProjects
.mockResolvedValueOnce({ items: [project], nextPageToken: "next" })
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ items: [secondProject], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Load more" })).toBeInTheDocument()
);
fireEvent.click(screen.getByRole("button", { name: "Load more" }));
await waitFor(() => expect(screen.getByRole("alert")).toBeInTheDocument());
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: "Retry" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toBeInTheDocument()
);
expect(mocks.searchAgentProjects).toHaveBeenNthCalledWith(
3, "", "next", expect.any(AbortSignal)
);
});
test("keeps the newest query result when an older request finishes late", async () => {
const oldPage = deferredPage();
const newPage = deferredPage();
mocks.searchAgentProjects
.mockReturnValueOnce(oldPage.promise)
.mockReturnValueOnce(newPage.promise);
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const search = screen.getByRole("textbox", { name: "Search projects" });
fireEvent.change(search, { target: { value: "pay" } });
await waitFor(() =>
expect(mocks.searchAgentProjects).toHaveBeenCalledWith(
"pay", "", expect.any(AbortSignal)
),
{ timeout: DEBOUNCE_SEARCH_DELAY + 1000 }
);
await act(async () => {
newPage.resolve({ items: [secondProject], nextPageToken: "" });
await newPage.promise;
});
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toBeInTheDocument();
await act(async () => {
oldPage.resolve({ items: [project], nextPageToken: "old-next" });
await oldPage.promise;
});
expect(screen.queryByRole("button", { name: "Orders projects/orders" })).toBeNull();
expect(screen.queryByRole("button", { name: "Load more" })).toBeNull();
});
test("does not show results from a previous workspace", async () => {
const oldWorkspacePage = deferredPage();
mocks.searchAgentProjects
.mockReturnValueOnce(oldWorkspacePage.promise)
.mockResolvedValueOnce({ items: [secondProject], nextPageToken: "" });
const { rerender } = render(<PickerHarness workspaceName="workspaces/first" />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const oldSignal = mocks.searchAgentProjects.mock.calls[0][2] as AbortSignal;
rerender(<PickerHarness workspaceName="workspaces/second" />);
await waitFor(() =>
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toBeInTheDocument()
);
expect(oldSignal.aborted).toBe(true);
await act(async () => {
oldWorkspacePage.resolve({ items: [project], nextPageToken: "" });
await oldWorkspacePage.promise;
});
expect(screen.queryByRole("button", { name: "Orders projects/orders" })).toBeNull();
});
test("supports keyboard selection, back navigation, and Escape", async () => {
mocks.searchAgentProjects.mockResolvedValue({ items: [project, secondProject], nextPageToken: "" });
render(<PickerHarness />);
const category = screen.getByRole("button", { name: "Projects" });
await waitFor(() => expect(category).toHaveFocus());
fireEvent.keyDown(category, { key: "Enter" });
const search = await screen.findByRole("textbox", { name: "Search projects" });
await waitFor(() => expect(search).toHaveFocus());
fireEvent.keyDown(search, { key: "ArrowDown" });
const firstProject = screen.getByRole("button", { name: "Orders projects/orders" });
expect(firstProject).toHaveFocus();
expect(firstProject).toHaveClass("focus:bg-control-bg");
expect(firstProject).toHaveClass("focus:ring-offset-2");
fireEvent.keyDown(document.activeElement as HTMLElement, { key: "ArrowDown" });
const secondProjectButton = screen.getByRole("button", { name: "Payments projects/payments" });
expect(secondProjectButton).toHaveFocus();
expect(secondProjectButton).toHaveClass("focus:bg-control-bg");
fireEvent.keyDown(document.activeElement as HTMLElement, { key: "ArrowUp" });
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toHaveFocus();
fireEvent.click(screen.getByRole("button", { name: "Back" }));
expect(screen.getByRole("button", { name: "Projects" })).toBeInTheDocument();
fireEvent.keyDown(screen.getByRole("button", { name: "Projects" }), { key: "Escape" });
expect(mocks.onOpenChange).toHaveBeenCalledWith(false);
expect(mocks.onSelectProject).not.toHaveBeenCalled();
});
test("selects the first search result with Enter", async () => {
mocks.searchAgentProjects.mockResolvedValue({ items: [project], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument()
);
fireEvent.keyDown(screen.getByRole("textbox", { name: "Search projects" }), { key: "Enter" });
expect(mocks.onSelectProject).toHaveBeenCalledExactlyOnceWith(project);
});
test("does not select stale results before a new query is sent", async () => {
mocks.searchAgentProjects
.mockResolvedValueOnce({ items: [project], nextPageToken: "" })
.mockResolvedValueOnce({ items: [secondProject], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
await waitFor(() =>
expect(screen.getByRole("button", { name: "Orders projects/orders" })).toBeInTheDocument()
);
const search = screen.getByRole("textbox", { name: "Search projects" });
fireEvent.change(search, { target: { value: "pay" } });
fireEvent.keyDown(search, { key: "Enter" });
expect(mocks.onSelectProject).not.toHaveBeenCalled();
expect(screen.queryByRole("button", { name: "Orders projects/orders" })).toBeNull();
await waitFor(() =>
expect(screen.getByRole("button", { name: "Payments projects/payments" })).toBeInTheDocument()
);
});
test("selects a focused result with Enter but not during IME composition", async () => {
mocks.searchAgentProjects.mockResolvedValue({ items: [project], nextPageToken: "" });
render(<PickerHarness />);
fireEvent.click(screen.getByRole("button", { name: "Projects" }));
const result = await screen.findByRole("button", { name: "Orders projects/orders" });
const search = screen.getByRole("textbox", { name: "Search projects" });
fireEvent.keyDown(search, { key: "Enter", isComposing: true });
expect(mocks.onSelectProject).not.toHaveBeenCalled();
result.focus();
fireEvent.keyDown(result, { key: "Enter" });
expect(mocks.onSelectProject).toHaveBeenCalledExactlyOnceWith(project);
});
});