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 { act } from "react";
import { createRoot } from "react-dom/client";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { preCreateIssue } from "@/lib/plan/issue";
import { Engine } from "@/types/proto-es/v1/common_pb";
(
globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;
const mocks = vi.hoisted(() => ({
visibleDatabases: [] as { name: string; project?: string; instanceResource?: { engine: number } }[],
databasesByName: {} as Record<string, { name: string }>,
instancesByName: {} as Record<string, { name: string; title: string }>,
routerCurrentName: "workspace.project.database",
routerCurrentQuery: {} as Record<string, unknown>,
routerPush: vi.fn(),
batchUpdateDatabases: vi.fn(),
useProductIntro: vi.fn(),
captureMetric: vi.fn(),
scenarioId: undefined as
| "query-data"
| "create-database-change"
| "mark-sensitive-data"
| "just-exploring"
| undefined,
removeDatabaseMetadataCache: vi.fn(),
fetchInstance: vi.fn(),
fetchInstanceList: vi.fn(async (_params?: { parent?: string }) => ({
instances: [] as { name: string; title: string }[],
})),
workspacePermissions: new Set<string>([
"bb.instances.create",
"bb.instances.list",
]),
projectPermissions: new Set<string>([
"bb.instances.create",
"bb.instances.get",
"bb.instances.list",
]),
}));
let ProjectDatabasesPage: typeof import("./ProjectDatabasesPage").ProjectDatabasesPage;
vi.mock("react-i18next", () => ({
initReactI18next: { type: "3rdParty", init: () => {} },
Trans: ({
i18nKey,
components,
}: {
i18nKey: string;
components?: { instance?: React.ReactNode };
}) => (
<>
{i18nKey}
{components?.instance}
</>
),
useTranslation: () => ({
t: (key: string, options?: { instance?: string }) =>
options?.instance ? `${key}:${options.instance}` : key,
}),
}));
vi.mock("@/app/router", () => ({
router: {
push: mocks.routerPush,
resolve: ({ name }: { name?: string }) => ({ href: `/${name ?? ""}` }),
currentRoute: {
get value() {
return {
name: mocks.routerCurrentName,
query: mocks.routerCurrentQuery,
};
},
},
},
useCurrentRoute: () => ({
name: mocks.routerCurrentName,
query: mocks.routerCurrentQuery,
}),
SQL_EDITOR_DATABASE_MODULE: "sql-editor.database",
SQL_EDITOR_HOME_MODULE: "sql-editor.home",
SQL_EDITOR_PROJECT_MODULE: "sql-editor.project",
}));
vi.mock("@/app/analytics/provider", () => ({
behaviorAnalytics: {
captureMetric: mocks.captureMetric,
},
}));
vi.mock("@/modules/workspace-setup-guide/selection", () => ({
readSelectedGuideScenarioId: () => mocks.scenarioId,
}));
vi.mock("@/components/AdvancedSearch", () => ({
AdvancedSearch: ({
scopeOptions,
}: {
scopeOptions: {
id: string;
onSearch?: (keyword: string) => Promise<unknown>;
}[];
}) => (
<div data-testid="advanced-search">
<span
data-testid="search-instances"
onClick={() => {
void scopeOptions
.find((option) => option.id === "instance")
?.onSearch?.("");
}}
>
search instances
</span>
</div>
),
getValueFromScopes: () => undefined,
}));
vi.mock("@/components/EditEnvironmentSheet", () => ({
EditEnvironmentSheet: () => null,
}));
vi.mock("@/components/PermissionGuard", () => ({
PermissionGuard: ({ children }: { children: React.ReactNode }) => (
<>{children}</>
),
}));
vi.mock("@/components/database", async () => {
const React = await import("react");
return {
CreateDatabaseSheet: ({ open }: { open: boolean }) =>
open
? React.createElement("div", { "data-testid": "create-database-sheet" })
: null,
DatabaseBatchOperationsBar: ({
databases,
onTransferProject,
onToggleSelectAll,
}: {
databases: { name: string }[];
onTransferProject?: () => void;
onToggleSelectAll: () => void;
}) =>
React.createElement(
"div",
{
"data-testid": "batch-operations-bar",
"data-selected-count": String(databases.length),
"data-has-transfer": String(!!onTransferProject),
},
React.createElement(
"button",
{
"data-testid": "batch-select-all",
onClick: onToggleSelectAll,
},
"select all"
),
databases.length > 0 && onTransferProject
? React.createElement(
"button",
{
"data-testid": "batch-transfer-project",
onClick: onTransferProject,
},
"database.transfer-project"
)
: null
),
DatabaseTable: ({
emptyPlaceholder,
onSelectedNamesChange,
onDatabasesChange,
}: {
emptyPlaceholder?: React.ReactNode;
onSelectedNamesChange: (selectedNames: Set<string>) => void;
onDatabasesChange: (databases: { name: string }[]) => void;
}) => {
React.useEffect(() => {
onDatabasesChange(mocks.visibleDatabases);
onSelectedNamesChange(
new Set(mocks.visibleDatabases.map((d) => d.name))
);
}, [onDatabasesChange, onSelectedNamesChange]);
return React.createElement(
"div",
{ "data-testid": "database-table" },
emptyPlaceholder
);
},
LabelEditorSheet: () => null,
TransferProjectSheet: ({
open,
onTransfer,
}: {
open: boolean;
onTransfer: (projectName: string) => Promise<void>;
}) =>
open
? React.createElement(
"button",
{
"data-testid": "transfer-project-sheet",
onClick: () => {
void onTransfer("projects/target");
},
},
"transfer"
)
: null,
};
});
vi.mock("@/hooks/useProjectByName", () => ({
useProjectByName: (name: string) => ({ name, title: "Demo Project" }),
}));
vi.mock("@/lib/plan/issue", () => ({
preCreateIssue: vi.fn(),
}));
vi.mock("@/lib/productIntro", () => ({
CONNECT_DATABASE_PRODUCT_INTRO: "connect-database",
MARK_SENSITIVE_DATA_PRODUCT_INTRO: "mark-sensitive-data",
PROJECT_INSTANCE_SYNCED_PRODUCT_INTRO: "project-instance-synced",
PRODUCT_INTRO_QUERY_KEY: "intro",
useProductIntro: mocks.useProductIntro,
}));
vi.mock("@/types", async () => {
const actual = await vi.importActual<typeof import("@/types")>("@/types");
return {
...actual,
isDefaultProject: (name: string) => name === "projects/default",
};
});
vi.mock("@/stores/app", () => {
const appState = {
removeDatabaseMetadataCache: mocks.removeDatabaseMetadataCache,
get databasesByName() {
return mocks.databasesByName;
},
get instancesByName() {
return mocks.instancesByName;
},
projectsByName: {
"projects/demo": { name: "projects/demo", title: "Demo Project" },
},
environmentList: [],
};
const useAppStore = (selector: (state: typeof appState) => unknown) =>
selector(appState);
useAppStore.getState = () => ({
fetchInstance: mocks.fetchInstance,
fetchInstanceList: mocks.fetchInstanceList,
batchSyncDatabases: vi.fn(),
batchUpdateDatabases: mocks.batchUpdateDatabases,
serverInfo: { defaultProject: "projects/default" },
});
return { useAppStore };
});
vi.mock("@/stores", () => ({
pushNotification: vi.fn(),
}));
vi.mock("@/utils", async () => {
const actual = await vi.importActual<typeof import("@/utils")>("@/utils");
return {
...actual,
engineNameV1: () => "PostgreSQL",
extractInstanceResourceName: (name: string) =>
name.match(/(?:^|\/)instances\/([^/]+)/)?.[1] ?? name,
getDefaultPagination: () => 1000,
hasProjectPermissionV2: (_project: unknown, permission: string) =>
mocks.projectPermissions.has(permission),
hasWorkspacePermissionV2: (permission: string) =>
mocks.workspacePermissions.has(permission),
PERMISSIONS_FOR_DATABASE_CREATE_ISSUE: [],
supportedEngineV1List: () => [],
};
});
beforeEach(async () => {
vi.clearAllMocks();
mocks.fetchInstanceList.mockImplementation(async () => ({ instances: [] }));
mocks.visibleDatabases = [];
mocks.databasesByName = {};
mocks.instancesByName = {};
mocks.routerCurrentName = "workspace.project.database";
mocks.routerCurrentQuery = {};
mocks.scenarioId = undefined;
mocks.batchUpdateDatabases.mockResolvedValue(undefined);
mocks.workspacePermissions = new Set([
"bb.instances.create",
"bb.instances.get",
"bb.instances.list",
]);
mocks.projectPermissions = new Set([
"bb.instances.create",
"bb.instances.get",
"bb.instances.list",
]);
({ ProjectDatabasesPage } = await import("./ProjectDatabasesPage"));
});
describe("ProjectDatabasesPage", () => {
test("shows a connect instance action when the project has no databases and no workspace instances", async () => {
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 0));
});
const toolbarButton = container.querySelector(
'button[data-product-intro-target="connect-database"]'
);
expect(toolbarButton?.textContent).toContain("project.connect-instance");
expect(
container.querySelector("[data-testid='database-table'] button")
).toBe(null);
expect(container.textContent).toContain(
"project.connect-instance-empty-placeholder"
);
act(() => {
root.unmount();
});
});
test("starts the connect database intro when requested after project creation", async () => {
mocks.routerCurrentQuery = { intro: "connect-database" };
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(mocks.useProductIntro).toHaveBeenCalledWith({
id: "connect-database",
title: "project.connect-instance-intro-title",
description: "project.connect-instance-intro-description",
disabled: false,
});
act(() => {
root.unmount();
});
});
test("routes the empty project connect action to instance creation with project context", async () => {
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
const button = container.querySelector(
'button[data-product-intro-target="connect-database"]'
) as HTMLButtonElement;
act(() => {
button.click();
});
expect(mocks.routerPush).toHaveBeenCalledWith({
name: "workspace.project.instance.create",
params: { projectId: "demo" },
});
expect(mocks.captureMetric).toHaveBeenCalledWith({
event: "connect database clicked",
properties: {
route_id: "workspace.project.database",
resource: "projects/demo",
},
});
act(() => {
root.unmount();
});
});
test("opens the create database sheet when the project is empty but the workspace has instances", async () => {
mocks.fetchInstanceList.mockResolvedValueOnce({
instances: [{ name: "instances/prod", title: "Prod" }],
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
const button = container.querySelector(
"button:not([data-product-intro-target])"
) as HTMLButtonElement;
expect(button.textContent?.trim()).toContain("database.create-database");
expect(container.textContent).toContain(
"project.add-database-empty-placeholder"
);
expect(container.textContent).not.toContain("project.connect-database");
await act(async () => {
button.click();
});
expect(mocks.routerPush).not.toHaveBeenCalled();
expect(
container.querySelector("[data-testid='create-database-sheet']")
).not.toBeNull();
act(() => {
root.unmount();
});
});
test("opens the create database sheet from a Project Home shortcut", async () => {
mocks.routerCurrentQuery = { createDatabase: "1" };
mocks.fetchInstanceList.mockResolvedValueOnce({
instances: [{ name: "instances/prod", title: "Prod" }],
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(container.querySelector("[data-testid='create-database-sheet']")).not.toBeNull();
act(() => root.unmount());
});
test("only checks workspace instances for the default project", async () => {
mocks.fetchInstanceList.mockImplementation(async (params) => {
if (params?.parent) {
throw new Error("the default project cannot own instances");
}
return {
instances: [{ name: "instances/prod", title: "Prod" }],
};
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="default" />);
await Promise.resolve();
});
expect(mocks.fetchInstanceList).toHaveBeenCalledTimes(1);
expect(mocks.fetchInstanceList).toHaveBeenCalledWith({ pageSize: 2 });
expect(container.textContent).toContain("database.create-database");
expect(container.textContent).not.toContain("project.connect-instance");
act(() => {
root.unmount();
});
});
test("only searches workspace instances for the default project", async () => {
mocks.fetchInstanceList.mockImplementation(async (params) => {
if (params?.parent) {
throw new Error("the default project cannot own instances");
}
return {
instances: [{ name: "instances/prod", title: "Prod" }],
};
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="default" />);
await Promise.resolve();
});
mocks.fetchInstanceList.mockClear();
const button = container.querySelector(
'[data-testid="search-instances"]'
) as HTMLElement;
await act(async () => {
button.click();
await Promise.resolve();
});
expect(mocks.fetchInstanceList).toHaveBeenCalledTimes(1);
expect(mocks.fetchInstanceList).toHaveBeenCalledWith({
pageSize: 1000,
filter: undefined,
});
act(() => {
root.unmount();
});
});
test("opens the create database sheet when the project has a project instance", async () => {
mocks.fetchInstanceList.mockImplementation(async (params) => ({
instances:
params?.parent === "projects/demo"
? [
{
name: "projects/demo/instances/prod",
title: "Project production",
},
]
: [],
}));
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(container.textContent).toContain("database.create-database");
expect(container.textContent).not.toContain("project.connect-database");
expect(mocks.fetchInstanceList).toHaveBeenCalledWith({
parent: "projects/demo",
pageSize: 2,
});
act(() => {
root.unmount();
});
});
test("disables the empty project connect action without project instance creation permission", async () => {
mocks.projectPermissions.delete("bb.instances.create");
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
await act(async () => {
await new Promise((resolve) => setTimeout(resolve, 0));
});
const button = container.querySelector(
'button[data-product-intro-target="connect-database"]'
) as HTMLButtonElement;
expect(button.textContent?.trim()).toContain("project.connect-instance");
expect(button.disabled).toBe(true);
expect(
container.querySelector("[data-testid='database-table'] button")
).toBe(null);
act(() => {
button.click();
});
expect(mocks.routerPush).not.toHaveBeenCalled();
act(() => {
root.unmount();
});
});
test("shows syncing guidance when redirected from project-aware instance creation", async () => {
mocks.routerCurrentQuery = { syncingInstance: "prod" };
mocks.instancesByName = {
"projects/demo/instances/prod": {
name: "projects/demo/instances/prod",
title: "Prod Instance",
},
};
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain(
"db.project-instance-syncing-titleProd Instance"
);
expect(container.textContent).not.toContain(
"db.project-instance-syncing-titleprod"
);
expect(container.textContent).toContain(
"db.project-instance-syncing-description"
);
expect(container.textContent).toContain("common.refresh");
expect(container.textContent).toContain(
"db.project-instance-syncing-empty"
);
expect(container.textContent).not.toContain("project.connect-database");
const refreshButton = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent?.includes("common.refresh")
) as HTMLButtonElement;
await act(async () => {
refreshButton.click();
});
act(() => {
root.unmount();
});
});
test("updates syncing guidance when the syncing instance query changes", async () => {
mocks.instancesByName = {
"projects/demo/instances/prod": {
name: "projects/demo/instances/prod",
title: "Prod Instance",
},
};
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).not.toContain(
"db.project-instance-syncing-title"
);
mocks.routerCurrentQuery = { syncingInstance: "prod" };
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain(
"db.project-instance-syncing-titleProd Instance"
);
act(() => {
root.unmount();
});
});
test("falls back to create database after redirected instance sync finds no databases", async () => {
vi.useFakeTimers();
mocks.routerCurrentQuery = { syncingInstance: "prod" };
mocks.fetchInstanceList.mockResolvedValue({
instances: [{ name: "instances/prod", title: "Prod" }],
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(container.textContent).toContain(
"db.project-instance-syncing-title"
);
await act(async () => {
vi.advanceTimersByTime(60000);
await Promise.resolve();
});
expect(container.textContent).not.toContain(
"db.project-instance-syncing-title"
);
const button = container.querySelector("button") as HTMLButtonElement;
expect(button.textContent?.trim()).toContain("database.create-database");
await act(async () => {
button.click();
});
expect(
container.querySelector("[data-testid='create-database-sheet']")
).not.toBeNull();
act(() => {
root.unmount();
});
vi.useRealTimers();
});
test("opens a synced project instance database in SQL Editor", async () => {
mocks.routerCurrentQuery = { syncingInstance: "prod" };
mocks.fetchInstanceList.mockResolvedValueOnce({
instances: [{ name: "instances/prod", title: "Prod" }],
});
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain("db.project-instance-synced-title");
expect(container.textContent).toContain(
"db.project-instance-synced-description"
);
expect(container.textContent).toContain(
"db.project-instance-synced-action"
);
expect(container.textContent).toContain(
"db.project-instance-synced-sql-editor-action"
);
expect(container.textContent).not.toContain(
"db.project-instance-syncing-title"
);
expect(
container
.querySelector("[role='alert']")
?.getAttribute("data-product-intro-target")
).toBe("project-instance-synced");
expect(mocks.useProductIntro).toHaveBeenCalledWith({
id: "project-instance-synced",
title: "db.project-instance-synced-title",
description: "db.project-instance-synced-description",
disabled: false,
});
const nextActionButton = Array.from(
container.querySelectorAll("button")
).find((button) =>
button.textContent?.includes("db.project-instance-synced-action")
) as HTMLButtonElement;
await act(async () => {
nextActionButton.click();
});
expect(preCreateIssue).toHaveBeenCalledWith("projects/demo", [
"projects/demo/instances/prod/databases/app",
]);
const sqlEditorButton = Array.from(container.querySelectorAll("a")).find(
(link) =>
link.textContent?.includes(
"db.project-instance-synced-sql-editor-action"
)
) as HTMLAnchorElement;
expect(sqlEditorButton.className).toContain("bg-accent");
expect(nextActionButton.className).toContain("border-control-border");
expect(
nextActionButton.compareDocumentPosition(sqlEditorButton) &
Node.DOCUMENT_POSITION_FOLLOWING
).toBe(Node.DOCUMENT_POSITION_FOLLOWING);
await act(async () => {
sqlEditorButton.click();
});
expect(mocks.routerPush).toHaveBeenCalledWith({
name: "sql-editor.database",
params: {
project: "demo",
instance: "prod",
database: "app",
},
});
act(() => {
root.unmount();
});
});
test("only offers a database change for the change scenario", async () => {
mocks.scenarioId = "create-database-change";
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain(
"db.project-instance-synced-create-change-title"
);
expect(container.textContent).toContain(
"db.project-instance-synced-create-change-description"
);
expect(container.textContent).toContain(
"db.project-instance-synced-action"
);
expect(container.textContent).not.toContain(
"db.project-instance-synced-sql-editor-action"
);
expect(mocks.useProductIntro).toHaveBeenCalledWith({
id: "project-instance-synced",
title: "db.project-instance-synced-create-change-title",
description: "db.project-instance-synced-create-change-description",
disabled: false,
});
const changeButton = Array.from(container.querySelectorAll("button")).find(
(button) =>
button.textContent?.includes("db.project-instance-synced-action")
) as HTMLButtonElement;
expect(changeButton.className).toContain("bg-accent");
await act(async () => {
changeButton.click();
});
expect(preCreateIssue).toHaveBeenCalledWith("projects/demo", [
"projects/demo/instances/prod/databases/app",
]);
act(() => {
root.unmount();
});
});
test.each([
"query-data",
"just-exploring",
] as const)("only offers SQL Editor for the %s scenario", async (scenarioId) => {
mocks.scenarioId = scenarioId;
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain(
"db.project-instance-synced-query-data-title"
);
expect(container.textContent).toContain(
"db.project-instance-synced-query-data-description"
);
expect(container.textContent).toContain(
"db.project-instance-synced-sql-editor-action"
);
expect(container.textContent).not.toContain(
"db.project-instance-synced-action"
);
expect(mocks.useProductIntro).toHaveBeenCalledWith({
id: "project-instance-synced",
title: "db.project-instance-synced-query-data-title",
description: "db.project-instance-synced-query-data-description",
disabled: false,
});
const sqlEditorButton = Array.from(container.querySelectorAll("a")).find(
(link) =>
link.textContent?.includes(
"db.project-instance-synced-sql-editor-action"
)
) as HTMLAnchorElement;
expect(sqlEditorButton.className).toContain("bg-accent");
act(() => {
root.unmount();
});
});
test("only offers marking sensitive data for its scenario", async () => {
mocks.scenarioId = "mark-sensitive-data";
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.textContent).toContain(
"db.project-instance-synced-mark-sensitive-data-title"
);
expect(container.textContent).toContain(
"db.project-instance-synced-mark-sensitive-data-description"
);
expect(container.textContent).toContain(
"db.project-instance-synced-mark-sensitive-data-action"
);
expect(container.textContent).not.toContain(
"db.project-instance-synced-sql-editor-action"
);
expect(container.textContent).not.toContain(
"db.project-instance-synced-action"
);
const markButton = Array.from(container.querySelectorAll("button")).find(
(button) =>
button.textContent?.includes(
"db.project-instance-synced-mark-sensitive-data-action"
)
) as HTMLButtonElement;
await act(async () => {
markButton.click();
});
expect(mocks.routerPush).toHaveBeenCalledWith({
name: "workspace.project.database.detail",
params: {
projectId: "demo",
instanceId: "prod",
databaseName: "app",
},
query: {
parent: "projects/demo/instances/prod",
intro: "mark-sensitive-data",
},
hash: "#catalog",
});
act(() => {
root.unmount();
});
});
test.each([false, true])("excludes Redis from the masking action (supported target: %s)", async (hasSupportedTarget) => {
mocks.scenarioId = "mark-sensitive-data";
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [{
name: "projects/demo/instances/redis/databases/0",
project: "projects/demo",
instanceResource: { engine: Engine.REDIS },
}];
if (hasSupportedTarget) mocks.visibleDatabases.push({
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
instanceResource: { engine: Engine.POSTGRES },
});
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => root.render(<ProjectDatabasesPage projectId="demo" />));
const button = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent?.includes("db.project-instance-synced-mark-sensitive-data-action")
);
expect(button).toBeDefined();
expect(button?.disabled).toBe(!hasSupportedTarget);
await act(async () => button?.click());
if (hasSupportedTarget) {
expect(mocks.routerPush).toHaveBeenCalledWith(expect.objectContaining({
params: { projectId: "demo", instanceId: "prod", databaseName: "app" },
}));
} else {
expect(mocks.routerPush).not.toHaveBeenCalled();
}
act(() => root.unmount());
});
test("shows database next actions when requested by the setup guide", async () => {
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(
container
.querySelector("[role='alert']")
?.getAttribute("data-product-intro-target")
).toBe("project-instance-synced");
expect(mocks.useProductIntro).toHaveBeenCalledWith({
id: "project-instance-synced",
title: "db.project-instance-synced-title",
description: "db.project-instance-synced-description",
disabled: false,
});
act(() => {
root.unmount();
});
});
test("keeps database next actions after the product intro is dismissed", async () => {
mocks.routerCurrentQuery = { intro: "project-instance-synced" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.querySelector("[role='alert']")).not.toBe(null);
mocks.routerCurrentQuery = {};
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
});
expect(container.querySelector("[role='alert']")).not.toBe(null);
act(() => {
root.unmount();
});
});
test("hides post-sync guidance when the workspace has multiple instances", async () => {
mocks.routerCurrentQuery = { syncingInstance: "prod" };
mocks.fetchInstanceList.mockResolvedValueOnce({
instances: [
{ name: "instances/prod", title: "Prod" },
{ name: "instances/staging", title: "Staging" },
],
});
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(mocks.fetchInstanceList).toHaveBeenCalledWith({ pageSize: 2 });
expect(container.textContent).not.toContain(
"db.project-instance-synced-title"
);
expect(mocks.useProductIntro).toHaveBeenCalledWith(
expect.objectContaining({
id: "project-instance-synced",
disabled: true,
})
);
act(() => {
root.unmount();
});
});
test("hides post-sync guidance without permission to list instances", async () => {
mocks.workspacePermissions.delete("bb.instances.list");
mocks.projectPermissions.delete("bb.instances.list");
mocks.routerCurrentQuery = { syncingInstance: "prod" };
mocks.visibleDatabases = [
{
name: "projects/demo/instances/prod/databases/app",
project: "projects/demo",
},
];
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="demo" />);
await Promise.resolve();
});
expect(mocks.fetchInstanceList).not.toHaveBeenCalled();
expect(container.textContent).not.toContain(
"db.project-instance-synced-title"
);
expect(mocks.useProductIntro).toHaveBeenCalledWith(
expect.objectContaining({
id: "project-instance-synced",
disabled: true,
})
);
act(() => {
root.unmount();
});
});
test("shows transfer project batch action for the default project", async () => {
mocks.visibleDatabases = [{ name: "instances/prod/databases/app" }];
mocks.databasesByName = {
"instances/prod/databases/app": { name: "instances/prod/databases/app" },
};
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="default" />);
await Promise.resolve();
});
await act(async () => {
await Promise.resolve();
});
const selectAllButton = container.querySelector(
'[data-testid="batch-select-all"]'
) as HTMLButtonElement;
await act(async () => {
selectAllButton.click();
});
const batchBar = container.querySelector(
'[data-testid="batch-operations-bar"]'
) as HTMLElement;
expect(batchBar.dataset.hasTransfer).toBe("true");
expect(batchBar.dataset.selectedCount).toBe("1");
const transferButton = container.querySelector(
'[data-testid="batch-transfer-project"]'
) as HTMLButtonElement;
expect(transferButton?.textContent).toContain("database.transfer-project");
await act(async () => {
transferButton.click();
});
expect(
container.querySelector('[data-testid="transfer-project-sheet"]')
).not.toBeNull();
act(() => {
root.unmount();
});
});
test("redirects to target project databases page after batch transfer", async () => {
mocks.visibleDatabases = [{ name: "instances/prod/databases/app" }];
mocks.databasesByName = {
"instances/prod/databases/app": { name: "instances/prod/databases/app" },
};
const container = document.createElement("div");
const root = createRoot(container);
await act(async () => {
root.render(<ProjectDatabasesPage projectId="default" />);
await Promise.resolve();
});
const selectAllButton = container.querySelector(
'[data-testid="batch-select-all"]'
) as HTMLButtonElement;
await act(async () => {
selectAllButton.click();
});
const transferButton = container.querySelector(
'[data-testid="batch-transfer-project"]'
) as HTMLButtonElement;
await act(async () => {
transferButton.click();
});
const transferSheet = container.querySelector(
'[data-testid="transfer-project-sheet"]'
) as HTMLButtonElement;
await act(async () => {
transferSheet.click();
await Promise.resolve();
});
expect(mocks.routerPush).toHaveBeenCalledWith({
name: "workspace.project.database",
params: {
projectId: "target",
},
});
act(() => {
root.unmount();
});
});
});