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 } from "react";
import { createRoot } from "react-dom/client";
import { beforeEach, describe, expect, test, vi } from "vitest";
import type { ReactRoute } from "@/app/router";
import { sqlEditorEvents } from "@/modules/sql-editor/model/events";
import {
type RequestRoleDraft,
saveAccessGrantDraft,
wasDeniedQueryRequestDraftDelivered,
} from "@/modules/sql-editor/model/accessGrantDraft";
import type { SQLEditorTab } from "@/types";
import { Engine } from "@/types/proto-es/v1/common_pb";
import {
DatabaseMetadataSchema,
DatabaseSchema$,
} from "@/types/proto-es/v1/database_service_pb";
import { SQLEditorRouteShell } from "./SQLEditorRouteShell";
(
globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;
const mocks = vi.hoisted(() => {
const tabsState = {
tabsById: new Map(),
openTmpTabList: [],
currentTabId: "",
addTab: vi.fn((payload: Partial<SQLEditorTab> = {}) => {
const tab = {
id: "tab-1",
savedQuery: "",
connection: {
instance: "",
database: "",
},
...payload,
} as SQLEditorTab;
tabsState.tabsById.set(tab.id, tab);
tabsState.currentTabId = tab.id;
return tab;
}),
initProject: vi.fn(async () => undefined),
updateCurrentTab: vi.fn(),
};
const editorState = {
project: "projects/proj1",
projectContextReady: true,
setProjectContextReady: vi.fn(),
setProject: vi.fn(),
};
return {
tabsState,
editorState,
maybeSwitchProject: vi.fn<(project: string) => Promise<string | undefined>>(
async (project: string) => project
),
setAsidePanelTab: vi.fn(),
openAccessGrantDrawer: vi.fn(),
openRequestRoleSheet: vi.fn(),
notify: vi.fn(),
getOrFetchProjectByName: vi.fn(),
hasInstanceFeature: vi.fn(),
roleList: [] as Array<{ name: string; permissions: string[] }>,
cleanupLegacyPouchDatabases: vi.fn(async () => undefined),
permissionState: {
missedBasicPermissions: [] as string[],
missedPermissions: [] as string[],
permitted: true,
},
getOrFetchDatabaseByName: vi.fn(async (name: string) => ({
name,
project: "projects/proj1",
})),
getOrFetchDatabaseMetadata: vi.fn(),
fetchInstance: vi.fn<
(name: string) => Promise<{ name: string } | undefined>
>(async (name: string) => ({ name })),
getSavedQueryByName: vi.fn(),
getOrFetchSavedQueryByName: vi.fn(),
searchProjects: vi.fn(),
beforeEach: vi.fn(() => vi.fn()),
navigateReplace: vi.fn(),
renderRoute: {
name: "sql-editor.database",
fullPath:
"/sql-editor/projects/proj1/instances/inst1/databases/db1?schema=public&table=users",
hash: "",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
schema: "public",
table: "users",
},
requiredPermissions: [],
overrideDocumentTitle: false,
meta: {},
} as ReactRoute,
currentRoute: {
name: "sql-editor.database",
fullPath:
"/sql-editor/projects/proj1/instances/inst1/databases/db1?schema=public&table=users",
hash: "",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
schema: "public",
table: "users",
},
requiredPermissions: [],
overrideDocumentTitle: false,
meta: {},
} as ReactRoute,
};
});
vi.mock("react-i18next", () => ({
initReactI18next: { type: "3rdParty", init: () => undefined },
useTranslation: () => ({
t: (key: string) => key,
}),
}));
vi.mock("@/components/ComponentPermissionGuard", () => ({
PermissionDeniedFallback: () => <div data-testid="denied" />,
useComponentPermissionState: vi.fn(() => mocks.permissionState),
usePermissionDataReady: () => true,
}));
vi.mock("@/hooks/useAppProject", () => ({
useAppProject: (name: string) => ({
name: name || "projects/-1",
}),
}));
vi.mock("@/modules/sql-editor/hooks/useSQLEditorState", () => ({
useClampResultRowsLimitToPolicy: vi.fn(),
}));
vi.mock("@/app/router", async (importOriginal) => ({
...(await importOriginal<typeof import("@/app/router")>()),
router: {
currentRoute: {
get value() {
return mocks.currentRoute;
},
},
beforeEach: mocks.beforeEach,
},
useCurrentRoute: () => mocks.renderRoute,
useNavigate: () => ({
replace: mocks.navigateReplace,
}),
}));
vi.mock("@/stores/app", () => ({
useAppStore: {
getState: () => ({
notify: mocks.notify,
getOrFetchProjectByName: mocks.getOrFetchProjectByName,
hasInstanceFeature: mocks.hasInstanceFeature,
roleList: mocks.roleList,
getOrFetchDatabaseByName: mocks.getOrFetchDatabaseByName,
getOrFetchDatabaseMetadata: mocks.getOrFetchDatabaseMetadata,
fetchInstance: mocks.fetchInstance,
getSavedQueryByName: mocks.getSavedQueryByName,
getOrFetchSavedQueryByName: mocks.getOrFetchSavedQueryByName,
searchProjects: mocks.searchProjects,
serverInfo: {
defaultProject: "projects/proj1",
},
}),
},
}));
vi.mock("./RequestDrawerHost", () => ({
useRequestDrawerHost: () => ({
openAccessGrantDrawer: mocks.openAccessGrantDrawer,
openRequestRoleSheet: mocks.openRequestRoleSheet,
}),
}));
vi.mock("@/modules/sql-editor/store", () => ({
useSQLEditorStore: Object.assign(
(selector: (state: unknown) => unknown) =>
selector({
maybeSwitchProject: mocks.maybeSwitchProject,
setAsidePanelTab: mocks.setAsidePanelTab,
asidePanelTab: "SCHEMA",
}),
{
getState: () => ({
fetchQueryHistory: vi.fn(),
setLinkedQueryHistory: vi.fn(),
}),
}
),
}));
vi.mock("@/utils", async (importOriginal) => ({
...(await importOriginal<typeof import("@/utils")>()),
isSavedQueryReadableV1: vi.fn(() => true),
}));
vi.mock("@/modules/sql-editor/store/editor", () => ({
getSQLEditorEditorState: () => mocks.editorState,
useSQLEditorEditorState: (selector: (state: unknown) => unknown) =>
selector(mocks.editorState),
}));
vi.mock("@/modules/sql-editor/store/tab", () => ({
getSQLEditorTabsState: () => mocks.tabsState,
useSQLEditorTabState: (selector: (state: unknown) => unknown) =>
selector(mocks.tabsState),
}));
vi.mock("@/modules/sql-editor/legacy/migration", () => ({
cleanupLegacyPouchDatabases: mocks.cleanupLegacyPouchDatabases,
}));
vi.mock("./SQLEditorHomePage", () => ({
SQLEditorHomePage: () => <div data-testid="sql-editor-home" />,
}));
const renderShell = () => {
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() => {
root.render(<SQLEditorRouteShell />);
});
return {
container,
rerender: () =>
act(() => {
root.render(<SQLEditorRouteShell />);
}),
unmount: () =>
act(() => {
root.unmount();
container.remove();
}),
};
};
beforeEach(() => {
vi.clearAllMocks();
localStorage.clear();
sessionStorage.clear();
mocks.maybeSwitchProject.mockImplementation(
async (project: string) => project
);
mocks.getOrFetchProjectByName.mockResolvedValue({
name: "projects/proj1",
allowRequestRole: true,
});
mocks.hasInstanceFeature.mockReturnValue(false);
mocks.roleList = [
{ name: "roles/sqlEditorReadUser", permissions: ["bb.sql.select"] },
];
mocks.openAccessGrantDrawer.mockReturnValue(true);
mocks.openRequestRoleSheet.mockReturnValue(true);
mocks.tabsState.addTab.mockImplementation(
(payload: Partial<SQLEditorTab> = {}) => {
const tab = {
id: "tab-1",
savedQuery: "",
connection: {
instance: "",
database: "",
},
...payload,
} as SQLEditorTab;
mocks.tabsState.tabsById.set(tab.id, tab);
mocks.tabsState.currentTabId = tab.id;
return tab;
}
);
mocks.getOrFetchDatabaseByName.mockImplementation(async (name: string) =>
create(DatabaseSchema$, {
name,
project: "projects/proj1",
instanceResource: {
name: "instances/inst1",
engine: Engine.POSTGRES,
},
})
);
mocks.getOrFetchDatabaseMetadata.mockResolvedValue(
create(DatabaseMetadataSchema, {
schemas: [
{
name: "public",
tables: [{ name: "users" }],
},
],
})
);
mocks.fetchInstance.mockImplementation(async (name: string) => ({ name }));
mocks.getSavedQueryByName.mockImplementation((name: string) => ({
name,
project: "projects/proj1",
}));
mocks.getOrFetchSavedQueryByName.mockImplementation(async (name: string) => ({
name,
project: "projects/proj1",
database: "instances/inst1/databases/db1",
content: new TextEncoder().encode("select 1"),
contentSize: BigInt(new TextEncoder().encode("select 1").length),
}));
mocks.editorState.project = "projects/proj1";
mocks.cleanupLegacyPouchDatabases.mockResolvedValue(undefined);
mocks.permissionState = {
missedBasicPermissions: [],
missedPermissions: [],
permitted: true,
};
mocks.tabsState.tabsById = new Map();
mocks.tabsState.openTmpTabList = [];
mocks.tabsState.currentTabId = "";
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.database",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
schema: "public",
table: "users",
},
requiredPermissions: [],
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor.database",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
schema: "public",
table: "users",
},
requiredPermissions: [],
};
});
describe("SQLEditorRouteShell", () => {
test("opens a prefilled Access Grant draft after the database route is ready", async () => {
const draft = {
project: "projects/proj1",
sourceDatabase: "instances/inst1/databases/db1",
targets: ["instances/inst1/databases/db1"],
statement: "SELECT id FROM users",
schema: "public",
};
const accessGrantDraftKey = saveAccessGrantDraft(draft);
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey },
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.openAccessGrantDrawer).toHaveBeenCalledOnce();
expect(mocks.openAccessGrantDrawer).toHaveBeenCalledWith({
query: draft.statement,
targets: draft.targets,
schema: draft.schema,
});
expect(sessionStorage.getItem(accessGrantDraftKey)).toBeNull();
expect(wasDeniedQueryRequestDraftDelivered(accessGrantDraftKey)).toBe(true);
expect(mocks.navigateReplace).toHaveBeenCalledWith(
expect.objectContaining({
name: "sql-editor.database",
query: {},
})
);
unmount();
});
test("opens a project instance draft when workspace IDs collide", async () => {
const sourceDatabase =
"projects/proj1/instances/inst1/databases/db1";
const accessGrantDraftKey = saveAccessGrantDraft({
project: "projects/proj1",
sourceDatabase,
targets: [sourceDatabase],
statement: "SELECT id FROM users",
});
mocks.renderRoute = {
...mocks.renderRoute,
query: {
parent: "projects/proj1/instances/inst1",
accessGrantDraftKey,
},
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.getOrFetchDatabaseByName).toHaveBeenCalledWith(sourceDatabase);
expect(mocks.getOrFetchDatabaseByName).not.toHaveBeenCalledWith(
"instances/inst1/databases/db1"
);
expect(mocks.openAccessGrantDrawer).toHaveBeenCalledWith({
query: "SELECT id FROM users",
targets: [sourceDatabase],
});
expect(wasDeniedQueryRequestDraftDelivered(accessGrantDraftKey)).toBe(true);
unmount();
});
test("opens a draft when an already mounted editor receives a database route", async () => {
const { rerender, unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
mocks.openAccessGrantDrawer.mockClear();
mocks.tabsState.addTab.mockClear();
const accessGrantDraftKey = saveAccessGrantDraft({
project: "projects/proj1",
sourceDatabase: "instances/inst1/databases/db1",
targets: ["instances/inst1/databases/db1"],
statement: "SELECT id FROM users",
});
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey },
};
mocks.currentRoute = mocks.renderRoute;
rerender();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.openAccessGrantDrawer).toHaveBeenCalledOnce();
expect(mocks.openAccessGrantDrawer).toHaveBeenCalledWith({
query: "SELECT id FROM users",
targets: ["instances/inst1/databases/db1"],
});
expect(mocks.navigateReplace).toHaveBeenCalledWith(
expect.objectContaining({ query: {} })
);
unmount();
});
test("opens a prefilled Request Role sheet for a non-JIT denied query", async () => {
const draft: RequestRoleDraft = {
kind: "requestRole",
project: "projects/proj1",
sourceDatabase: "instances/inst1/databases/db1",
targets: ["instances/inst1/databases/db1"],
resources: [
"instances/inst1/databases/db1/schemas/public/tables/users",
],
statement: "SELECT id FROM users",
requiredPermissions: ["bb.sql.select"],
};
const accessGrantDraftKey = saveAccessGrantDraft(draft);
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey },
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.openAccessGrantDrawer).not.toHaveBeenCalled();
expect(mocks.openRequestRoleSheet).toHaveBeenCalledOnce();
expect(mocks.openRequestRoleSheet).toHaveBeenCalledWith({
project: expect.objectContaining({ name: "projects/proj1" }),
requiredPermissions: ["bb.sql.select"],
initialRole: "roles/sqlEditorReadUser",
initialDatabaseResources: [
expect.objectContaining({
databaseFullName: "instances/inst1/databases/db1",
schema: "public",
table: "users",
}),
],
});
expect(sessionStorage.getItem(accessGrantDraftKey)).toBeNull();
expect(wasDeniedQueryRequestDraftDelivered(accessGrantDraftKey)).toBe(true);
unmount();
});
test("does not mark a draft delivered when another request drawer stays open", async () => {
const accessGrantDraftKey = saveAccessGrantDraft({
project: "projects/proj1",
sourceDatabase: "instances/inst1/databases/db1",
targets: ["instances/inst1/databases/db1"],
statement: "SELECT 1",
});
mocks.openAccessGrantDrawer.mockReturnValue(false);
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey },
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(wasDeniedQueryRequestDraftDelivered(accessGrantDraftKey)).toBe(false);
expect(mocks.notify).toHaveBeenCalledWith(
expect.objectContaining({ style: "CRITICAL" })
);
unmount();
});
test("warns when a draft link has expired", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey: "missing" },
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.openAccessGrantDrawer).not.toHaveBeenCalled();
expect(mocks.notify).toHaveBeenCalledWith(
expect.objectContaining({
style: "CRITICAL",
title: "sql-editor.access-request-draft-unavailable",
})
);
unmount();
});
test("does not open a draft for a different database than the route", async () => {
const accessGrantDraftKey = saveAccessGrantDraft({
project: "projects/proj1",
sourceDatabase: "instances/inst1/databases/other",
targets: ["instances/inst1/databases/other"],
statement: "SELECT 1",
});
mocks.renderRoute = {
...mocks.renderRoute,
query: { accessGrantDraftKey },
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.openAccessGrantDrawer).not.toHaveBeenCalled();
expect(mocks.notify).toHaveBeenCalledWith(
expect.objectContaining({ style: "CRITICAL" })
);
unmount();
});
test("waits for bootstrap before rendering the project selector", async () => {
let finishCleanup: (value: undefined) => void;
const cleanup = new Promise<undefined>((resolve) => {
finishCleanup = resolve;
});
mocks.editorState.project = "";
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.home",
params: {},
query: {},
};
mocks.currentRoute = mocks.renderRoute;
mocks.cleanupLegacyPouchDatabases.mockReturnValueOnce(cleanup);
const { container, unmount } = renderShell();
expect(
container.querySelector('[data-testid="sql-editor-home"]')
).toBeNull();
await act(async () => {
finishCleanup(undefined);
await cleanup;
await Promise.resolve();
await Promise.resolve();
});
expect(
container.querySelector('[data-testid="sql-editor-home"]')
).not.toBeNull();
unmount();
});
test("renders the project selector before workspace-level route permissions", async () => {
mocks.editorState.project = "";
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.home",
params: {},
query: {},
requiredPermissions: ["bb.projects.get"],
};
mocks.currentRoute = mocks.renderRoute;
mocks.permissionState = {
missedBasicPermissions: ["bb.roles.list"],
missedPermissions: ["bb.projects.get"],
permitted: false,
};
const { container, unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(
container.querySelector('[data-testid="sql-editor-home"]')
).not.toBeNull();
expect(container.querySelector('[data-testid="denied"]')).toBeNull();
unmount();
});
test("does not auto-select a project when the editor has no selection", async () => {
mocks.editorState.project = "";
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor",
params: {},
query: {},
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor",
params: {},
query: {},
};
mocks.maybeSwitchProject.mockImplementation(async (project: string) =>
project ? project : undefined
);
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.searchProjects).not.toHaveBeenCalled();
expect(mocks.maybeSwitchProject).not.toHaveBeenCalledWith(
"projects/proj1"
);
expect(mocks.editorState.setProject).toHaveBeenCalledWith("");
unmount();
});
test("does not restore the default project when it is the only project", async () => {
mocks.editorState.project = "projects/proj1";
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor",
params: {},
query: {},
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor",
params: {},
query: {},
};
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.searchProjects).not.toHaveBeenCalled();
expect(mocks.maybeSwitchProject).not.toHaveBeenCalledWith(
"projects/proj1"
);
expect(mocks.editorState.setProject).toHaveBeenCalledWith("");
unmount();
});
test("keeps a restored data explorer tab that matches the database route", async () => {
mocks.tabsState.initProject.mockImplementationOnce(async () => {
const tab = {
id: "explorer",
savedQuery: "",
mode: "DATA_EXPLORER",
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
dataExplorer: {
filter: "WHERE active = true",
initialized: false,
},
} as SQLEditorTab;
mocks.tabsState.tabsById.set(tab.id, tab);
mocks.tabsState.currentTabId = tab.id;
});
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).not.toHaveBeenCalled();
expect(mocks.tabsState.currentTabId).toBe("explorer");
unmount();
});
test("opens a query tab instead of reusing a restored data explorer tab for a guided query", async () => {
mocks.tabsState.initProject.mockImplementationOnce(async () => {
const tab = {
id: "explorer",
savedQuery: "",
mode: "DATA_EXPLORER",
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
dataExplorer: {
filter: "WHERE active = true",
initialized: false,
},
} as SQLEditorTab;
mocks.tabsState.tabsById.set(tab.id, tab);
mocks.tabsState.currentTabId = tab.id;
});
mocks.renderRoute = {
...mocks.renderRoute,
query: {
schema: "public",
table: "users",
intro: "run-query",
},
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
statement: 'SELECT * FROM "public"."users" LIMIT 50;',
});
expect(mocks.tabsState.currentTabId).toBe("tab-1");
unmount();
});
test("seeds database route tabs with schema and table from the URL", async () => {
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.database",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
table: "users",
schema: "public",
},
});
unmount();
});
test("generates a SELECT statement for a guided query target", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
query: {
schema: "public",
table: "users",
intro: "run-query",
},
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.getOrFetchDatabaseMetadata).toHaveBeenCalledWith({
database: "instances/inst1/databases/db1",
silent: true,
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
statement: 'SELECT * FROM "public"."users" LIMIT 50;',
});
unmount();
});
test("generates a SELECT statement when a mounted editor receives a guided query route", async () => {
const { rerender, unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
mocks.tabsState.addTab.mockClear();
mocks.renderRoute = {
...mocks.renderRoute,
query: {
schema: "public",
table: "users",
intro: "run-query",
},
};
mocks.currentRoute = mocks.renderRoute;
rerender();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
statement: 'SELECT * FROM "public"."users" LIMIT 50;',
});
unmount();
});
test("does not generate a statement outside the guided query intro", async () => {
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.getOrFetchDatabaseMetadata).not.toHaveBeenCalled();
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
unmount();
});
test("does not generate a guided statement for an unknown table", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
query: {
schema: "public",
table: "missing",
intro: "run-query",
},
};
mocks.currentRoute = mocks.renderRoute;
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "missing",
},
mode: "SAVED_QUERY",
});
unmount();
});
test("uses the render route when the imperative router snapshot is still on the parent route", async () => {
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor",
params: {},
query: {},
requiredPermissions: [],
};
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.database",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
table: "users",
schema: "public",
},
});
unmount();
});
test("opens the database route when the editor is already on that project", async () => {
mocks.editorState.project = "projects/proj1";
let switchProjectCallCount = 0;
mocks.maybeSwitchProject.mockImplementation(async (project: string) => {
switchProjectCallCount++;
return switchProjectCallCount === 1 ? project : undefined;
});
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
unmount();
});
test("resolves a project instance database without a parent query", async () => {
const parent = "projects/proj1/instances/inst1";
mocks.getOrFetchDatabaseByName.mockImplementation(async (name: string) =>
name.startsWith("projects/")
? { name, project: "projects/proj1" }
: {
name: "instances/-1/databases/-1",
project: "projects/-1",
}
);
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.getOrFetchDatabaseByName).toHaveBeenNthCalledWith(
1,
"instances/inst1/databases/db1"
);
expect(mocks.getOrFetchDatabaseByName).toHaveBeenNthCalledWith(
2,
`${parent}/databases/db1`
);
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: parent,
database: `${parent}/databases/db1`,
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.database",
params: {
project: "proj1",
instance: "inst1",
database: "db1",
},
query: {
table: "users",
schema: "public",
},
});
unmount();
});
test("restores a project instance connection without a parent query", async () => {
const parent = "projects/proj1/instances/inst1";
mocks.fetchInstance.mockImplementation(async (name: string) =>
name.startsWith("projects/") ? { name } : undefined
);
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.instance",
params: {
project: "proj1",
instance: "inst1",
},
query: {},
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor.instance",
params: {
project: "proj1",
instance: "inst1",
},
query: {},
};
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.fetchInstance).toHaveBeenNthCalledWith(
1,
"instances/inst1"
);
expect(mocks.fetchInstance).toHaveBeenNthCalledWith(2, parent);
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: parent,
database: "",
},
mode: "SAVED_QUERY",
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.instance",
params: {
project: "proj1",
instance: "inst1",
},
query: {},
});
unmount();
});
test("opens the database route when project context enrichment fails after database fetch", async () => {
mocks.editorState.project = "projects/other";
let switchProjectCallCount = 0;
mocks.maybeSwitchProject.mockImplementation(async (project: string) => {
switchProjectCallCount++;
return switchProjectCallCount === 1 ? project : undefined;
});
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.editorState.setProject).toHaveBeenCalledWith("projects/proj1");
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
unmount();
});
test("does not downgrade a database deep link while the tab connection is pending", async () => {
mocks.tabsState.addTab.mockImplementation(
(payload: Partial<SQLEditorTab> = {}) =>
({
id: "tab-pending",
savedQuery: "",
connection: {
instance: "",
database: "",
},
...payload,
}) as SQLEditorTab
);
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "users",
},
mode: "SAVED_QUERY",
});
expect(mocks.navigateReplace).not.toHaveBeenCalledWith({
name: "sql-editor.project",
params: {
project: "proj1",
},
query: {
table: "users",
},
});
unmount();
});
test("restores the sidebar tab from project-scoped localStorage", async () => {
localStorage.setItem(
"bb.sql-editor.sidebar.last-visited-tab.projects/proj1",
JSON.stringify("SAVED_QUERY")
);
const { unmount } = renderShell();
await act(async () => {
await sqlEditorEvents.emit("project-context-ready", {
project: "projects/proj1",
});
await new Promise((resolve) => requestAnimationFrame(resolve));
});
expect(mocks.setAsidePanelTab).toHaveBeenCalledWith("SAVED_QUERY");
unmount();
});
test("defaults the sidebar to schema for a database route", async () => {
const { unmount } = renderShell();
mocks.setAsidePanelTab.mockClear();
await act(async () => {
await sqlEditorEvents.emit("project-context-ready", {
project: "projects/proj1",
});
await new Promise((resolve) => requestAnimationFrame(resolve));
});
expect(mocks.setAsidePanelTab).toHaveBeenLastCalledWith("SCHEMA");
unmount();
});
test("defaults the sidebar to saved queries for a project route", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.project",
params: { project: "proj1" },
query: {},
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor.project",
params: { project: "proj1" },
query: {},
};
const { unmount } = renderShell();
mocks.setAsidePanelTab.mockClear();
await act(async () => {
await sqlEditorEvents.emit("project-context-ready", {
project: "projects/proj1",
});
await new Promise((resolve) => requestAnimationFrame(resolve));
});
expect(mocks.setAsidePanelTab).toHaveBeenLastCalledWith("SAVED_QUERY");
unmount();
});
test("updates a stale database URL when the active tab is disconnected", async () => {
mocks.tabsState.tabsById.set("tab-blank", {
id: "tab-blank",
savedQuery: "",
connection: {
instance: "",
database: "",
},
} as SQLEditorTab);
mocks.tabsState.currentTabId = "tab-blank";
mocks.tabsState.addTab.mockImplementation(
(payload: Partial<SQLEditorTab> = {}) => {
const tab = {
id: "tab-from-route",
savedQuery: "",
connection: {
instance: "",
database: "",
},
...payload,
} as SQLEditorTab;
mocks.tabsState.tabsById.set(tab.id, tab);
return tab;
}
);
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.project",
params: {
project: "proj1",
},
query: {},
});
unmount();
});
test("seeds saved query route tabs with schema and table from the URL", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.saved-query",
params: {
project: "proj1",
savedQuery: "sheet1",
},
query: {
schema: "public",
table: "SUPPORDERS_VIS.items",
},
requiredPermissions: [],
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor.saved-query",
params: {
project: "proj1",
savedQuery: "sheet1",
},
query: {
schema: "public",
table: "SUPPORDERS_VIS.items",
},
requiredPermissions: [],
};
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.tabsState.addTab).toHaveBeenCalledWith({
id: undefined,
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "SUPPORDERS_VIS.items",
},
savedQuery: "projects/proj1/savedQueries/sheet1",
title: undefined,
statement: "select 1",
status: "CLEAN",
});
unmount();
});
test("keeps schema and table query parameters when syncing saved query tabs", async () => {
mocks.renderRoute = {
...mocks.renderRoute,
name: "sql-editor.project",
params: {
project: "proj1",
},
query: {},
requiredPermissions: [],
};
mocks.currentRoute = {
...mocks.currentRoute,
name: "sql-editor.project",
params: {
project: "proj1",
},
query: {},
requiredPermissions: [],
};
mocks.tabsState.tabsById.set("tab-savedQuery", {
id: "tab-savedQuery",
savedQuery: "projects/proj1/savedQueries/sheet1",
connection: {
instance: "instances/inst1",
database: "instances/inst1/databases/db1",
schema: "public",
table: "SUPPORDERS_VIS.items",
},
} as SQLEditorTab);
mocks.tabsState.currentTabId = "tab-savedQuery";
const { unmount } = renderShell();
await act(async () => {
await Promise.resolve();
await Promise.resolve();
await Promise.resolve();
});
expect(mocks.navigateReplace).toHaveBeenCalledWith({
name: "sql-editor.saved-query",
params: {
project: "proj1",
savedQuery: "sheet1",
},
query: {
table: "SUPPORDERS_VIS.items",
schema: "public",
},
});
unmount();
});
});