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 { Code, ConnectError } from "@connectrpc/connect";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { afterEach, describe, expect, test, vi } from "vitest";
import type { WorkloadIdentity } from "@/types/proto-es/v1/workload_identity_service_pb";
import {
WorkloadIdentityConfig_ProviderType,
WorkloadIdentityConfigSchema,
WorkloadIdentitySchema,
} from "@/types/proto-es/v1/workload_identity_service_pb";
import { CreateWorkloadIdentitySheet } from "./CreateWorkloadIdentitySheet";
(
globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;
const mocks = vi.hoisted(() => {
const store = {
projectsByName: {},
getProjectIamPolicy: vi.fn(),
updateProjectIamPolicy: vi.fn(),
patchWorkspaceIamPolicy: vi.fn(),
createWorkloadIdentity: vi.fn(),
updateWorkloadIdentity: vi.fn(),
workspaceResourceName: () => "workspaces/default",
};
const useAppStore = vi.fn((selector: (state: typeof store) => unknown) =>
selector(store)
);
return {
store,
useAppStore: Object.assign(useAppStore, {
getState: () => store,
}),
};
});
vi.mock("react-i18next", () => ({
initReactI18next: { type: "3rdParty", init: () => undefined },
useTranslation: () => ({
t: (key: string) => key,
}),
}));
vi.mock("@/components/RoleSelect", () => ({
RoleSelect: () => <div data-testid="role-select" />,
}));
vi.mock("@/components/ui/sheet", () => ({
Sheet: ({ children, open }: { children: React.ReactNode; open: boolean }) =>
open ? <div>{children}</div> : null,
SheetBody: ({ children }: { children: React.ReactNode }) => (
<div>{children}</div>
),
SheetContent: ({ children }: { children: React.ReactNode }) => (
<div>{children}</div>
),
SheetFooter: ({ children }: { children: React.ReactNode }) => (
<div>{children}</div>
),
SheetHeader: ({ children }: { children: React.ReactNode }) => (
<div>{children}</div>
),
SheetTitle: ({ children }: { children: React.ReactNode }) => (
<h2>{children}</h2>
),
}));
vi.mock("@/hooks/useProjectByName", () => ({
useProjectByName: () => undefined,
}));
vi.mock("@/stores/app", () => ({
useAppStore: mocks.useAppStore,
}));
vi.mock("@/stores", () => ({
pushNotification: vi.fn(),
}));
// The real parser and resolver, so the tests see exactly what the form does
// with a stored subject. Only the permission checks are stubbed.
vi.mock("@/utils", async () => ({
...(await vi.importActual<typeof import("@/utils/workloadIdentity")>(
"@/utils/workloadIdentity"
)),
hasProjectPermissionV2: () => true,
hasWorkspacePermissionV2: () => true,
}));
describe("CreateWorkloadIdentitySheet", () => {
afterEach(() => {
document.body.innerHTML = "";
vi.clearAllMocks();
});
test("places role selection directly after email in create mode", () => {
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() => {
root.render(
<CreateWorkloadIdentitySheet
open
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const text = container.textContent ?? "";
const emailIndex = text.indexOf("common.email");
const rolesIndex = text.indexOf("settings.members.table.roles");
const platformIndex = text.indexOf(
"settings.members.workload-identity-platform"
);
expect(emailIndex).toBeGreaterThanOrEqual(0);
expect(rolesIndex).toBeGreaterThan(emailIndex);
expect(platformIndex).toBeGreaterThan(rolesIndex);
act(() => {
root.unmount();
});
});
test("places repository and branch helper text under the field title", () => {
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() => {
root.render(
<CreateWorkloadIdentitySheet
open
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const fields = Array.from(
container.querySelectorAll('[data-slot="form-field"]')
);
const repositoryField = fields.find((field) =>
field.textContent?.includes("settings.members.workload-identity-repo")
);
const branchField = fields.find((field) =>
field.textContent?.includes("settings.members.workload-identity-branch")
);
for (const field of [repositoryField, branchField]) {
expect(field).toBeTruthy();
const header = field?.querySelector('[data-slot="form-field-header"]');
const input = field?.querySelector("input");
expect(header).toBeTruthy();
expect(header?.textContent).toContain("hint");
expect(
header && input
? Node.DOCUMENT_POSITION_FOLLOWING &
header.compareDocumentPosition(input)
: 0
).toBeTruthy();
}
act(() => {
root.unmount();
});
});
test("presets the generated-workflow audience when creating a GitHub identity", async () => {
const created = create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "deploy",
});
mocks.store.createWorkloadIdentity.mockResolvedValue(created);
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
await act(async () => {
root.render(
<CreateWorkloadIdentitySheet
open
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const fields = Array.from(
container.querySelectorAll('[data-slot="form-field"]')
);
const fieldInput = (label: string) =>
fields
.find((field) => field.textContent?.includes(label))
?.querySelector("input");
const setInputValue = (
input: HTMLInputElement | null | undefined,
value: string
) => {
if (!input) return;
Object.getOwnPropertyDescriptor(
HTMLInputElement.prototype,
"value"
)?.set?.call(input, value);
input.dispatchEvent(new Event("input", { bubbles: true }));
};
await act(async () => {
setInputValue(fieldInput("common.email"), "deploy");
setInputValue(
fieldInput("settings.members.workload-identity-owner"),
"bytebase"
);
});
const createButton = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.create"
);
expect(createButton?.disabled).toBe(false);
await act(async () => {
createButton?.click();
});
expect(mocks.store.createWorkloadIdentity).toHaveBeenCalledOnce();
const [, workloadIdentity] =
mocks.store.createWorkloadIdentity.mock.calls[0];
// BYT-10151: this shipped as [] and the exchange skipped the audience
// check when the list was empty, so the identity accepted a token minted
// for anyone. The preset is what the generated workflows request.
expect(
workloadIdentity.workloadIdentityConfig?.allowedAudiences
).toEqual(["bytebase"]);
act(() => {
root.unmount();
});
});
test("preserves a custom subject pattern when updating another field", async () => {
const subjectPattern =
"project_path:group/project:environment:production";
const workloadIdentity = create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "Atlantis",
workloadIdentityConfig: create(WorkloadIdentityConfigSchema, {
providerType: WorkloadIdentityConfig_ProviderType.GITLAB,
issuerUrl: "https://nomad.example.com",
allowedAudiences: ["bytebase"],
subjectPattern,
}),
});
mocks.store.updateWorkloadIdentity.mockResolvedValue(workloadIdentity);
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
await act(async () => {
root.render(
<CreateWorkloadIdentitySheet
open
workloadIdentity={workloadIdentity}
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const advancedButton = Array.from(container.querySelectorAll("button")).find(
(button) =>
button.textContent?.includes(
"settings.members.workload-identity-advanced"
)
);
expect(advancedButton).toBeTruthy();
await act(async () => {
advancedButton?.click();
});
const subjectField = Array.from(
container.querySelectorAll('[data-slot="form-field"]')
).find((field) =>
field.textContent?.includes("settings.members.workload-identity-subject")
);
const subjectInput = subjectField?.querySelector("input");
expect(subjectInput?.value).toBe(subjectPattern);
const titleInput = container.querySelector("input");
expect(titleInput).toBeTruthy();
await act(async () => {
if (titleInput) {
Object.getOwnPropertyDescriptor(
HTMLInputElement.prototype,
"value"
)?.set?.call(titleInput, "Updated Atlantis");
titleInput.dispatchEvent(new Event("input", { bubbles: true }));
}
});
const updateButton = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
expect(updateButton).toBeTruthy();
await act(async () => {
updateButton?.click();
});
expect(mocks.store.updateWorkloadIdentity).toHaveBeenCalledOnce();
const [updatedWorkloadIdentity] =
mocks.store.updateWorkloadIdentity.mock.calls[0];
expect(
updatedWorkloadIdentity.workloadIdentityConfig?.subjectPattern
).toBe(subjectPattern);
act(() => {
root.unmount();
});
});
test("shows and submits generic OIDC fields without preset controls", async () => {
const workloadIdentity = create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "Atlantis",
workloadIdentityConfig: create(WorkloadIdentityConfigSchema, {
providerType: WorkloadIdentityConfig_ProviderType.OIDC,
issuerUrl: "https://nomad.example.com",
jwksUrl: "https://nomad-verifier.example.com/jwks.json",
allowedAudiences: ["bytebase", "terraform"],
subjectPattern: "nomad_job:atlantis:namespace:production",
}),
});
mocks.store.updateWorkloadIdentity.mockResolvedValue(workloadIdentity);
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
await act(async () => {
root.render(
<CreateWorkloadIdentitySheet
open
workloadIdentity={workloadIdentity}
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const fields = Array.from(
container.querySelectorAll('[data-slot="form-field"]')
);
const fieldInput = (label: string) =>
fields
.find((field) => field.textContent?.includes(label))
?.querySelector("input");
expect(
fields.some((field) =>
field.textContent?.includes("settings.members.workload-identity-owner")
)
).toBe(false);
expect(
fields.some((field) =>
field.textContent?.includes("settings.members.workload-identity-repo")
)
).toBe(false);
expect(fieldInput("settings.members.workload-identity-issuer")?.value).toBe(
"https://nomad.example.com"
);
expect(fieldInput("settings.members.workload-identity-jwks-url")?.value).toBe(
"https://nomad-verifier.example.com/jwks.json"
);
const audienceField = fields.find((field) =>
field.textContent?.includes(
"settings.members.workload-identity-audience"
)
);
expect(
Array.from(audienceField?.querySelectorAll("input") ?? []).map(
(input) => input.value
)
).toEqual(["bytebase", "terraform"]);
expect(fieldInput("settings.members.workload-identity-subject")?.value).toBe(
"nomad_job:atlantis:namespace:production"
);
const titleInput = container.querySelector("input");
expect(titleInput).toBeTruthy();
await act(async () => {
if (titleInput) {
Object.getOwnPropertyDescriptor(
HTMLInputElement.prototype,
"value"
)?.set?.call(titleInput, "Updated Atlantis");
titleInput.dispatchEvent(new Event("input", { bubbles: true }));
}
});
const updateButton = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
expect(updateButton).toBeTruthy();
await act(async () => {
updateButton?.click();
});
expect(mocks.store.updateWorkloadIdentity).toHaveBeenCalledOnce();
const [updatedWorkloadIdentity, updateMask] =
mocks.store.updateWorkloadIdentity.mock.calls[0];
expect(updatedWorkloadIdentity.workloadIdentityConfig).toMatchObject({
providerType: WorkloadIdentityConfig_ProviderType.OIDC,
issuerUrl: "https://nomad.example.com",
jwksUrl: "https://nomad-verifier.example.com/jwks.json",
allowedAudiences: ["bytebase", "terraform"],
subjectPattern: "nomad_job:atlantis:namespace:production",
});
expect(updateMask.paths).toEqual(["title"]);
act(() => {
root.unmount();
});
});
test("adds and removes generic OIDC audiences", async () => {
const workloadIdentity = create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "Atlantis",
workloadIdentityConfig: create(WorkloadIdentityConfigSchema, {
providerType: WorkloadIdentityConfig_ProviderType.OIDC,
issuerUrl: "https://nomad.example.com",
allowedAudiences: ["bytebase", "terraform"],
subjectPattern: "nomad_job:atlantis:namespace:production",
}),
});
mocks.store.updateWorkloadIdentity.mockResolvedValue(workloadIdentity);
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
await act(async () => {
root.render(
<CreateWorkloadIdentitySheet
open
workloadIdentity={workloadIdentity}
onClose={() => undefined}
onCreated={() => undefined}
/>
);
});
const audienceField = Array.from(
container.querySelectorAll('[data-slot="form-field"]')
).find((field) =>
field.textContent?.includes(
"settings.members.workload-identity-audience"
)
);
const addButton = audienceField?.querySelector<HTMLButtonElement>(
'button[aria-label="common.add"]'
);
expect(addButton).toBeTruthy();
await act(async () => {
addButton?.click();
});
let audienceInputs = Array.from(
audienceField?.querySelectorAll("input") ?? []
);
expect(audienceInputs.map((input) => input.value)).toEqual([
"bytebase",
"terraform",
"",
]);
const updateButton = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
expect(updateButton?.disabled).toBe(true);
await act(async () => {
const newAudienceInput = audienceInputs[2];
Object.getOwnPropertyDescriptor(
HTMLInputElement.prototype,
"value"
)?.set?.call(newAudienceInput, "deployment");
newAudienceInput.dispatchEvent(new Event("input", { bubbles: true }));
});
const removeButtons = audienceField?.querySelectorAll<HTMLButtonElement>(
'button[aria-label="common.remove"]'
);
expect(removeButtons).toHaveLength(3);
await act(async () => {
removeButtons?.[1]?.click();
});
audienceInputs = Array.from(
audienceField?.querySelectorAll("input") ?? []
);
expect(audienceInputs.map((input) => input.value)).toEqual([
"bytebase",
"deployment",
]);
expect(updateButton?.disabled).toBe(false);
await act(async () => {
updateButton?.click();
});
expect(mocks.store.updateWorkloadIdentity).toHaveBeenCalledOnce();
const [updatedWorkloadIdentity, updateMask] =
mocks.store.updateWorkloadIdentity.mock.calls[0];
expect(
updatedWorkloadIdentity.workloadIdentityConfig?.allowedAudiences
).toEqual(["bytebase", "deployment"]);
expect(updateMask.paths).toEqual(["workload_identity_config"]);
act(() => {
root.unmount();
});
});
// Both bugs below reproduce on main. #21309 skips the first run of the
// fields-to-pattern effect, which covers opening the sheet; it does not
// cover a subject typed after any derived field is edited.
const editableIdentity = (
providerType: WorkloadIdentityConfig_ProviderType,
subjectPattern: string
) =>
create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "CI deploy",
workloadIdentityConfig: create(WorkloadIdentityConfigSchema, {
providerType,
issuerUrl: "https://token.actions.githubusercontent.com",
allowedAudiences: ["bytebase"],
subjectPattern,
}),
});
const renderSheet = (workloadIdentity?: WorkloadIdentity) => {
const container = document.createElement("div");
document.body.appendChild(container);
const root = createRoot(container);
act(() => {
root.render(
<CreateWorkloadIdentitySheet
open
workloadIdentity={workloadIdentity}
onClose={() => undefined}
onCreated={() => undefined}
onUpdated={() => undefined}
/>
);
});
return { container, root };
};
const inputFor = (container: HTMLElement, label: string) =>
Array.from(container.querySelectorAll('[data-slot="form-field"]'))
.find((field) => field.textContent?.includes(label))
?.querySelector("input") as HTMLInputElement;
const type = (input: HTMLInputElement, value: string) =>
act(() => {
Object.getOwnPropertyDescriptor(
HTMLInputElement.prototype,
"value"
)?.set?.call(input, value);
input.dispatchEvent(new Event("input", { bubbles: true }));
});
const openAdvanced = (container: HTMLElement) =>
act(() => {
Array.from(container.querySelectorAll("button"))
.find((button) =>
button.textContent?.includes(
"settings.members.workload-identity-advanced"
)
)
?.click();
});
test("keeps a subject pattern typed after a field edit", async () => {
const identity = editableIdentity(
WorkloadIdentityConfig_ProviderType.GITHUB,
"repo:acme-corp/deploy:ref:refs/heads/main"
);
mocks.store.updateWorkloadIdentity.mockResolvedValue(identity);
const { container, root } = renderSheet(identity);
type(inputFor(container, "settings.members.workload-identity-owner"), "acme-two");
openAdvanced(container);
const pinned = "repo:acme-two/deploy:environment:production";
type(inputFor(container, "settings.members.workload-identity-subject"), pinned);
expect(
inputFor(container, "settings.members.workload-identity-subject").value
).toBe(pinned);
const update = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
await act(async () => {
update?.click();
});
expect(
mocks.store.updateWorkloadIdentity.mock.calls[0]?.[0]
?.workloadIdentityConfig?.subjectPattern
).toBe(pinned);
act(() => root.unmount());
});
test("recomputes the subject pattern from every derived control", () => {
const { container, root } = renderSheet(
editableIdentity(
WorkloadIdentityConfig_ProviderType.GITHUB,
"repo:acme-corp/deploy:ref:refs/heads/main"
)
);
openAdvanced(container);
const subject = () =>
inputFor(container, "settings.members.workload-identity-subject").value;
type(inputFor(container, "settings.members.workload-identity-owner"), "acme-two");
expect(subject()).toBe("repo:acme-two/deploy:ref:refs/heads/main");
type(inputFor(container, "settings.members.workload-identity-repo"), "release");
expect(subject()).toBe("repo:acme-two/release:ref:refs/heads/main");
type(inputFor(container, "settings.members.workload-identity-branch"), "dev");
expect(subject()).toBe("repo:acme-two/release:ref:refs/heads/dev");
act(() => root.unmount());
});
const audienceField = (container: HTMLElement) =>
Array.from(container.querySelectorAll('[data-slot="form-field"]')).find(
(field) =>
field.textContent?.includes("settings.members.workload-identity-audience")
);
const audienceInput = (container: HTMLElement) =>
audienceField(container)?.querySelector("input") as HTMLInputElement;
test("shows the audience field without opening Advanced Settings", () => {
const { container, root } = renderSheet();
// A required field the operator cannot see leaves Create disabled with
// nothing on screen to explain why.
expect(audienceInput(container)).toBeTruthy();
expect(audienceInput(container).value).toBe("bytebase");
expect(audienceField(container)?.textContent).toContain("*");
act(() => root.unmount());
});
test("blocks a save with no audience", () => {
const identity = editableIdentity(
WorkloadIdentityConfig_ProviderType.GITHUB,
"repo:acme-corp/deploy:ref:refs/heads/main"
);
const { container, root } = renderSheet(identity);
const update = () =>
Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
type(audienceInput(container), " ");
expect(update()?.hasAttribute("disabled")).toBe(true);
type(audienceInput(container), "https://bytebase.acme.com/wi/ci");
expect(update()?.hasAttribute("disabled")).toBe(false);
act(() => root.unmount());
});
// An identity whose audience list is empty, which an older replica can still
// write after the backfill has run. Prefilling would make the form look
// unchanged, so Update would stay disabled and the row could never be
// repaired.
test("does not prefill an audience the identity does not hold", () => {
const unrepaired = create(WorkloadIdentitySchema, {
name: "workloadIdentities/[email protected]",
email: "[email protected]",
title: "GHES deploy",
workloadIdentityConfig: create(WorkloadIdentityConfigSchema, {
providerType: WorkloadIdentityConfig_ProviderType.GITHUB,
issuerUrl: "https://ghes.acme.com",
allowedAudiences: [],
subjectPattern: "repo:acme-corp/deploy:ref:refs/heads/main",
}),
});
const { container, root } = renderSheet(unrepaired);
expect(audienceInput(container).value).toBe("");
type(audienceInput(container), "https://ghes.acme.com/oidc");
expect(
Array.from(container.querySelectorAll("button"))
.find((button) => button.textContent === "common.update")
?.hasAttribute("disabled")
).toBe(false);
act(() => root.unmount());
});
// validateWorkloadIdentityConfig owns the configuration rules; the form does
// not restate them. What it owes the operator is the server's reason, beside
// the fields, with Advanced open so the field the reason names is visible.
test("shows the server's rejection beside the fields", async () => {
const identity = editableIdentity(
WorkloadIdentityConfig_ProviderType.GITHUB,
"repo:acme-corp/deploy:ref:refs/heads/main"
);
const { container, root } = renderSheet(identity);
mocks.store.updateWorkloadIdentity.mockRejectedValueOnce(
new ConnectError(
'subject pattern "repo:acme*" matches every repository from this issuer',
Code.InvalidArgument
)
);
expect(container.textContent).not.toContain(
"settings.members.workload-identity-subject"
);
type(audienceInput(container), "bytebase-prod");
const update = Array.from(container.querySelectorAll("button")).find(
(button) => button.textContent === "common.update"
);
await act(async () => {
update?.click();
});
expect(
container.querySelector('[data-slot="form-error"]')?.textContent
).toContain("matches every repository");
expect(container.textContent).toContain(
"settings.members.workload-identity-subject"
);
act(() => root.unmount());
});
});