Skip to content

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

115 KB
Raw Blame
import { create as createProto } from "@bufbuild/protobuf";
import { TimestampSchema } from "@bufbuild/protobuf/wkt";
import { Code, ConnectError } from "@connectrpc/connect";
import { beforeEach, describe, expect, test, vi } from "vitest";
import {
  silentContextKey,
  skipErrorNotificationContextKey,
} from "@/api/context-key";
import { isValidDatabaseGroupName, UNKNOWN_PROJECT_NAME } from "@/types";
import { ExprSchema } from "@/types/proto-es/google/type/expr_pb";
import {
  AccessGrant_Status,
  AccessGrantSchema,
} from "@/types/proto-es/v1/access_grant_service_pb";
import { ActuatorInfoSchema } from "@/types/proto-es/v1/actuator_service_pb";
import { AuthenticationInfoSchema } from "@/types/proto-es/v1/auth_service_pb";
import {
  ChangelogSchema,
  ChangelogView,
} from "@/types/proto-es/v1/changelog_service_pb";
import { State } from "@/types/proto-es/v1/common_pb";
import {
  DatabaseGroupSchema,
  DatabaseGroupView,
} from "@/types/proto-es/v1/database_group_service_pb";
import { DatabaseSchema$ } from "@/types/proto-es/v1/database_service_pb";
import { GroupSchema } from "@/types/proto-es/v1/group_service_pb";
import {
  BindingSchema,
  IamPolicySchema,
} from "@/types/proto-es/v1/iam_policy_pb";
import { IdentityProviderSchema } from "@/types/proto-es/v1/idp_service_pb";
import { InstanceRoleSchema } from "@/types/proto-es/v1/instance_role_service_pb";
import { InstanceSchema } from "@/types/proto-es/v1/instance_service_pb";
import { IssueCommentSchema } from "@/types/proto-es/v1/issue_service_pb";
import {
  ProjectSchema,
  WebhookSchema,
} from "@/types/proto-es/v1/project_service_pb";
import { ReleaseSchema } from "@/types/proto-es/v1/release_service_pb";
import { RevisionSchema } from "@/types/proto-es/v1/revision_service_pb";
import { RoleSchema } from "@/types/proto-es/v1/role_service_pb";
import { ServiceAccountSchema } from "@/types/proto-es/v1/service_account_service_pb";
import {
  DatabaseChangeMode,
  EnvironmentSetting_EnvironmentSchema,
  EnvironmentSettingSchema,
  SettingSchema,
  SettingValueSchema,
  WorkspaceProfileSettingSchema,
} from "@/types/proto-es/v1/setting_service_pb";
import { SheetSchema } from "@/types/proto-es/v1/sheet_service_pb";
import {
  PlanFeature,
  PlanType,
  SubscriptionSchema,
} from "@/types/proto-es/v1/subscription_service_pb";
import {
  UpdateUserRequestSchema,
  UserSchema,
} from "@/types/proto-es/v1/user_service_pb";
import { WorkloadIdentitySchema } from "@/types/proto-es/v1/workload_identity_service_pb";
import { WorkspaceSchema } from "@/types/proto-es/v1/workspace_service_pb";
import { hexToColor } from "@/utils";
import {
  storageKeyIntroState,
  storageKeyRecentProjects,
  storageKeyRecentVisit,
} from "@/utils/storage-keys";
import { createAppStore } from ".";

const mocks = vi.hoisted(() => ({
  localStorage: (() => {
    const storage = new Map<string, string>();
    const localStorage = {
      clear: vi.fn(() => storage.clear()),
      getItem: vi.fn((key: string) => storage.get(key) ?? null),
      removeItem: vi.fn((key: string) => storage.delete(key)),
      setItem: vi.fn((key: string, value: string) => {
        storage.set(key, value);
      }),
    };
    vi.stubGlobal("localStorage", localStorage);
    return localStorage;
  })(),
  getCurrentUser: vi.fn(),
  login: vi.fn(),
  logout: vi.fn(),
  navigateByName: vi.fn(),
  navigateToPath: vi.fn(),
  resolvePath: vi.fn(
    (
      name: string,
      options?: { query?: Record<string, string | undefined> }
    ) => {
      const base =
        name === "auth.signin"
          ? "/auth"
          : name === "sql-editor.home"
            ? "/sql-editor"
            : "/";
      const query = new URLSearchParams();
      for (const [key, value] of Object.entries(options?.query ?? {})) {
        if (value) query.set(key, value);
      }
      const serialized = query.toString();
      return serialized ? `${base}?${serialized}` : base;
    }
  ),
  signup: vi.fn(),
  getAuthenticationInfo: vi.fn(),
  getActuatorInfo: vi.fn(),
  getWorkspace: vi.fn(),
  updateWorkspace: vi.fn(),
  getIamPolicy: vi.fn(),
  setIamPolicy: vi.fn(),
  listRoles: vi.fn(),
  updateRole: vi.fn(),
  deleteRole: vi.fn(),
  getSubscription: vi.fn(),
  startTrial: vi.fn(),
  uploadLicense: vi.fn(),
  getSetting: vi.fn(),
  getProject: vi.fn(),
  getProjectIamPolicy: vi.fn(),
  setProjectIamPolicy: vi.fn(),
  batchGetProjects: vi.fn(),
  searchProjects: vi.fn(),
  createProject: vi.fn(),
  addWebhook: vi.fn(),
  updateWebhook: vi.fn(),
  removeWebhook: vi.fn(),
  testWebhook: vi.fn(),
  getInstance: vi.fn(),
  listReleases: vi.fn(),
  getRelease: vi.fn(),
  updateRelease: vi.fn(),
  deleteRelease: vi.fn(),
  undeleteRelease: vi.fn(),
  listRevisions: vi.fn(),
  getRevision: vi.fn(),
  deleteRevision: vi.fn(),
  getDatabase: vi.fn(),
  batchGetDatabases: vi.fn(),
  listDatabases: vi.fn(),
  listChangelogs: vi.fn(),
  getChangelog: vi.fn(),
  getDatabaseMetadata: vi.fn(),
  getDatabaseCatalog: vi.fn(),
  updateDatabaseCatalog: vi.fn(),
  getDatabaseGroup: vi.fn(),
  listDatabaseGroups: vi.fn(),
  getSheet: vi.fn(),
  createSheet: vi.fn(),
  listInstanceRoles: vi.fn(),
  listGroups: vi.fn(),
  batchGetGroups: vi.fn(),
  getGroup: vi.fn(),
  createGroup: vi.fn(),
  updateGroup: vi.fn(),
  deleteGroup: vi.fn(),
  listServiceAccounts: vi.fn(),
  getServiceAccount: vi.fn(),
  createServiceAccount: vi.fn(),
  updateServiceAccount: vi.fn(),
  deleteServiceAccount: vi.fn(),
  undeleteServiceAccount: vi.fn(),
  listWorkloadIdentities: vi.fn(),
  getWorkloadIdentity: vi.fn(),
  createWorkloadIdentity: vi.fn(),
  updateWorkloadIdentity: vi.fn(),
  deleteWorkloadIdentity: vi.fn(),
  undeleteWorkloadIdentity: vi.fn(),
  listIdentityProviders: vi.fn(),
  getIdentityProvider: vi.fn(),
  createIdentityProvider: vi.fn(),
  updateIdentityProvider: vi.fn(),
  deleteIdentityProvider: vi.fn(),
  listUsers: vi.fn(),
  getUser: vi.fn(),
  batchGetUsers: vi.fn(),
  createUser: vi.fn(),
  updateUser: vi.fn(),
  updateEmail: vi.fn(),
  deleteUser: vi.fn(),
  undeleteUser: vi.fn(),
  getAccessGrant: vi.fn(),
  searchMyAccessGrants: vi.fn(),
  createAccessGrant: vi.fn(),
  listAccessGrants: vi.fn(),
  activateAccessGrant: vi.fn(),
  revokeAccessGrant: vi.fn(),
  listIssueComments: vi.fn(),
  createIssueComment: vi.fn(),
  updateIssueComment: vi.fn(),
}));

vi.mock("@/api", () => ({
  actuatorServiceClientConnect: {
    getActuatorInfo: mocks.getActuatorInfo,
  },
  authServiceClientConnect: {
    getAuthenticationInfo: mocks.getAuthenticationInfo,
    login: mocks.login,
    logout: mocks.logout,
    signup: mocks.signup,
  },
  projectServiceClientConnect: {
    getProject: mocks.getProject,
    getIamPolicy: mocks.getProjectIamPolicy,
    setIamPolicy: mocks.setProjectIamPolicy,
    batchGetProjects: mocks.batchGetProjects,
    searchProjects: mocks.searchProjects,
    createProject: mocks.createProject,
    addWebhook: mocks.addWebhook,
    updateWebhook: mocks.updateWebhook,
    removeWebhook: mocks.removeWebhook,
    testWebhook: mocks.testWebhook,
  },
  releaseServiceClientConnect: {
    listReleases: mocks.listReleases,
    getRelease: mocks.getRelease,
    updateRelease: mocks.updateRelease,
    deleteRelease: mocks.deleteRelease,
    undeleteRelease: mocks.undeleteRelease,
  },
  revisionServiceClientConnect: {
    listRevisions: mocks.listRevisions,
    getRevision: mocks.getRevision,
    deleteRevision: mocks.deleteRevision,
  },
  instanceServiceClientConnect: {
    getInstance: mocks.getInstance,
  },
  changelogServiceClientConnect: {
    listChangelogs: mocks.listChangelogs,
    getChangelog: mocks.getChangelog,
  },
  databaseServiceClientConnect: {
    getDatabase: mocks.getDatabase,
    batchGetDatabases: mocks.batchGetDatabases,
    listDatabases: mocks.listDatabases,
    getDatabaseMetadata: mocks.getDatabaseMetadata,
  },
  databaseCatalogServiceClientConnect: {
    getDatabaseCatalog: mocks.getDatabaseCatalog,
    updateDatabaseCatalog: mocks.updateDatabaseCatalog,
  },
  databaseGroupServiceClientConnect: {
    getDatabaseGroup: mocks.getDatabaseGroup,
    listDatabaseGroups: mocks.listDatabaseGroups,
  },
  sheetServiceClientConnect: {
    getSheet: mocks.getSheet,
    createSheet: mocks.createSheet,
  },
  instanceRoleServiceClientConnect: {
    listInstanceRoles: mocks.listInstanceRoles,
  },
  groupServiceClientConnect: {
    listGroups: mocks.listGroups,
    batchGetGroups: mocks.batchGetGroups,
    getGroup: mocks.getGroup,
    createGroup: mocks.createGroup,
    updateGroup: mocks.updateGroup,
    deleteGroup: mocks.deleteGroup,
  },
  serviceAccountServiceClientConnect: {
    listServiceAccounts: mocks.listServiceAccounts,
    getServiceAccount: mocks.getServiceAccount,
    createServiceAccount: mocks.createServiceAccount,
    updateServiceAccount: mocks.updateServiceAccount,
    deleteServiceAccount: mocks.deleteServiceAccount,
    undeleteServiceAccount: mocks.undeleteServiceAccount,
  },
  workloadIdentityServiceClientConnect: {
    listWorkloadIdentities: mocks.listWorkloadIdentities,
    getWorkloadIdentity: mocks.getWorkloadIdentity,
    createWorkloadIdentity: mocks.createWorkloadIdentity,
    updateWorkloadIdentity: mocks.updateWorkloadIdentity,
    deleteWorkloadIdentity: mocks.deleteWorkloadIdentity,
    undeleteWorkloadIdentity: mocks.undeleteWorkloadIdentity,
  },
  identityProviderServiceClientConnect: {
    listIdentityProviders: mocks.listIdentityProviders,
    getIdentityProvider: mocks.getIdentityProvider,
    createIdentityProvider: mocks.createIdentityProvider,
    updateIdentityProvider: mocks.updateIdentityProvider,
    deleteIdentityProvider: mocks.deleteIdentityProvider,
  },
  accessGrantServiceClientConnect: {
    getAccessGrant: mocks.getAccessGrant,
    searchMyAccessGrants: mocks.searchMyAccessGrants,
    createAccessGrant: mocks.createAccessGrant,
    listAccessGrants: mocks.listAccessGrants,
    activateAccessGrant: mocks.activateAccessGrant,
    revokeAccessGrant: mocks.revokeAccessGrant,
  },
  roleServiceClientConnect: {
    listRoles: mocks.listRoles,
    updateRole: mocks.updateRole,
    deleteRole: mocks.deleteRole,
  },
  settingServiceClientConnect: {
    getSetting: mocks.getSetting,
  },
  subscriptionServiceClientConnect: {
    getSubscription: mocks.getSubscription,
    startTrial: mocks.startTrial,
    uploadLicense: mocks.uploadLicense,
  },
  userServiceClientConnect: {
    getCurrentUser: mocks.getCurrentUser,
    listUsers: mocks.listUsers,
    getUser: mocks.getUser,
    batchGetUsers: mocks.batchGetUsers,
    createUser: mocks.createUser,
    updateUser: mocks.updateUser,
    updateEmail: mocks.updateEmail,
    deleteUser: mocks.deleteUser,
    undeleteUser: mocks.undeleteUser,
  },
  workspaceServiceClientConnect: {
    getWorkspace: mocks.getWorkspace,
    updateWorkspace: mocks.updateWorkspace,
    getIamPolicy: mocks.getIamPolicy,
    setIamPolicy: mocks.setIamPolicy,
  },
  issueServiceClientConnect: {
    listIssueComments: mocks.listIssueComments,
    createIssueComment: mocks.createIssueComment,
    updateIssueComment: mocks.updateIssueComment,
  },
}));

vi.mock("@/app/router/navigation", () => ({
  navigateByName: mocks.navigateByName,
  navigateToPath: mocks.navigateToPath,
  resolvePath: mocks.resolvePath,
}));

const user = createProto(UserSchema, {
  name: "users/[email protected]",
  email: "[email protected]",
  groups: ["groups/dba"],
  workspace: "workspaces/default",
});

const workspacePolicyForUser = (role: string) =>
  createProto(IamPolicySchema, {
    bindings: [
      createProto(BindingSchema, {
        role,
        members: [`user:${user.email}`],
      }),
    ],
  });

const projectA = createProto(ProjectSchema, {
  name: "projects/a",
  title: "A",
  state: State.ACTIVE,
});

const projectB = createProto(ProjectSchema, {
  name: "projects/b",
  title: "B",
  state: State.ACTIVE,
});

const groupA = createProto(GroupSchema, {
  name: "groups/[email protected]",
  email: "[email protected]",
  title: "DBA",
});

const groupB = createProto(GroupSchema, {
  name: "groups/[email protected]",
  email: "[email protected]",
  title: "Dev",
});

const userA = createProto(UserSchema, {
  name: "users/[email protected]",
  email: "[email protected]",
  title: "Bob",
  state: State.ACTIVE,
});

const userB = createProto(UserSchema, {
  name: "users/[email protected]",
  email: "[email protected]",
  title: "Carol",
  state: State.ACTIVE,
});

const roleA = createProto(RoleSchema, {
  name: "roles/sql-reviewer",
  title: "SQL Reviewer",
  permissions: ["bb.plans.get"],
});

const roleB = createProto(RoleSchema, {
  name: "roles/sql-admin",
  title: "SQL Admin",
  permissions: ["bb.plans.get", "bb.plans.update"],
});

const serviceAccountA = createProto(ServiceAccountSchema, {
  name: "serviceAccounts/[email protected]",
  email: "[email protected]",
  title: "Robot",
  state: State.ACTIVE,
});

const workloadIdentityA = createProto(WorkloadIdentitySchema, {
  name: "workloadIdentities/[email protected]",
  email: "[email protected]",
  title: "Deploy",
  state: State.ACTIVE,
});

const identityProviderA = createProto(IdentityProviderSchema, {
  name: "idps/google",
  title: "Google",
  domain: "example.com",
});

const accessGrantA = createProto(AccessGrantSchema, {
  name: "projects/a/accessGrants/ag1",
  status: AccessGrant_Status.ACTIVE,
});

const releaseA = createProto(ReleaseSchema, {
  name: "projects/a/releases/rel-a",
  state: State.ACTIVE,
});

const releaseB = createProto(ReleaseSchema, {
  name: "projects/a/releases/rel-b",
  state: State.ACTIVE,
});

const revisionA = createProto(RevisionSchema, {
  name: "instances/i1/databases/db1/revisions/1",
});

const revisionB = createProto(RevisionSchema, {
  name: "instances/i1/databases/db1/revisions/2",
});

const changelogA = createProto(ChangelogSchema, {
  name: "instances/i1/databases/db1/changelogs/1",
});

const changelogB = createProto(ChangelogSchema, {
  name: "instances/i1/databases/db1/changelogs/2",
  schema: "full",
});

const changelogCreateTime = createProto(TimestampSchema, {
  seconds: 1735689599n,
  nanos: 123456789,
});

const webhookA = createProto(WebhookSchema, {
  name: "projects/a/webhooks/hook-a",
  title: "Hook A",
  url: "https://example.com/hook-a",
});

const timestampSeconds = (seconds: number) => ({
  seconds: BigInt(seconds),
  nanos: 0,
});

beforeEach(() => {
  vi.clearAllMocks();
  // Tests here stub `location`; without this the stub leaks into every test
  // declared after it, with only the keys that test happened to supply. The
  // unstub is blanket, so re-install the localStorage mock it also removes.
  vi.unstubAllGlobals();
  vi.stubGlobal("localStorage", mocks.localStorage);
  localStorage.clear();
});

describe("useAppStore", () => {
  test("combines app state slices behind one bounded store", () => {
    const store = createAppStore();
    const state = store.getState();

    expect(state.loadCurrentUser).toBeTypeOf("function");
    expect(state.loadWorkspace).toBeTypeOf("function");
    expect(state.hasWorkspacePermission).toBeTypeOf("function");
    expect(state.fetchProject).toBeTypeOf("function");
    expect(state.fetchInstance).toBeTypeOf("function");
    expect(state.notify).toBeTypeOf("function");
    expect(state.recordRecentVisit).toBeTypeOf("function");
    expect(state.removeRecentVisit).toBeTypeOf("function");
  });

  test("keeps the signed-in identity when marking the session expired", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      currentUserName: user.name,
    });

    store.getState().setUnauthenticatedOccurred(true);

    expect(store.getState().unauthenticatedOccurred).toBe(true);
    expect(store.getState().currentUser).toBe(user);
    expect(store.getState().currentUserName).toBe(user.name);
    expect(store.getState().isLoggedIn()).toBe(true);
  });

  test("keeps the signed-in identity when current-user refresh has a transient failure", async () => {
    mocks.getCurrentUser.mockRejectedValue(new Error("network unavailable"));
    const store = createAppStore();
    store.setState({
      currentUser: user,
      currentUserName: user.name,
    });

    const result = await store.getState().fetchCurrentUser();

    expect(result).toBeUndefined();
    expect(store.getState().currentUser).toBe(user);
    expect(store.getState().currentUserName).toBe(user.name);
    expect(store.getState().isLoggedIn()).toBe(true);
  });

  // Mutations that answer with the updated user adopt it directly: the router
  // guard reads this state, and a refetch that failed would leave it stale
  // while fetchCurrentUser swallowed the error.
  test("adopts a user handed to setCurrentUser", () => {
    const store = createAppStore();
    const enabled = createProto(UserSchema, { ...user, mfaEnabled: true });

    store.getState().setCurrentUser(enabled);

    expect(store.getState().currentUser?.mfaEnabled).toBe(true);
    expect(store.getState().currentUserName).toBe(enabled.name);
    expect(store.getState().isLoggedIn()).toBe(true);
  });

  test("fetches the current user silently when requested", async () => {
    mocks.getCurrentUser.mockResolvedValue(user);
    const store = createAppStore();

    await store.getState().fetchCurrentUser(true);

    expect(
      mocks.getCurrentUser.mock.calls[0][1]?.contextValues.get(silentContextKey)
    ).toBe(true);
  });

  test("auto logout preserves the full current path for signin redirect", async () => {
    const fakeLocation = {
      pathname: "/sql-editor/projects/prod/instances/pg/databases/app",
      search: "?schema=public",
      hash: "#result",
      href: "",
    };
    vi.stubGlobal("location", fakeLocation);
    mocks.logout.mockResolvedValue({});
    const store = createAppStore();

    await store.getState().logout();

    expect(mocks.resolvePath).toHaveBeenCalledWith("auth.signin", {
      query: {
        redirect:
          "/sql-editor/projects/prod/instances/pg/databases/app?schema=public#result",
      },
    });
    expect(fakeLocation.href).toBe(
      "/auth?redirect=%2Fsql-editor%2Fprojects%2Fprod%2Finstances%2Fpg%2Fdatabases%2Fapp%3Fschema%3Dpublic%23result"
    );
  });

  test("login keeps an explicit redirect URL in SQL Editor mode", async () => {
    const redirectUrl =
      "/sql-editor/projects/prod/instances/pg/databases/app?schema=public#result";
    mocks.login.mockResolvedValue({ requireResetPassword: false });
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({ workspace: user.workspace });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    // `login()` loads the profile itself, so EDITOR mode comes from the server
    // rather than a seeded `appFeatures`.
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
      redirectUrl,
      silent: true,
    });

    const requestOptions = mocks.login.mock.calls[0]?.[1];
    expect(requestOptions?.contextValues.get(silentContextKey)).toBe(true);
    expect(mocks.navigateToPath).toHaveBeenCalledWith(redirectUrl, {
      replace: true,
    });
  });

  // Regression guard (customer report): signing in from the bare root left
  // `appFeatures` at its PIPELINE default, because a signed-out boot never
  // fetches the workspace profile and `login()` did not fetch it either. The
  // EDITOR branch below then failed and the user landed on the workspace
  // landing page instead of the SQL Editor. Note this test seeds no
  // `appFeatures` — the profile must come from the server during `login()`.
  test("login loads the workspace profile before choosing the next page", async () => {
    mocks.login.mockResolvedValue({ requireResetPassword: false });
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({ workspace: user.workspace });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(
      store.getState().appFeatures["bb.feature.database-change-mode"]
    ).toBe(DatabaseChangeMode.EDITOR);
    // `rootGuard` owns the "/" policy and turns this into the SQL Editor; see
    // the root-redirect tests in app/router/guard.test.ts. What `login()` owes
    // it is a loaded profile, asserted above.
    expect(mocks.navigateToPath).toHaveBeenCalledWith("/", { replace: true });
  });

  test("self-host first login with an IdP display name uses the unified workspace setup route", async () => {
    const firstLoginUser = createProto(UserSchema, {
      ...user,
      title: "Alice Doe",
    });
    mocks.login.mockResolvedValue({
      requireResetPassword: false,
      user: firstLoginUser,
    });
    mocks.getCurrentUser.mockResolvedValue(firstLoginUser);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: false,
    });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {}),
          },
        }),
      })
    );
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceAdmin")
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(mocks.navigateByName).toHaveBeenCalledWith("auth.setup", {
      query: { redirect: "/" },
    });
  });

  test("Cloud first login with an IdP display name uses the unified workspace setup route", async () => {
    const firstLoginUser = createProto(UserSchema, {
      ...user,
      title: "Alice Doe",
    });
    mocks.login.mockResolvedValue({
      requireResetPassword: false,
      user: firstLoginUser,
    });
    mocks.getCurrentUser.mockResolvedValue(firstLoginUser);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: true,
    });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {}),
          },
        }),
      })
    );
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceAdmin")
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(mocks.navigateByName).toHaveBeenCalledWith("auth.setup", {
      query: { redirect: "/" },
    });
    expect(
      localStorage.getItem("bb.workspace-setup.finished.workspaces/default")
    ).toBe("false");
  });

  test("invited self-host user leaves root navigation to the router on first login", async () => {
    const firstLoginUser = createProto(UserSchema, {
      ...user,
      title: "Bob Invited",
    });
    mocks.login.mockResolvedValue({
      requireResetPassword: false,
      user: firstLoginUser,
    });
    mocks.getCurrentUser.mockResolvedValue(firstLoginUser);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
      saas: false,
    });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(mocks.navigateToPath).toHaveBeenCalledWith("/", { replace: true });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  test("invited SaaS first login skips workspace setup and lets the router choose the destination", async () => {
    vi.stubGlobal("location", {
      search: "?workspace=default&email=alice%40example.com",
    });
    const firstLoginUser = createProto(UserSchema, {
      ...user,
      title: user.email,
    });
    mocks.login.mockResolvedValue({
      requireResetPassword: false,
      user: firstLoginUser,
    });
    mocks.getCurrentUser.mockResolvedValue(firstLoginUser);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
      saas: true,
    });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(mocks.navigateToPath).toHaveBeenCalledWith("/", {
      replace: true,
    });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  test("invited SaaS first login preserves an explicit redirect", async () => {
    vi.stubGlobal("location", {
      search:
        "?workspace=default&email=alice%40example.com&redirect=%2Fprojects%2Ffoo",
    });
    const firstLoginUser = createProto(UserSchema, {
      ...user,
      title: user.email,
    });
    mocks.login.mockResolvedValue({
      requireResetPassword: false,
      user: firstLoginUser,
    });
    mocks.getCurrentUser.mockResolvedValue(firstLoginUser);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
      saas: true,
    });
    mocks.getWorkspace.mockResolvedValue({ name: user.workspace });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    const store = createAppStore();

    await store.getState().login({
      request: { email: user.email, password: "secret" } as never,
    });

    expect(mocks.navigateToPath).toHaveBeenCalledWith("/projects/foo", {
      replace: true,
    });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  // Regression guard: `signup()` used to override the destination with the SQL
  // Editor whenever the mode read EDITOR, with no check for an explicit
  // redirect. That branch was dead (signup always boots signed out, so the mode
  // was never EDITOR) until the profile load made it live, which would have
  // silently dropped deep links.
  test("signup keeps an explicit redirect in an EDITOR workspace", async () => {
    vi.stubGlobal("location", { search: "?redirect=%2Fprojects%2Ffoo" });
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    // userCountInIam > 1 so `enableOnboarding()` is false and signup navigates.
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateToPath).toHaveBeenCalledWith("/projects/foo", {
      replace: true,
    });
  });

  test("self-host signup uses the unified workspace setup route", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: false,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceAdmin")
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateByName).toHaveBeenCalledWith("auth.setup", {
      replace: true,
    });
  });

  test("SaaS signup uses the unified workspace setup route", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: true,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceAdmin")
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateByName).toHaveBeenCalledWith("auth.setup", {
      replace: true,
    });
    expect(
      localStorage.getItem("bb.workspace-setup.finished.workspaces/default")
    ).toBe("false");
  });

  test("invited SaaS signup skips workspace setup and opens the workspace landing page", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
      saas: true,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateByName).toHaveBeenCalledWith("workspace.landing", {
      replace: true,
    });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  test("non-admin signup skips workspace setup even with one IAM user", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: true,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateByName).toHaveBeenCalledWith("workspace.landing", {
      replace: true,
    });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  test("signup skips workspace setup when the workspace policy cannot be loaded", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 1,
      saas: true,
    });
    mocks.getIamPolicy.mockRejectedValue(new Error("policy unavailable"));
    const store = createAppStore();
    store.setState({
      workspacePolicy: workspacePolicyForUser("roles/workspaceAdmin"),
    });

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(mocks.navigateByName).toHaveBeenCalledWith("workspace.landing", {
      replace: true,
    });
    expect(mocks.navigateByName).not.toHaveBeenCalledWith(
      "auth.setup",
      expect.anything()
    );
  });

  test("signup loads the workspace profile before opening the landing page", async () => {
    mocks.signup.mockResolvedValue({});
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: user.workspace,
      userCountInIam: 2,
    });
    mocks.getIamPolicy.mockResolvedValue(
      workspacePolicyForUser("roles/workspaceMember")
    );
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    await store.getState().signup({
      email: user.email,
      name: "Test",
      password: "secret",
    } as never);

    expect(
      store.getState().appFeatures["bb.feature.database-change-mode"]
    ).toBe(DatabaseChangeMode.EDITOR);
    expect(mocks.navigateByName).toHaveBeenCalledWith("workspace.landing", {
      replace: true,
    });
  });

  test("lists groups and populates the group cache", async () => {
    mocks.listGroups.mockResolvedValue({
      groups: [groupA, groupB],
      nextPageToken: "next",
    });
    const store = createAppStore();
    store.setState({
      currentUser: user,
      roles: [
        createProto(RoleSchema, {
          name: "roles/group-viewer",
          permissions: ["bb.groups.list"],
        }),
      ],
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/group-viewer",
            members: [`user:${user.email}`],
          }),
        ],
      }),
    });

    const result = await store.getState().listGroups({ pageSize: 50 });

    expect(result.groups).toEqual([groupA, groupB]);
    expect(result.nextPageToken).toBe("next");
    expect(store.getState().groupsByName[groupA.name]).toBe(groupA);
    expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
  });

  test("lists users and populates the user cache", async () => {
    mocks.listUsers.mockResolvedValue({
      users: [userA, userB],
      nextPageToken: "next-user",
    });
    const store = createAppStore();
    store.setState({
      currentUser: user,
      roles: [
        createProto(RoleSchema, {
          name: "roles/user-viewer",
          permissions: ["bb.users.list"],
        }),
      ],
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/user-viewer",
            members: [`user:${user.email}`],
          }),
        ],
      }),
    });

    const result = await store.getState().listUsers({
      pageSize: 50,
      filter: { query: "BO", state: State.DELETED },
    });

    expect(result.users).toEqual([userA, userB]);
    expect(result.nextPageToken).toBe("next-user");
    expect(store.getState().usersByName[userA.name]).toBe(userA);
    expect(store.getState().usersByName[userB.name]).toBe(userB);
    expect(mocks.listUsers).toHaveBeenCalledWith(
      expect.objectContaining({
        filter:
          '(name.contains("bo") || email.contains("bo")) && state == "DELETED"',
        showDeleted: true,
      })
    );
  });

  test("listUsers omits the project filter for unknown project sentinels", async () => {
    mocks.listUsers.mockResolvedValue({
      users: [userA],
      nextPageToken: "",
    });
    const store = createAppStore();
    store.setState({
      currentUser: user,
      roles: [
        createProto(RoleSchema, {
          name: "roles/user-viewer",
          permissions: ["bb.users.list"],
        }),
      ],
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/user-viewer",
            members: [`user:${user.email}`],
          }),
        ],
      }),
    });

    for (const project of [UNKNOWN_PROJECT_NAME, "projects/-"]) {
      await store.getState().listUsers({
        pageSize: 50,
        filter: { project, query: "BO" },
      });
    }

    expect(
      mocks.listUsers.mock.calls.map(([request]) => request.filter)
    ).toEqual([
      '(name.contains("bo") || email.contains("bo"))',
      '(name.contains("bo") || email.contains("bo"))',
    ]);
  });

  test("batchGetOrFetchUsers fetches missing users and returns unknown fallback", async () => {
    mocks.batchGetUsers.mockResolvedValue({ users: [userB] });
    const store = createAppStore();
    store.setState({ usersByName: { [userA.name]: userA } });

    const result = await store
      .getState()
      .batchGetOrFetchUsers([userA.name, "user:[email protected]"]);

    expect(mocks.batchGetUsers).toHaveBeenCalledWith(
      expect.objectContaining({ names: [userB.name] }),
      expect.anything()
    );
    expect(result.map((u) => u.name)).toEqual([userA.name, userB.name]);

    mocks.batchGetUsers.mockResolvedValueOnce({ users: [] });
    const missing = await store
      .getState()
      .batchGetOrFetchUsers(["users/[email protected]"]);

    expect(missing[0]).toMatchObject({
      name: "users/[email protected]",
      email: "[email protected]",
    });
  });

  test("updateEmail removes the old user cache key and stores the updated user", async () => {
    const updated = createProto(UserSchema, {
      ...userA,
      name: "users/[email protected]",
      email: "[email protected]",
    });
    mocks.updateEmail.mockResolvedValue(updated);
    const store = createAppStore();
    store.setState({ usersByName: { [userA.name]: userA } });

    const result = await store
      .getState()
      .updateEmail("[email protected]", "[email protected]");

    expect(result).toBe(updated);
    expect(store.getState().usersByName[userA.name]).toBeUndefined();
    expect(store.getState().usersByName[updated.name]).toBe(updated);
  });

  test("updateEmail refreshes currentUser when the signed-in user changes email", async () => {
    const updated = createProto(UserSchema, {
      ...user,
      name: "users/[email protected]",
      email: "[email protected]",
    });
    mocks.updateEmail.mockResolvedValue(updated);
    const store = createAppStore();
    store.setState({
      currentUser: user,
      usersByName: { [user.name]: user },
    });

    await store.getState().updateEmail(user.email, updated.email);

    expect(store.getState().currentUser).toBe(updated);
  });

  test("updateUser passes allowMissing through without requiring an existing user", async () => {
    mocks.updateUser.mockResolvedValue(userA);
    const store = createAppStore();

    const result = await store.getState().updateUser(
      createProto(UpdateUserRequestSchema, {
        user: userA,
        allowMissing: true,
      })
    );

    expect(result).toBe(userA);
    expect(mocks.getUser).not.toHaveBeenCalled();
    expect(mocks.updateUser.mock.calls[0][0]).toMatchObject({
      user: userA,
      allowMissing: true,
    });
    expect(store.getState().usersByName[userA.name]).toBe(userA);
  });

  test("updateUser refreshes currentUser when the signed-in user is updated", async () => {
    const updated = createProto(UserSchema, {
      ...user,
      title: "Alice Updated",
    });
    mocks.updateUser.mockResolvedValue(updated);
    const store = createAppStore();
    store.setState({
      currentUser: user,
      usersByName: { [user.name]: user },
    });

    await store.getState().updateUser(
      createProto(UpdateUserRequestSchema, {
        user: updated,
      })
    );

    expect(store.getState().currentUser).toBe(updated);
  });

  test("updateWorkspace refreshes the current workspace and list entry", async () => {
    const existing = createProto(WorkspaceSchema, {
      name: "workspaces/default",
      title: "Old",
      logo: "old-logo",
    });
    const updated = createProto(WorkspaceSchema, {
      name: "workspaces/default",
      title: "Old",
      logo: "new-logo",
    });
    mocks.updateWorkspace.mockResolvedValue(updated);
    const store = createAppStore();
    store.setState({ workspace: existing, workspaceList: [existing] });

    const result = await store.getState().updateWorkspace(updated, ["logo"]);

    expect(result).toBe(updated);
    expect(store.getState().workspace).toBe(updated);
    expect(store.getState().workspaceList[0]).toBe(updated);
  });

  test("updateWorkspace leaves workspace untouched when a different workspace is active", async () => {
    const active = createProto(WorkspaceSchema, {
      name: "workspaces/other",
      title: "Other",
    });
    const updated = createProto(WorkspaceSchema, {
      name: "workspaces/default",
      title: "Default",
      logo: "new-logo",
    });
    mocks.updateWorkspace.mockResolvedValue(updated);
    const store = createAppStore();
    store.setState({ workspace: active, workspaceList: [active] });

    await store.getState().updateWorkspace(updated, ["logo"]);

    expect(store.getState().workspace).toBe(active);
  });

  test("patchWorkspaceIamPolicy adds the member to the requested role bindings", async () => {
    const existing = createProto(IamPolicySchema, {
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceMember",
          members: ["user:[email protected]"],
        }),
      ],
    });
    const setPolicy = createProto(IamPolicySchema, {
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceMember",
          members: ["user:[email protected]", "user:[email protected]"],
        }),
        createProto(BindingSchema, {
          role: "roles/workspaceAdmin",
          members: ["user:[email protected]"],
        }),
      ],
    });
    mocks.setIamPolicy.mockResolvedValue(setPolicy);
    const store = createAppStore();
    store.setState({ workspacePolicy: existing });

    await store.getState().patchWorkspaceIamPolicy([
      {
        member: "user:[email protected]",
        roles: ["roles/workspaceMember", "roles/workspaceAdmin"],
      },
    ]);

    expect(mocks.setIamPolicy).toHaveBeenCalledTimes(1);
    const request = mocks.setIamPolicy.mock.calls[0][0] as {
      policy: { bindings: { role: string; members: string[] }[] };
    };
    // Existing member binding gains bob, and a new admin binding is appended.
    expect(
      request.policy.bindings.map(({ role, members }) => ({ role, members }))
    ).toEqual([
      {
        role: "roles/workspaceMember",
        members: ["user:[email protected]", "user:[email protected]"],
      },
      {
        role: "roles/workspaceAdmin",
        members: ["user:[email protected]"],
      },
    ]);
    expect(store.getState().workspacePolicy).toBe(setPolicy);
  });

  test("patchWorkspaceIamPolicy round-trips the etag it read", async () => {
    const existing = createProto(IamPolicySchema, {
      etag: "1756000000000",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceMember",
          members: ["user:[email protected]"],
        }),
      ],
    });
    mocks.setIamPolicy.mockResolvedValue(existing);
    const store = createAppStore();
    store.setState({ workspacePolicy: existing });

    await store
      .getState()
      .patchWorkspaceIamPolicy([
        { member: "user:[email protected]", roles: ["roles/workspaceMember"] },
      ]);

    // The server reads the etag from either field; sending both keeps an older
    // server, which only reads the request field, checking it too.
    const request = mocks.setIamPolicy.mock.calls[0][0] as {
      etag: string;
      policy: { etag: string };
    };
    expect(request.etag).toBe("1756000000000");
    expect(request.policy.etag).toBe("1756000000000");
  });

  test("patchWorkspaceIamPolicy refetches after a concurrent edit", async () => {
    const stale = createProto(IamPolicySchema, {
      etag: "1756000000000",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceMember",
          members: ["user:[email protected]"],
        }),
      ],
    });
    // What the other admin left behind: alice revoked, and a new etag.
    const current = createProto(IamPolicySchema, {
      etag: "1756000009999",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceAdmin",
          members: ["user:[email protected]"],
        }),
      ],
    });
    mocks.setIamPolicy.mockRejectedValue(
      new ConnectError("concurrent update", Code.Aborted)
    );
    mocks.getIamPolicy.mockResolvedValue(current);
    const store = createAppStore();
    store.setState({ workspacePolicy: stale });

    await expect(
      store
        .getState()
        .patchWorkspaceIamPolicy([
          { member: "user:[email protected]", roles: ["roles/workspaceMember"] },
        ])
    ).rejects.toThrow();

    // Without the refetch the store would keep the losing policy, and every
    // retry would replay the same stale etag.
    expect(store.getState().workspacePolicy).toBe(current);
  });

  test("updateProjectIamPolicy refetches after a concurrent edit", async () => {
    const stale = createProto(IamPolicySchema, {
      etag: "1756000000000",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/projectDeveloper",
          members: ["user:[email protected]"],
        }),
      ],
    });
    const current = createProto(IamPolicySchema, {
      etag: "1756000009999",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/projectOwner",
          members: ["user:[email protected]"],
        }),
      ],
    });
    mocks.setProjectIamPolicy.mockRejectedValue(
      new ConnectError("concurrent update", Code.Aborted)
    );
    mocks.getProjectIamPolicy.mockResolvedValue(current);
    const store = createAppStore();
    store.setState({ projectPoliciesByName: { [projectA.name]: stale } });

    await expect(
      store.getState().updateProjectIamPolicy(projectA.name, stale)
    ).rejects.toThrow();

    expect(mocks.setProjectIamPolicy.mock.calls[0][0]).toMatchObject({
      etag: "1756000000000",
    });
    expect(store.getState().projectPoliciesByName[projectA.name]).toBe(current);
  });

  test("updateProjectIamPolicy leaves the cached policy alone on other errors", async () => {
    const stale = createProto(IamPolicySchema, {
      etag: "1756000000000",
      bindings: [
        createProto(BindingSchema, {
          role: "roles/projectDeveloper",
          members: ["user:[email protected]"],
        }),
      ],
    });
    mocks.setProjectIamPolicy.mockRejectedValue(
      new ConnectError("at least one owner", Code.InvalidArgument)
    );
    const store = createAppStore();
    store.setState({ projectPoliciesByName: { [projectA.name]: stale } });

    await expect(
      store.getState().updateProjectIamPolicy(projectA.name, stale)
    ).rejects.toThrow();

    // A rejected write left the server's policy where it was, so the etag this
    // store holds is still good and refetching would be churn.
    expect(mocks.getProjectIamPolicy).not.toHaveBeenCalled();
    expect(store.getState().projectPoliciesByName[projectA.name]).toBe(stale);
  });

  test("workspaceUserMapToRoles inverts policy bindings to member -> roles", () => {
    const policy = createProto(IamPolicySchema, {
      bindings: [
        createProto(BindingSchema, {
          role: "roles/workspaceMember",
          members: ["user:[email protected]", "user:[email protected]"],
        }),
        createProto(BindingSchema, {
          role: "roles/workspaceAdmin",
          members: ["user:[email protected]"],
        }),
      ],
    });
    const store = createAppStore();
    store.setState({ workspacePolicy: policy });

    const map = store.getState().workspaceUserMapToRoles();
    expect(
      [...(map.get("users/[email protected]") ?? [])].sort((a, b) =>
        a.localeCompare(b)
      )
    ).toEqual(["roles/workspaceAdmin", "roles/workspaceMember"]);
    expect([...(map.get("users/[email protected]") ?? [])]).toEqual([
      "roles/workspaceMember",
    ]);
  });

  test("create archive and restore refresh the IAM user count", async () => {
    mocks.createUser.mockResolvedValue(userA);
    mocks.deleteUser.mockResolvedValue({});
    mocks.undeleteUser.mockResolvedValue(userA);
    mocks.getActuatorInfo
      .mockResolvedValueOnce(
        createProto(ActuatorInfoSchema, { userCountInIam: 7 })
      )
      .mockResolvedValueOnce(
        createProto(ActuatorInfoSchema, { userCountInIam: 6 })
      )
      .mockResolvedValueOnce(
        createProto(ActuatorInfoSchema, { userCountInIam: 7 })
      )
      .mockResolvedValueOnce(
        createProto(ActuatorInfoSchema, { userCountInIam: 0 })
      );
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, {
        userCountInIam: 2,
      }),
    });

    await store.getState().createUser(userA);
    expect(store.getState().serverInfo?.userCountInIam).toBe(7);

    await store.getState().archiveUser(userA.name);
    expect(store.getState().serverInfo?.userCountInIam).toBe(6);

    await store.getState().restoreUser(userA.name);
    expect(store.getState().serverInfo?.userCountInIam).toBe(7);

    await store.getState().archiveUser(userA.name);
    expect(store.getState().serverInfo?.userCountInIam).toBe(0);
  });

  test("lists, upserts, and deletes roles", async () => {
    mocks.listRoles.mockResolvedValue({ roles: [roleA] });
    mocks.updateRole.mockResolvedValue(roleB);
    mocks.deleteRole.mockResolvedValue({});
    const store = createAppStore();

    const roles = await store.getState().listRoles();
    expect(roles).toEqual([roleA]);
    expect(store.getState().getRoleByName(roleA.name)).toBe(roleA);

    const upserted = await store.getState().upsertRole(roleB);
    expect(upserted).toBe(roleB);
    expect(store.getState().roleList).toEqual([roleA, roleB]);
    expect(mocks.updateRole).toHaveBeenCalledWith(
      expect.objectContaining({
        role: roleB,
        updateMask: expect.objectContaining({
          paths: ["title", "description", "permissions"],
        }),
        allowMissing: true,
      })
    );

    await store.getState().deleteRole(roleA);
    expect(store.getState().roleList).toEqual([roleB]);
    expect(mocks.deleteRole).toHaveBeenCalledWith(
      expect.objectContaining({ name: roleA.name })
    );
  });

  test("lists roles silently when requested", async () => {
    mocks.listRoles.mockResolvedValue({ roles: [roleA] });
    const store = createAppStore();

    await store.getState().listRoles(true);

    expect(
      mocks.listRoles.mock.calls[0][1]?.contextValues.get(silentContextKey)
    ).toBe(true);
  });

  test("loads workspace permission roles into the role display cache", async () => {
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: "workspaces/default",
    });
    mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });
    mocks.listRoles.mockResolvedValue({ roles: [roleA, roleB] });
    mocks.getIamPolicy.mockResolvedValue(createProto(IamPolicySchema, {}));
    const store = createAppStore();

    await store.getState().loadWorkspacePermissionState();

    expect(store.getState().roles).toEqual([roleA, roleB]);
    expect(store.getState().roleList).toEqual([roleA, roleB]);
    expect(
      mocks.listRoles.mock.calls[0][1]?.contextValues.get(silentContextKey)
    ).toBe(true);
    expect(
      mocks.getIamPolicy.mock.calls[0][1]?.contextValues.get(silentContextKey)
    ).toBe(true);
  });

  test("fetches workspace IAM policy silently when requested", async () => {
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: "workspaces/default",
    });
    mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });
    mocks.getIamPolicy.mockResolvedValue(createProto(IamPolicySchema, {}));
    const store = createAppStore();
    store.setState({ currentUser: user });

    await store.getState().fetchWorkspaceIamPolicy(true);

    expect(
      mocks.getIamPolicy.mock.calls[0][1]?.contextValues.get(silentContextKey)
    ).toBe(true);
  });

  test("prefetches user members referenced by the workspace policy", async () => {
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: "workspaces/default",
    });
    mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });
    mocks.listRoles.mockResolvedValue({ roles: [roleA] });
    mocks.getIamPolicy.mockResolvedValue(
      createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: roleA.name,
            members: [`user:${userA.email}`],
          }),
        ],
      })
    );
    mocks.batchGetUsers.mockResolvedValue({ users: [userA] });
    const store = createAppStore();

    await store.getState().loadWorkspacePermissionState();

    expect(mocks.batchGetUsers).toHaveBeenCalledWith(
      expect.objectContaining({ names: [userA.name] }),
      expect.anything()
    );
    expect(store.getState().usersByName[userA.name]).toBe(userA);
  });

  test("lists releases and marks cached release deleted", async () => {
    mocks.listReleases.mockResolvedValue({
      releases: [releaseA, releaseB],
      nextPageToken: "next-release",
    });
    mocks.deleteRelease.mockResolvedValue({});
    const store = createAppStore();

    const result = await store
      .getState()
      .listReleasesByProject("projects/a", { pageSize: 20 }, true, "x");

    expect(result.releases).toEqual([releaseA, releaseB]);
    expect(result.nextPageToken).toBe("next-release");
    expect(store.getState().releasesByName[releaseA.name]).toBe(releaseA);
    expect(store.getState().getReleasesByProject("projects/a")).toEqual([
      releaseA,
      releaseB,
    ]);
    expect(mocks.listReleases).toHaveBeenCalledWith(
      expect.objectContaining({
        parent: "projects/a",
        pageSize: 20,
        showDeleted: true,
        filter: "x",
      })
    );

    await store.getState().deleteRelease(releaseA.name);

    expect(store.getState().releasesByName[releaseA.name].state).toBe(
      State.DELETED
    );
  });

  test("returns undefined for an unknown release", () => {
    const store = createAppStore();

    // getReleaseByName backs the useReleaseByName Zustand selector. Returning a
    // freshly-constructed sentinel on every call made the selector snapshot
    // change each render, triggering an infinite re-render loop on cache miss.
    // A stable undefined avoids that, matching the other cache-miss getters.
    expect(
      store.getState().getReleaseByName("projects/a/releases/miss")
    ).toBeUndefined();
  });

  test("reuses stable fallback resources on cache misses", () => {
    const store = createAppStore();

    // These getters are tempting to use inside Zustand selectors. Returning a
    // fresh proto on every cache miss makes the selector snapshot unstable in
    // Zustand v5 / React useSyncExternalStore and can render-loop.
    expect(store.getState().getProjectByName("projects/missing")).toBe(
      store.getState().getProjectByName("projects/missing")
    );
    expect(store.getState().getProjectByName("projects/-")).toBe(
      store.getState().getProjectByName("projects/-")
    );
    expect(
      store.getState().getDatabaseByName("instances/i/databases/miss")
    ).toBe(store.getState().getDatabaseByName("instances/i/databases/miss"));
    expect(store.getState().getInstanceByName("instances/missing")).toBe(
      store.getState().getInstanceByName("instances/missing")
    );
    expect(
      store.getState().getDBGroupByName("projects/p/databaseGroups/miss")
    ).toBe(store.getState().getDBGroupByName("projects/p/databaseGroups/miss"));
    expect(store.getState().getRolloutByName("projects/p/rollouts/miss")).toBe(
      store.getState().getRolloutByName("projects/p/rollouts/miss")
    );
    expect(store.getState().getEnvironmentByName("environments/missing")).toBe(
      store.getState().getEnvironmentByName("environments/missing")
    );
    expect(
      store.getState().getDatabaseCatalog("instances/i/databases/miss")
    ).toBe(store.getState().getDatabaseCatalog("instances/i/databases/miss"));
    expect(
      store.getState().getDatabaseMetadata("instances/i/databases/miss")
    ).toBe(store.getState().getDatabaseMetadata("instances/i/databases/miss"));
  });

  test("deduplicates release fetches and clears failed requests", async () => {
    mocks.getRelease.mockResolvedValueOnce(releaseA);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchRelease(releaseA.name),
      store.getState().fetchRelease(releaseA.name),
    ]);

    expect(first).toBe(releaseA);
    expect(second).toBe(releaseA);
    expect(mocks.getRelease).toHaveBeenCalledTimes(1);
    expect(store.getState().releaseRequests[releaseA.name]).toBeUndefined();

    const failedName = "projects/a/releases/fail";
    mocks.getRelease.mockRejectedValueOnce(new Error("failed"));
    await expect(store.getState().fetchRelease(failedName)).rejects.toThrow(
      "failed"
    );
    expect(store.getState().releaseRequests[failedName]).toBeUndefined();
  });

  test("paginates all revisions by database and caches results", async () => {
    mocks.listRevisions
      .mockResolvedValueOnce({
        revisions: [revisionA],
        nextPageToken: "next-revision",
      })
      .mockResolvedValueOnce({
        revisions: [revisionB],
        nextPageToken: "",
      });
    const store = createAppStore();

    const result = await store
      .getState()
      .listAllRevisionsByDatabase("instances/i1/databases/db1", {
        pageSize: 1,
      });

    expect(result).toEqual([revisionA, revisionB]);
    expect(mocks.listRevisions.mock.calls.map(([request]) => request)).toEqual([
      expect.objectContaining({
        parent: "instances/i1/databases/db1",
        pageSize: 1,
        pageToken: "",
      }),
      expect.objectContaining({
        parent: "instances/i1/databases/db1",
        pageSize: 1,
        pageToken: "next-revision",
      }),
    ]);
    expect(
      store.getState().getRevisionsByDatabase("instances/i1/databases/db1")
    ).toEqual([revisionA, revisionB]);
  });

  test("deleteRevision removes the cached revision", async () => {
    mocks.deleteRevision.mockResolvedValue({});
    const store = createAppStore();
    store.setState({ revisionsByName: { [revisionA.name]: revisionA } });

    await store.getState().deleteRevision(revisionA.name);

    expect(store.getState().revisionsByName[revisionA.name]).toBeUndefined();
  });

  test("caches changelog list by database and view preference", async () => {
    mocks.listChangelogs.mockResolvedValue({ changelogs: [changelogA] });
    const fullChangelog = createProto(ChangelogSchema, {
      ...changelogA,
      schema: "full",
    });
    const store = createAppStore();

    const changelogs = await store.getState().listChangelogs({
      parent: "instances/i1/databases/db1",
      pageSize: 20,
      view: ChangelogView.BASIC,
    });

    expect(changelogs.changelogs).toEqual([changelogA]);
    expect(
      store.getState().changelogListByDatabase("instances/i1/databases/db1")
    ).toEqual([changelogA]);
    expect(store.getState().getChangelogByName(changelogA.name)).toBe(
      changelogA
    );

    store.setState({
      changelogsByCacheKey: {
        ...store.getState().changelogsByCacheKey,
        [`${changelogA.name}|${ChangelogView.FULL}`]: fullChangelog,
      },
    });

    expect(store.getState().getChangelogByName(changelogA.name)).toBe(
      fullChangelog
    );
  });

  test("keeps changelog list cache isolated by request dimensions", async () => {
    mocks.listChangelogs
      .mockResolvedValueOnce({ changelogs: [changelogA] })
      .mockResolvedValueOnce({ changelogs: [changelogB] });
    const store = createAppStore();

    await store.getState().listChangelogs({
      parent: "instances/i1/databases/db1",
      pageSize: 20,
      view: ChangelogView.BASIC,
    });
    const full = await store
      .getState()
      .getOrFetchChangelogListOfDatabase(
        "instances/i1/databases/db1",
        20,
        ChangelogView.FULL
      );

    expect(full).toEqual([changelogB]);
    expect(mocks.listChangelogs).toHaveBeenCalledTimes(2);
    expect(
      store.getState().changelogListByDatabase("instances/i1/databases/db1")
    ).toEqual([changelogA]);

    mocks.listChangelogs.mockReset();
    mocks.listChangelogs
      .mockResolvedValueOnce({ changelogs: [changelogB] })
      .mockResolvedValueOnce({ changelogs: [changelogA, changelogB] });
    const filteredStore = createAppStore();

    await filteredStore.getState().listChangelogs({
      parent: "instances/i1/databases/db1",
      pageSize: 20,
      view: ChangelogView.BASIC,
      filter: 'status == "DONE"',
    });
    const unfiltered = await filteredStore
      .getState()
      .getOrFetchChangelogListOfDatabase("instances/i1/databases/db1", 20);

    expect(unfiltered).toEqual([changelogA, changelogB]);
    expect(mocks.listChangelogs).toHaveBeenCalledTimes(2);
    expect(
      filteredStore
        .getState()
        .changelogListByDatabase("instances/i1/databases/db1")
    ).toEqual([changelogA, changelogB]);
  });

  test("deduplicates changelog fetches and skips unknown changelog names", async () => {
    mocks.getChangelog.mockResolvedValue(changelogA);
    const store = createAppStore();

    const missing = await store
      .getState()
      .getOrFetchChangelogByName("instances/i1/databases/db1/changelogs/-1");
    expect(missing).toBeUndefined();

    const [first, second] = await Promise.all([
      store.getState().getOrFetchChangelogByName(changelogA.name),
      store.getState().getOrFetchChangelogByName(changelogA.name),
    ]);

    expect(first).toBe(changelogA);
    expect(second).toBe(changelogA);
    expect(mocks.getChangelog).toHaveBeenCalledTimes(1);
    expect(
      store.getState().changelogRequests[
        `${changelogA.name}|${ChangelogView.BASIC}`
      ]
    ).toBeUndefined();
  });

  test("fetches the latest prior changelog with a schema snapshot", async () => {
    const current = createProto(ChangelogSchema, {
      ...changelogA,
      createTime: changelogCreateTime,
    });
    mocks.getChangelog.mockResolvedValue(current);
    mocks.listChangelogs.mockResolvedValue({ changelogs: [changelogB] });
    const store = createAppStore();

    const previous = await store
      .getState()
      .fetchPreviousChangelog(current.name);

    expect(previous).toBe(changelogB);
    expect(mocks.getChangelog).toHaveBeenCalledWith(
      expect.objectContaining({
        name: current.name,
        view: ChangelogView.FULL,
      })
    );
    expect(mocks.listChangelogs).toHaveBeenCalledWith(
      expect.objectContaining({
        parent: "instances/i1/databases/db1",
        pageSize: 1,
        view: ChangelogView.FULL,
        filter:
          'has_schema_snapshot == true && create_time < "2024-12-31T23:59:59.123456789Z"',
      })
    );
  });

  test("project webhook operations call through and lookup by id", async () => {
    const projectWithWebhook = createProto(ProjectSchema, {
      ...projectA,
      webhooks: [webhookA],
    });
    mocks.addWebhook.mockResolvedValue(projectWithWebhook);
    mocks.updateWebhook.mockResolvedValue(projectWithWebhook);
    mocks.removeWebhook.mockResolvedValue(projectA);
    mocks.testWebhook.mockResolvedValue({ error: "no route" });
    const store = createAppStore();

    expect(
      store
        .getState()
        .getProjectWebhookFromProjectById(projectWithWebhook, "hook-a")
    ).toBe(webhookA);

    await expect(
      store.getState().createProjectWebhook(projectA.name, webhookA)
    ).resolves.toBe(projectWithWebhook);
    expect(store.getState().projectsByName[projectWithWebhook.name]).toBe(
      projectWithWebhook
    );

    await expect(
      store.getState().updateProjectWebhook(webhookA, ["title"])
    ).resolves.toBe(projectWithWebhook);
    expect(store.getState().projectsByName[projectWithWebhook.name]).toBe(
      projectWithWebhook
    );

    await expect(store.getState().deleteProjectWebhook(webhookA)).resolves.toBe(
      projectA
    );
    expect(store.getState().projectsByName[projectA.name]).toBe(projectA);

    await expect(
      store.getState().testProjectWebhook(projectWithWebhook, webhookA)
    ).resolves.toEqual({ error: "no route" });

    expect(mocks.addWebhook).toHaveBeenCalledWith(
      expect.objectContaining({ project: projectA.name, webhook: webhookA })
    );
    expect(mocks.updateWebhook).toHaveBeenCalledWith(
      expect.objectContaining({
        webhook: webhookA,
        updateMask: expect.objectContaining({ paths: ["title"] }),
      })
    );
    expect(mocks.removeWebhook).toHaveBeenCalledWith(
      expect.objectContaining({ webhook: webhookA })
    );
    expect(mocks.testWebhook).toHaveBeenCalledWith(
      expect.objectContaining({ project: projectA.name, webhook: webhookA })
    );
  });

  test("batchGetOrFetchGroups skips cached groups and preserves order", async () => {
    mocks.batchGetGroups.mockResolvedValue({ groups: [groupB] });
    const store = createAppStore();
    store.setState({ groupsByName: { [groupA.name]: groupA } });

    const result = await store
      .getState()
      .batchGetOrFetchGroups([groupA.name, groupB.name, groupA.name]);

    expect(mocks.batchGetGroups).toHaveBeenCalledTimes(1);
    expect(result).toEqual([groupA, groupB]);
    expect(store.getState().groupsByName[groupB.name]).toBe(groupB);
  });

  test("lists service accounts and writes them into cache", async () => {
    mocks.listServiceAccounts.mockResolvedValue({
      serviceAccounts: [serviceAccountA],
      nextPageToken: "next-sa",
    });
    const store = createAppStore();

    const result = await store.getState().listServiceAccounts({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
    });

    expect(result.serviceAccounts).toEqual([serviceAccountA]);
    expect(result.nextPageToken).toBe("next-sa");
    expect(store.getState().serviceAccountsByName[serviceAccountA.name]).toBe(
      serviceAccountA
    );
  });

  test("lists service accounts without caching when requested", async () => {
    mocks.listServiceAccounts.mockResolvedValue({
      serviceAccounts: [serviceAccountA],
      nextPageToken: "",
    });
    const store = createAppStore();

    await store.getState().listServiceAccounts({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
      skipCache: true,
    });

    expect(store.getState().serviceAccountsByName).not.toHaveProperty(
      serviceAccountA.name
    );
  });

  test("lists service accounts silently when requested", async () => {
    mocks.listServiceAccounts.mockResolvedValue({
      serviceAccounts: [],
      nextPageToken: "",
    });
    const store = createAppStore();

    await store.getState().listServiceAccounts({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
      silent: true,
    });

    expect(
      mocks.listServiceAccounts.mock.calls[0][1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
  });

  test("marks cached service account deleted after delete", async () => {
    mocks.deleteServiceAccount.mockResolvedValue({});
    const store = createAppStore();
    store.setState({
      serviceAccountsByName: { [serviceAccountA.name]: serviceAccountA },
    });

    await store.getState().deleteServiceAccount(serviceAccountA.name);

    expect(
      store.getState().serviceAccountsByName[serviceAccountA.name].state
    ).toBe(State.DELETED);
  });

  test("lists workload identities and writes them into cache", async () => {
    mocks.listWorkloadIdentities.mockResolvedValue({
      workloadIdentities: [workloadIdentityA],
      nextPageToken: "next-wi",
    });
    const store = createAppStore();

    const result = await store.getState().listWorkloadIdentities({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
    });

    expect(result.workloadIdentities).toEqual([workloadIdentityA]);
    expect(result.nextPageToken).toBe("next-wi");
    expect(
      store.getState().workloadIdentitiesByName[workloadIdentityA.name]
    ).toBe(workloadIdentityA);
  });

  test("lists workload identities without caching when requested", async () => {
    mocks.listWorkloadIdentities.mockResolvedValue({
      workloadIdentities: [workloadIdentityA],
      nextPageToken: "",
    });
    const store = createAppStore();

    await store.getState().listWorkloadIdentities({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
      skipCache: true,
    });

    expect(store.getState().workloadIdentitiesByName).not.toHaveProperty(
      workloadIdentityA.name
    );
  });

  test("lists workload identities silently when requested", async () => {
    mocks.listWorkloadIdentities.mockResolvedValue({
      workloadIdentities: [],
      nextPageToken: "",
    });
    const store = createAppStore();

    await store.getState().listWorkloadIdentities({
      parent: "workspaces/default",
      pageSize: 20,
      showDeleted: false,
      silent: true,
    });

    expect(
      mocks.listWorkloadIdentities.mock.calls[0][1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
  });

  test("lists identity providers and replaces the identity provider cache", async () => {
    mocks.listIdentityProviders.mockResolvedValue({
      identityProviders: [identityProviderA],
    });
    const store = createAppStore();
    store.setState({
      identityProvidersByName: {
        "idps/stale": createProto(IdentityProviderSchema, {
          name: "idps/stale",
        }),
      },
    });

    const providers = await store
      .getState()
      .listIdentityProviders("workspaces/default");

    expect(providers).toEqual([identityProviderA]);
    expect(store.getState().identityProviderList()).toEqual([
      identityProviderA,
    ]);
    expect(store.getState().identityProvidersByName).toEqual({
      [identityProviderA.name]: identityProviderA,
    });
  });

  test("updates identity provider with a field mask based on changed fields", async () => {
    mocks.getIdentityProvider.mockResolvedValue(identityProviderA);
    mocks.updateIdentityProvider.mockResolvedValue({
      ...identityProviderA,
      title: "Google Workspace",
    });
    const store = createAppStore();

    const updated = await store.getState().updateIdentityProvider({
      name: identityProviderA.name,
      title: "Google Workspace",
    });

    expect(updated.title).toBe("Google Workspace");
    expect(mocks.updateIdentityProvider).toHaveBeenCalledWith(
      expect.objectContaining({
        updateMask: expect.objectContaining({ paths: ["title"] }),
      })
    );
  });

  test("lists access grants and writes them into cache", async () => {
    mocks.listAccessGrants.mockResolvedValue({
      accessGrants: [accessGrantA],
      nextPageToken: "next-ag",
    });
    const store = createAppStore();

    const result = await store.getState().listAccessGrants({
      parent: "projects/a",
      pageSize: 20,
      filter: { status: ["ACTIVE"] },
    });

    expect(result.accessGrants).toEqual([accessGrantA]);
    expect(result.nextPageToken).toBe("next-ag");
    expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(
      accessGrantA
    );
  });

  test("revokeAccessGrant writes returned grant into cache", async () => {
    const revoked = {
      ...accessGrantA,
      status: AccessGrant_Status.REVOKED,
    };
    mocks.revokeAccessGrant.mockResolvedValue(revoked);
    const store = createAppStore();

    const result = await store.getState().revokeAccessGrant(accessGrantA.name);

    expect(result).toBe(revoked);
    expect(store.getState().accessGrantsByName[accessGrantA.name]).toBe(
      revoked
    );
  });

  test("updateIssueComment writes the server response so the edited marker shows in place (BYT-9746)", async () => {
    const issueName = "projects/a/issues/1";
    const commentName = `${issueName}/issueComments/100`;
    const original = createProto(IssueCommentSchema, {
      name: commentName,
      comment: "before",
      createTime: timestampSeconds(1000),
      updateTime: timestampSeconds(1000),
    });
    // The server bumps updated_at on edit and returns the refreshed comment.
    const serverUpdated = createProto(IssueCommentSchema, {
      name: commentName,
      comment: "after",
      createTime: timestampSeconds(1000),
      updateTime: timestampSeconds(2000),
    });
    mocks.updateIssueComment.mockResolvedValue(serverUpdated);
    const store = createAppStore();
    store.setState({ issueCommentsByIssue: { [issueName]: [original] } });

    await store.getState().updateIssueComment({
      issueCommentName: commentName,
      comment: "after",
    });

    const cached = store.getState().getIssueComments(issueName)[0];
    expect(cached.comment).toBe("after");
    // Regression guard: the optimistic patch used to discard the RPC response
    // and keep the stale updateTime, so IssueCommentActivity's
    // `isEdited = createTime !== updateTime` stayed false until a full refetch.
    expect(cached.updateTime).toEqual(serverUpdated.updateTime);
    expect(cached.updateTime).not.toEqual(cached.createTime);
  });

  test("deduplicates project fetches and caches the result", async () => {
    mocks.getProject.mockResolvedValue(projectA);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchProject(projectA.name),
      store.getState().fetchProject(projectA.name),
    ]);

    expect(first).toBe(projectA);
    expect(second).toBe(projectA);
    expect(mocks.getProject).toHaveBeenCalledTimes(1);
    expect(store.getState().projectsByName[projectA.name]).toBe(projectA);
  });

  test("falls back to individual project fetches when batch fetch fails", async () => {
    // BatchGetProjects is all-or-nothing, so one stale name fails the batch.
    mocks.batchGetProjects.mockRejectedValue(
      new ConnectError("project not found", Code.NotFound)
    );
    mocks.getProject.mockImplementation(({ name }: { name: string }) => {
      return Promise.resolve(name === projectA.name ? projectA : projectB);
    });
    const store = createAppStore();

    const projects = await store
      .getState()
      .batchFetchProjects([projectA.name, projectB.name], true);

    expect(projects).toEqual([projectA, projectB]);
    expect(mocks.batchGetProjects).toHaveBeenCalledTimes(1);
    expect(mocks.getProject).toHaveBeenCalledTimes(2);
    expect(
      mocks.batchGetProjects.mock.calls[0]?.[1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
    expect(
      mocks.getProject.mock.calls.every(
        (call) => call[1]?.contextValues.get(silentContextKey) === true
      )
    ).toBe(true);
  });

  test("keeps default project only when searchProjects opts in", async () => {
    const defaultProject = createProto(ProjectSchema, {
      name: "projects/default",
      title: "Default project",
      state: State.ACTIVE,
    });
    mocks.searchProjects.mockResolvedValue({
      projects: [defaultProject, projectA],
      nextPageToken: "",
    });
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, {
        defaultProject: defaultProject.name,
      }),
    });

    await expect(
      store.getState().searchProjects({
        pageSize: 50,
        pageToken: "",
      })
    ).resolves.toMatchObject({
      projects: [projectA],
    });
    await expect(
      store.getState().searchProjects({
        pageSize: 50,
        pageToken: "",
        excludeDefault: false,
      })
    ).resolves.toMatchObject({
      projects: [defaultProject, projectA],
    });
  });

  test("writes created projects into the entity cache", async () => {
    mocks.createProject.mockResolvedValue(projectA);
    const store = createAppStore();

    const created = await store.getState().createProject("A", "a");

    expect(created).toBe(projectA);
    expect(store.getState().projectsByName[projectA.name]).toBe(projectA);
  });

  test.each([
    { reportedBy: "the caller, on request", report: { byCaller: true } },
    { reportedBy: "the shared error toast, by default", report: undefined },
  ])(
    "leaves a failed write to be reported by $reportedBy",
    async ({ report }) => {
      const policy = createProto(IamPolicySchema, {});
      const workspace = createProto(WorkspaceSchema, {
        name: "workspaces/default",
      });
      mocks.updateUser.mockResolvedValue(userA);
      mocks.updateWorkspace.mockResolvedValue(workspace);
      mocks.createProject.mockResolvedValue(projectA);
      mocks.getIamPolicy.mockResolvedValue(policy);
      mocks.setProjectIamPolicy.mockResolvedValue(policy);
      mocks.setIamPolicy.mockResolvedValue(policy);
      const store = createAppStore();
      const state = store.getState();

      await state.updateUser(
        createProto(UpdateUserRequestSchema, {
          user: userA,
          allowMissing: true,
        }),
        report
      );
      await state.updateWorkspace(workspace, ["title"], report);
      await state.createProject("A", "a", report);
      await state.updateProjectIamPolicy(projectA.name, policy, report);
      await state.fetchWorkspaceIamPolicy(false, report);
      await state.patchWorkspaceIamPolicy(
        [{ member: "user:[email protected]", roles: ["roles/workspaceMember"] }],
        report
      );

      const writes = {
        updateUser: mocks.updateUser,
        updateWorkspace: mocks.updateWorkspace,
        createProject: mocks.createProject,
        setProjectIamPolicy: mocks.setProjectIamPolicy,
        getWorkspaceIamPolicy: mocks.getIamPolicy,
        setWorkspaceIamPolicy: mocks.setIamPolicy,
      };
      expect(
        Object.fromEntries(
          Object.entries(writes).map(([name, write]) => [
            name,
            write.mock.calls[0][1]?.contextValues.get(
              skipErrorNotificationContextKey
            ) ?? false,
          ])
        )
      ).toEqual(
        Object.fromEntries(Object.keys(writes).map((name) => [name, !!report]))
      );
    }
  );

  test("checks workspace permission through user, groups, and roles", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      roles: [
        createProto(RoleSchema, {
          name: "roles/admin",
          permissions: ["bb.projects.create"],
        }),
        createProto(RoleSchema, {
          name: "roles/viewer",
          permissions: ["bb.projects.get"],
        }),
      ],
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/admin",
            members: ["group:dba"],
          }),
          createProto(BindingSchema, {
            role: "roles/viewer",
            members: ["user:allUsers"],
          }),
        ],
      }),
    });

    expect(store.getState().hasWorkspacePermission("bb.projects.create")).toBe(
      true
    );
    expect(store.getState().hasWorkspacePermission("bb.settings.set")).toBe(
      false
    );
  });

  test("ignores expired IAM bindings when checking workspace permission", () => {
    const store = createAppStore();
    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
    store.setState({
      currentUser: user,
      roles: [
        createProto(RoleSchema, {
          name: "roles/admin",
          permissions: ["bb.projects.create"],
        }),
      ],
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/admin",
            members: ["group:dba"],
            condition: createProto(ExprSchema, {
              expression: `request.time < timestamp("${yesterday}")`,
            }),
          }),
        ],
      }),
    });

    expect(store.getState().hasWorkspacePermission("bb.projects.create")).toBe(
      false
    );
  });

  test("derives app features from the workspace profile setting", async () => {
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "workspaceProfile",
            value: createProto(WorkspaceProfileSettingSchema, {
              databaseChangeMode: DatabaseChangeMode.EDITOR,
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    await store.getState().loadWorkspaceProfile();

    expect(store.getState().appFeatures["bb.feature.hide-quick-start"]).toBe(
      true
    );
  });

  test("uses pipeline app feature defaults before profile overrides", () => {
    const store = createAppStore();

    expect(
      store.getState().appFeatures["bb.feature.database-change-mode"]
    ).toBe(DatabaseChangeMode.PIPELINE);
    expect(store.getState().appFeatures["bb.feature.hide-quick-start"]).toBe(
      false
    );
    expect(store.getState().appFeatures["bb.feature.hide-trial"]).toBe(false);
  });

  test("enables the workspace setup guide for the sole workspace admin", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 1 }),
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/workspaceAdmin",
            members: [user.name],
          }),
        ],
      }),
    });
    expect(store.getState().workspaceSetupGuideEnabled()).toBe(true);
  });

  test("keeps the workspace setup guide disabled until IAM loads", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 1 }),
      workspacePolicy: undefined,
    });
    expect(store.getState().workspaceSetupGuideEnabled()).toBe(false);
  });

  test("disables the workspace setup guide for a sole non-admin", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 1 }),
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/workspaceMember",
            members: [user.name],
          }),
        ],
      }),
    });
    expect(store.getState().workspaceSetupGuideEnabled()).toBe(false);
  });

  test("allows the original admin to finish an explicit team guide", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 2 }),
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/workspaceAdmin",
            members: [user.name],
          }),
        ],
      }),
    });
    expect(store.getState().workspaceSetupGuideEnabled()).toBe(false);
    expect(store.getState().workspaceSetupGuideEnabled(true)).toBe(true);
  });

  test("does not allow the multi-member exception for a non-admin", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 2 }),
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/workspaceMember",
            members: [user.name, "users/[email protected]"],
          }),
        ],
      }),
    });

    expect(store.getState().workspaceSetupGuideEnabled(true)).toBe(false);
  });

  test("disables the workspace setup guide when quick start is hidden", () => {
    const store = createAppStore();
    store.setState({
      currentUser: user,
      appFeatures: {
        ...store.getState().appFeatures,
        "bb.feature.hide-quick-start": true,
      },
      serverInfo: createProto(ActuatorInfoSchema, { userCountInIam: 1 }),
      workspacePolicy: createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/workspaceAdmin",
            members: [user.name],
          }),
        ],
      }),
    });
    expect(store.getState().workspaceSetupGuideEnabled()).toBe(false);
  });

  test("derives actuator state for React consumers", () => {
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, {
        workspace: "workspaces/default",
        version: "3.10.2",
        externalUrl: "",
        saas: true,
        activatedInstanceCount: 2,
        totalInstanceCount: 3,
        userCountInIam: 7,
      }),
    });

    expect(store.getState().isSaaSMode()).toBe(true);
    expect(store.getState().workspaceResourceName()).toBe("workspaces/default");
    expect(store.getState().needConfigureExternalUrl()).toBe(true);
    expect(store.getState().changelogURL()).toBe(
      "https://docs.bytebase.com/changelog/bytebase-3-10-2/"
    );
    expect(store.getState().activatedInstanceCount()).toBe(2);
    expect(store.getState().totalInstanceCount()).toBe(3);
    expect(store.getState().userCountInIam()).toBe(7);
  });

  test("loads authentication info without fetching actuator info", async () => {
    const info = createProto(AuthenticationInfoSchema, {
      workspace: "workspaces/pre-login",
    });
    mocks.getAuthenticationInfo.mockResolvedValue(info);
    const store = createAppStore();

    await store.getState().loadAuthenticationInfo();

    expect(mocks.getAuthenticationInfo).toHaveBeenCalledWith({
      workspace: "",
    });
    expect(mocks.getActuatorInfo).not.toHaveBeenCalled();
    expect(store.getState().authenticationInfo).toBe(info);
    expect(store.getState().isSaaSMode()).toBe(false);
    expect(store.getState().workspaceResourceName()).toBe(
      "workspaces/pre-login"
    );
  });

  test("derives subscription limits and feature state", () => {
    const store = createAppStore();
    store.setState({
      subscription: createProto(SubscriptionSchema, {
        plan: PlanType.ENTERPRISE,
        seats: -1,
        instances: -1,
        activeInstances: -1,
        expiresTime: timestampSeconds(
          Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30
        ),
      }),
    });

    expect(store.getState().currentPlan()).toBe(PlanType.ENTERPRISE);
    expect(store.getState().isFreePlan()).toBe(false);
    expect(store.getState().isExpired()).toBe(false);
    expect(store.getState().showTrial()).toBe(false);
    expect(store.getState().instanceCountLimit()).toBe(Number.MAX_VALUE);
    expect(store.getState().userCountLimit()).toBe(Number.MAX_VALUE);
    expect(store.getState().instanceLicenseCount()).toBe(Number.MAX_VALUE);
    expect(store.getState().hasUnifiedInstanceLicense()).toBe(true);
    expect(store.getState().hasFeature(PlanFeature.FEATURE_DATA_MASKING)).toBe(
      true
    );
    expect(
      store.getState().hasInstanceFeature(
        PlanFeature.FEATURE_DATA_MASKING,
        createProto(InstanceSchema, {
          name: "instances/prod",
          activation: false,
        })
      )
    ).toBe(true);
    expect(
      store.getState().instanceMissingLicense(
        PlanFeature.FEATURE_DATA_MASKING,
        createProto(InstanceSchema, {
          name: "instances/prod",
          activation: false,
        })
      )
    ).toBe(false);

    store.setState({
      subscription: createProto(SubscriptionSchema, {
        plan: PlanType.ENTERPRISE,
        instances: 50,
        activeInstances: 20,
        expiresTime: timestampSeconds(
          Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 30
        ),
      }),
    });
    expect(store.getState().hasUnifiedInstanceLicense()).toBe(false);
    expect(
      store.getState().hasInstanceFeature(
        PlanFeature.FEATURE_DATA_MASKING,
        createProto(InstanceSchema, {
          name: "instances/prod",
          activation: false,
        })
      )
    ).toBe(false);
    expect(
      store.getState().instanceMissingLicense(
        PlanFeature.FEATURE_DATA_MASKING,
        createProto(InstanceSchema, {
          name: "instances/prod",
          activation: false,
        })
      )
    ).toBe(true);
  });

  test("treats expired subscriptions as feature unavailable", () => {
    const store = createAppStore();
    store.setState({
      subscription: createProto(SubscriptionSchema, {
        plan: PlanType.ENTERPRISE,
        expiresTime: timestampSeconds(
          Math.floor(Date.now() / 1000) - 60 * 60 * 24
        ),
      }),
    });

    expect(store.getState().isExpired()).toBe(true);
    expect(store.getState().hasFeature(PlanFeature.FEATURE_DATA_MASKING)).toBe(
      false
    );
  });

  test("refreshes subscription state after external mutations", async () => {
    mocks.getSubscription.mockResolvedValue(
      createProto(SubscriptionSchema, {
        plan: PlanType.TEAM,
        seats: 12,
      })
    );
    const store = createAppStore();
    store.setState({
      subscription: createProto(SubscriptionSchema, {
        plan: PlanType.FREE,
        seats: 0,
      }),
    });

    const subscription = await store.getState().refreshSubscription();

    expect(subscription?.plan).toBe(PlanType.TEAM);
    expect(store.getState().currentPlan()).toBe(PlanType.TEAM);
    expect(store.getState().userCountLimit()).toBe(12);
  });

  test("starts a trial and applies the returned subscription", async () => {
    const trial = createProto(SubscriptionSchema, {
      plan: PlanType.ENTERPRISE,
      trialing: true,
    });
    mocks.startTrial.mockResolvedValue(trial);
    const store = createAppStore();

    const subscription = await store.getState().startTrial();

    expect(mocks.startTrial).toHaveBeenCalledOnce();
    expect(subscription).toBe(trial);
    expect(store.getState().subscription).toBe(trial);
  });

  test("offers trial activation only to free SaaS workspaces in any mode", () => {
    vi.stubEnv("MODE", "release-aws");
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: true }),
      subscription: undefined,
    });
    expect(store.getState().canStartTrial()).toBe(false);

    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: true }),
      subscription: createProto(SubscriptionSchema, { plan: PlanType.FREE }),
    });

    expect(store.getState().canStartTrial()).toBe(true);

    store.setState({
      subscription: createProto(SubscriptionSchema, {
        plan: PlanType.ENTERPRISE,
        trialing: true,
      }),
    });
    expect(store.getState().canStartTrial()).toBe(false);

    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: false }),
      subscription: createProto(SubscriptionSchema, { plan: PlanType.FREE }),
    });
    expect(store.getState().canStartTrial()).toBe(false);

    vi.stubEnv("MODE", "development");
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: true }),
    });
    expect(store.getState().canStartTrial()).toBe(true);
  });

  test("loads environment settings into React state", async () => {
    mocks.getSetting.mockResolvedValue(
      createProto(SettingSchema, {
        value: createProto(SettingValueSchema, {
          value: {
            case: "environment",
            value: createProto(EnvironmentSettingSchema, {
              environments: [
                createProto(EnvironmentSetting_EnvironmentSchema, {
                  id: "dev",
                  title: "Development",
                  color: hexToColor("#00aa00"),
                }),
                createProto(EnvironmentSetting_EnvironmentSchema, {
                  id: "prod",
                  title: "Production",
                  tags: { protected: "protected" },
                }),
              ],
            }),
          },
        }),
      })
    );
    const store = createAppStore();

    const environments = await store.getState().loadEnvironmentList();

    expect(environments.map((env) => env.name)).toEqual([
      "environments/dev",
      "environments/prod",
    ]);
    expect(store.getState().environmentList[1]).toMatchObject({
      id: "prod",
      order: 1,
      tags: { protected: "protected" },
    });
    expect(store.getState().environmentList[0].color).toBe("#00aa00");
  });

  test("refreshes environment settings after cache warm-up", async () => {
    mocks.getSetting
      .mockResolvedValueOnce(
        createProto(SettingSchema, {
          value: createProto(SettingValueSchema, {
            value: {
              case: "environment",
              value: createProto(EnvironmentSettingSchema, {
                environments: [
                  createProto(EnvironmentSetting_EnvironmentSchema, {
                    id: "dev",
                    title: "Development",
                  }),
                ],
              }),
            },
          }),
        })
      )
      .mockResolvedValueOnce(
        createProto(SettingSchema, {
          value: createProto(SettingValueSchema, {
            value: {
              case: "environment",
              value: createProto(EnvironmentSettingSchema, {
                environments: [
                  createProto(EnvironmentSetting_EnvironmentSchema, {
                    id: "prod",
                    title: "Production",
                  }),
                ],
              }),
            },
          }),
        })
      );
    const store = createAppStore();

    await store.getState().loadEnvironmentList();
    await store.getState().loadEnvironmentList();
    expect(mocks.getSetting).toHaveBeenCalledTimes(1);

    const environments = await store.getState().refreshEnvironmentList();

    expect(mocks.getSetting).toHaveBeenCalledTimes(2);
    expect(environments.map((env) => env.name)).toEqual(["environments/prod"]);
  });

  test("loads project IAM policy and checks project permissions", async () => {
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: "workspaces/default",
    });
    mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });
    mocks.listRoles.mockResolvedValue({
      roles: [
        createProto(RoleSchema, {
          name: "roles/projectDeveloper",
          permissions: ["bb.projects.update"],
        }),
      ],
    });
    mocks.getIamPolicy.mockResolvedValue(createProto(IamPolicySchema, {}));
    mocks.getProjectIamPolicy.mockResolvedValue(
      createProto(IamPolicySchema, {
        bindings: [
          createProto(BindingSchema, {
            role: "roles/projectDeveloper",
            members: ["user:[email protected]"],
          }),
        ],
      })
    );
    const store = createAppStore();

    await store.getState().loadProjectIamPolicy(projectA.name);

    expect(mocks.getProjectIamPolicy).toHaveBeenCalledTimes(1);
    expect(
      mocks.getProjectIamPolicy.mock.calls[0][1]?.contextValues?.get(
        silentContextKey
      ) ?? false
    ).toBe(false);
    expect(
      store.getState().hasProjectPermission(projectA, "bb.projects.update")
    ).toBe(true);
    expect(
      store.getState().hasProjectPermission(projectA, "bb.projects.delete")
    ).toBe(false);
  });

  test("loads project IAM policy silently when requested", async () => {
    mocks.getCurrentUser.mockResolvedValue(user);
    mocks.getActuatorInfo.mockResolvedValue({
      workspace: "workspaces/default",
    });
    mocks.getWorkspace.mockResolvedValue({ name: "workspaces/default" });
    mocks.listRoles.mockResolvedValue({ roles: [] });
    mocks.getIamPolicy.mockResolvedValue(createProto(IamPolicySchema, {}));
    mocks.getProjectIamPolicy.mockResolvedValue(
      createProto(IamPolicySchema, {})
    );
    const store = createAppStore();

    await store.getState().loadProjectIamPolicy(projectA.name, true);

    expect(
      mocks.getProjectIamPolicy.mock.calls[0][1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
  });

  test("caches instances by resource name", async () => {
    const instance = createProto(InstanceSchema, {
      name: "instances/prod",
      title: "Prod",
    });
    mocks.getInstance.mockResolvedValue(instance);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchInstance(instance.name),
      store.getState().fetchInstance(instance.name),
    ]);

    expect(first).toBe(instance);
    expect(second).toBe(instance);
    expect(mocks.getInstance).toHaveBeenCalledTimes(1);
    expect(store.getState().instancesByName[instance.name]).toBe(instance);
  });

  test("deduplicates database fetches and caches the result", async () => {
    const dbName = "instances/i1/databases/db1";
    const database = createProto(DatabaseSchema$, { name: dbName });
    mocks.getDatabase.mockResolvedValueOnce(database);
    const store = createAppStore();

    const [first, second, third] = await Promise.all([
      store.getState().fetchDatabase(dbName),
      store.getState().fetchDatabase(dbName),
      store.getState().fetchDatabase(dbName),
    ]);

    expect(first).toEqual(database);
    expect(second).toEqual(database);
    expect(third).toEqual(database);
    expect(mocks.getDatabase).toHaveBeenCalledTimes(1);
    expect(store.getState().databasesByName[dbName]).toEqual(database);
  });

  test("keeps database and project batch enrichment silent", async () => {
    const dbName = "instances/i1/databases/db1";
    const database = createProto(DatabaseSchema$, {
      name: dbName,
      project: projectA.name,
    });
    mocks.batchGetDatabases.mockResolvedValue({ databases: [database] });
    mocks.batchGetProjects.mockResolvedValue({ projects: [projectA] });
    const store = createAppStore();

    await store.getState().batchGetOrFetchDatabases([dbName], true);

    expect(
      mocks.batchGetDatabases.mock.calls[0]?.[1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
    expect(
      mocks.batchGetProjects.mock.calls[0]?.[1]?.contextValues.get(
        silentContextKey
      )
    ).toBe(true);
  });

  test("fetchDatabases populates databasesByName from the list response", async () => {
    const dbA = createProto(DatabaseSchema$, {
      name: "instances/i1/databases/db1",
    });
    const dbB = createProto(DatabaseSchema$, {
      name: "instances/i1/databases/db2",
    });
    mocks.listDatabases.mockResolvedValue({
      databases: [dbA, dbB],
      nextPageToken: "next",
    });
    const store = createAppStore();

    const result = await store.getState().fetchDatabases({
      parent: "projects/a",
      pageSize: 50,
      filter: 'project == "projects/a"',
    });

    expect(result.databases).toEqual([dbA, dbB]);
    expect(result.nextPageToken).toBe("next");
    expect(store.getState().databasesByName[dbA.name]).toEqual(dbA);
    expect(store.getState().databasesByName[dbB.name]).toEqual(dbB);
    expect(mocks.listDatabases).toHaveBeenCalledTimes(1);
  });

  test("deduplicates db group fetches and caches the result", async () => {
    const name = "projects/p1/databaseGroups/g1";
    const group = createProto(DatabaseGroupSchema, { name });
    mocks.getDatabaseGroup.mockResolvedValueOnce(group);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchDBGroup(name),
      store.getState().fetchDBGroup(name),
    ]);

    expect(first).toEqual(group);
    expect(second).toEqual(group);
    expect(mocks.getDatabaseGroup).toHaveBeenCalledTimes(1);
  });

  test("deduplicates sheet fetches and caches the result", async () => {
    const name = "projects/p1/sheets/s1";
    const sheet = createProto(SheetSchema, {
      name,
      content: new Uint8Array(),
    });
    mocks.getSheet.mockResolvedValueOnce(sheet);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchSheet(name),
      store.getState().fetchSheet(name),
    ]);

    expect(first).toEqual(sheet);
    expect(second).toEqual(sheet);
    expect(mocks.getSheet).toHaveBeenCalledTimes(1);
  });

  test("deduplicates instance role fetches per instance", async () => {
    const instance = "instances/i1";
    const roles = [
      createProto(InstanceRoleSchema, { name: `${instance}/roles/admin` }),
    ];
    mocks.listInstanceRoles.mockResolvedValueOnce({ roles });
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store.getState().fetchInstanceRoles(instance),
      store.getState().fetchInstanceRoles(instance),
    ]);

    expect(first).toEqual(roles);
    expect(second).toEqual(roles);
    expect(mocks.listInstanceRoles).toHaveBeenCalledTimes(1);
  });

  test("notify() routes to the React toast manager", async () => {
    const { toastManager } = await import("@/lib/toast");
    const addSpy = vi.spyOn(toastManager, "add");
    const store = createAppStore();

    store.getState().notify({
      module: "bytebase",
      style: "SUCCESS",
      title: "Saved",
    });

    expect(addSpy).toHaveBeenCalledTimes(1);
    expect(addSpy.mock.calls[0][0]).toMatchObject({
      title: "Saved",
      type: "success",
    });
    addSpy.mockRestore();
  });

  test("keeps user-scoped preferences in localStorage", () => {
    const store = createAppStore();
    store.setState({ currentUser: user });

    store.getState().setRecentProject(projectA.name);
    store.getState().setRecentProject(projectB.name);
    store.getState().recordRecentVisit("/projects/a?tab=1");
    store.getState().recordRecentVisit("/projects/a?tab=2");
    store.getState().removeRecentVisit("/missing");
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.dismissed",
      newState: true,
    });
    store.getState().resumeWorkspaceSetupGuide();

    expect(
      JSON.parse(
        localStorage.getItem(storageKeyRecentProjects("", user.email))!
      )
    ).toEqual([projectB.name, projectA.name]);
    expect(
      JSON.parse(localStorage.getItem(storageKeyRecentVisit("", user.email))!)
    ).toEqual(["/projects/a?tab=2"]);
    expect(
      JSON.parse(
        localStorage.getItem(
          storageKeyIntroState("workspaces/default", user.email)
        )!
      )
    ).toEqual({ "workspace-setup-guide.dismissed": false });
  });

  test("resumes the setup guide without clearing progress", () => {
    const store = createAppStore();
    store.setState({ currentUser: user });

    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.dismissed",
      newState: true,
    });
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.database-explored",
      newState: true,
    });
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.statement-run",
      newState: true,
    });
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.product-model-seen",
      newState: true,
    });
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.completed.query-data",
      newState: true,
    });
    store.getState().saveIntroStateByKey({
      key: "workspace-setup-guide.started.query-data",
      newState: true,
    });
    store
      .getState()
      .saveIntroStateByKey({ key: "unrelated.intro", newState: true });

    store.getState().resumeWorkspaceSetupGuide();

    expect(
      store.getState().getIntroStateByKey("workspace-setup-guide.dismissed")
    ).toBe(false);
    expect(
      store
        .getState()
        .getIntroStateByKey("workspace-setup-guide.database-explored")
    ).toBe(true);
    expect(
      store.getState().getIntroStateByKey("workspace-setup-guide.statement-run")
    ).toBe(true);
    expect(
      store
        .getState()
        .getIntroStateByKey("workspace-setup-guide.product-model-seen")
    ).toBe(true);
    expect(
      store
        .getState()
        .getIntroStateByKey("workspace-setup-guide.completed.query-data")
    ).toBe(false);
    expect(
      store
        .getState()
        .getIntroStateByKey("workspace-setup-guide.started.query-data")
    ).toBe(true);
    expect(store.getState().getIntroStateByKey("unrelated.intro")).toBe(true);
  });

  test("scopes recent projects by workspace in SaaS mode", () => {
    const store = createAppStore();
    // SaaS mode scopes cache keys by workspace.
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: true }),
    });
    store.setState({ currentUser: { ...user, workspace: "workspaces/a" } });
    store.getState().setRecentProject(projectA.name);
    store.getState().recordRecentVisit("/projects/a");

    // Same user, different workspace (e.g. after a SaaS workspace switch).
    store.setState({ currentUser: { ...user, workspace: "workspaces/b" } });
    store.getState().setRecentProject(projectB.name);
    store.getState().recordRecentVisit("/projects/b");

    expect(
      JSON.parse(
        localStorage.getItem(
          storageKeyRecentProjects("workspaces/a", user.email)
        )!
      )
    ).toEqual([projectA.name]);
    expect(
      JSON.parse(
        localStorage.getItem(
          storageKeyRecentProjects("workspaces/b", user.email)
        )!
      )
    ).toEqual([projectB.name]);
    // Recent-visit is isolated per workspace too.
    expect(
      JSON.parse(
        localStorage.getItem(storageKeyRecentVisit("workspaces/a", user.email))!
      )
    ).toEqual(["/projects/a"]);
    expect(
      JSON.parse(
        localStorage.getItem(storageKeyRecentVisit("workspaces/b", user.email))!
      )
    ).toEqual(["/projects/b"]);
  });

  test("scopes recent projects from server workspace before user workspace hydrates", () => {
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, {
        saas: true,
        workspace: "workspaces/from-server",
      }),
    });
    store.setState({ currentUser: { ...user, workspace: "" } });

    store.getState().setRecentProject(projectA.name);

    expect(
      JSON.parse(
        localStorage.getItem(
          storageKeyRecentProjects("workspaces/from-server", user.email)
        )!
      )
    ).toEqual([projectA.name]);
    expect(
      localStorage.getItem(storageKeyRecentProjects("", user.email))
    ).toBeNull();
  });

  test("scopes intro state by workspace in SaaS mode", () => {
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, { saas: true }),
    });
    store.setState({ currentUser: { ...user, workspace: "workspaces/a" } });
    store.getState().saveIntroStateByKey({ key: "some.intro", newState: true });

    store.setState({ currentUser: { ...user, workspace: "workspaces/b" } });
    expect(store.getState().getIntroStateByKey("some.intro")).toBe(false);
    store
      .getState()
      .saveIntroStateByKey({ key: "another.intro", newState: true });

    expect(
      JSON.parse(
        localStorage.getItem(storageKeyIntroState("workspaces/a", user.email))!
      )
    ).toEqual({ "some.intro": true });
    expect(
      JSON.parse(
        localStorage.getItem(storageKeyIntroState("workspaces/b", user.email))!
      )
    ).toEqual({ "another.intro": true });
  });

  test("scopes intro state by workspace in self-host mode", () => {
    const store = createAppStore();
    store.setState({
      serverInfo: createProto(ActuatorInfoSchema, {
        saas: false,
      }),
    });
    store.setState({ currentUser: { ...user, workspace: "workspaces/a" } });
    localStorage.setItem(
      storageKeyIntroState("", user.email),
      JSON.stringify({ "stale.intro": true })
    );
    store.getState().saveIntroStateByKey({ key: "some.intro", newState: true });

    store.setState({ currentUser: { ...user, workspace: "workspaces/b" } });
    expect(store.getState().getIntroStateByKey("some.intro")).toBe(false);
    expect(store.getState().getIntroStateByKey("stale.intro")).toBe(false);
    store
      .getState()
      .saveIntroStateByKey({ key: "another.intro", newState: true });

    expect(
      JSON.parse(
        localStorage.getItem(storageKeyIntroState("workspaces/a", user.email))!
      )
    ).toEqual({ "some.intro": true });
    expect(
      JSON.parse(
        localStorage.getItem(storageKeyIntroState("workspaces/b", user.email))!
      )
    ).toEqual({ "another.intro": true });
  });

  test("caches database metadata and reuses inflight request", async () => {
    const {
      DatabaseMetadataSchema,
      SchemaMetadataSchema,
      TableMetadataSchema,
    } = await import("@/types/proto-es/v1/database_service_pb");
    const metadata = createProto(DatabaseMetadataSchema, {
      name: "instances/i1/databases/db1/metadata",
      schemas: [
        createProto(SchemaMetadataSchema, {
          name: "public",
          tables: [createProto(TableMetadataSchema, { name: "users" })],
        }),
      ],
    });
    mocks.getDatabaseMetadata.mockResolvedValue(metadata);
    const store = createAppStore();

    const [first, second] = await Promise.all([
      store
        .getState()
        .getOrFetchDatabaseMetadata({ database: "instances/i1/databases/db1" }),
      store
        .getState()
        .getOrFetchDatabaseMetadata({ database: "instances/i1/databases/db1" }),
    ]);

    expect(first).toBe(metadata);
    expect(second).toBe(metadata);
    // Concurrent calls dedupe through `metadataRequests`.
    expect(mocks.getDatabaseMetadata).toHaveBeenCalledTimes(1);

    // Sync derived getters resolve through the cached metadata.
    expect(
      store.getState().getTableMetadata({
        database: "instances/i1/databases/db1",
        schema: "public",
        table: "users",
      }).name
    ).toBe("users");
    // Unknown table falls back to an empty TableMetadata placeholder.
    expect(
      store.getState().getTableMetadata({
        database: "instances/i1/databases/db1",
        schema: "public",
        table: "missing",
      }).name
    ).toBe("");
  });

  test("keeps metadata cache isolated by filter and limit", async () => {
    const { DatabaseMetadataSchema, SchemaMetadataSchema } = await import(
      "@/types/proto-es/v1/database_service_pb"
    );
    const fullMetadata = createProto(DatabaseMetadataSchema, {
      name: "instances/i1/databases/db1/metadata",
      schemas: [createProto(SchemaMetadataSchema, { name: "public" })],
    });
    const filteredMetadata = createProto(DatabaseMetadataSchema, {
      name: "instances/i1/databases/db1/metadata",
      schemas: [createProto(SchemaMetadataSchema, { name: "filtered" })],
    });
    mocks.getDatabaseMetadata
      .mockResolvedValueOnce(fullMetadata)
      .mockResolvedValueOnce(filteredMetadata);
    const store = createAppStore();

    await store
      .getState()
      .getOrFetchDatabaseMetadata({ database: "instances/i1/databases/db1" });
    await store.getState().getOrFetchDatabaseMetadata({
      database: "instances/i1/databases/db1",
      filter: `schema == "filtered"`,
    });

    expect(mocks.getDatabaseMetadata).toHaveBeenCalledTimes(2);
  });

  test("keeps project-instance metadata requests and caches isolated", async () => {
    const { DatabaseMetadataSchema } = await import(
      "@/types/proto-es/v1/database_service_pb"
    );
    const databaseA = "projects/a/instances/shared/databases/db";
    const databaseB = "projects/b/instances/shared/databases/db";
    mocks.getDatabaseMetadata.mockImplementation(async ({ name }) =>
      createProto(DatabaseMetadataSchema, { name })
    );
    const store = createAppStore();

    await Promise.all([
      store.getState().getOrFetchDatabaseMetadata({ database: databaseA }),
      store.getState().getOrFetchDatabaseMetadata({ database: databaseB }),
    ]);

    expect(
      mocks.getDatabaseMetadata.mock.calls.map(([request]) => request.name)
    ).toEqual([`${databaseA}/metadata`, `${databaseB}/metadata`]);
    expect(store.getState().getCachedDatabaseMetadata(databaseA)?.name).toBe(
      `${databaseA}/metadata`
    );
    expect(store.getState().getCachedDatabaseMetadata(databaseB)?.name).toBe(
      `${databaseB}/metadata`
    );

    store.getState().removeDatabaseMetadataCache(databaseA);

    expect(
      store.getState().getCachedDatabaseMetadata(databaseA)
    ).toBeUndefined();
    expect(store.getState().getCachedDatabaseMetadata(databaseB)?.name).toBe(
      `${databaseB}/metadata`
    );
  });

  test("keeps project-instance catalog requests and caches isolated", async () => {
    const { DatabaseCatalogSchema } = await import(
      "@/types/proto-es/v1/database_catalog_service_pb"
    );
    const databaseA = "projects/a/instances/shared/databases/db";
    const databaseB = "projects/b/instances/shared/databases/db";
    mocks.getDatabaseCatalog.mockImplementation(async ({ name }) =>
      createProto(DatabaseCatalogSchema, { name })
    );
    const store = createAppStore();

    await Promise.all([
      store.getState().getOrFetchDatabaseCatalog({ database: databaseA }),
      store.getState().getOrFetchDatabaseCatalog({ database: databaseB }),
    ]);

    expect(
      mocks.getDatabaseCatalog.mock.calls.map(([request]) => request.name)
    ).toEqual([`${databaseA}/catalog`, `${databaseB}/catalog`]);
    expect(store.getState().getDatabaseCatalog(databaseA).name).toBe(
      `${databaseA}/catalog`
    );
    expect(store.getState().getDatabaseCatalog(databaseB).name).toBe(
      `${databaseB}/catalog`
    );
  });

  test("loads project-instance metadata when updating its catalog", async () => {
    const { DatabaseCatalogSchema } = await import(
      "@/types/proto-es/v1/database_catalog_service_pb"
    );
    const { DatabaseMetadataSchema } = await import(
      "@/types/proto-es/v1/database_service_pb"
    );
    const database = "projects/a/instances/shared/databases/db";
    const catalog = createProto(DatabaseCatalogSchema, {
      name: `${database}/catalog`,
    });
    mocks.getDatabaseMetadata.mockResolvedValue(
      createProto(DatabaseMetadataSchema, { name: `${database}/metadata` })
    );
    mocks.updateDatabaseCatalog.mockResolvedValue(catalog);
    const store = createAppStore();

    await store.getState().updateDatabaseCatalog(catalog);

    expect(mocks.getDatabaseMetadata).toHaveBeenCalledWith(
      expect.objectContaining({ name: `${database}/metadata` }),
      expect.anything()
    );
    expect(mocks.updateDatabaseCatalog).toHaveBeenCalledWith(
      expect.objectContaining({
        catalog: expect.objectContaining({ name: `${database}/catalog` }),
      })
    );
  });

  describe("getDBGroupByName / getOrFetchDBGroupByName cache semantics", () => {
    test("getDBGroupByName returns unknownDatabaseGroup when absent", () => {
      const store = createAppStore();
      const group = store
        .getState()
        .getDBGroupByName("projects/p/databaseGroups/x");
      expect(isValidDatabaseGroupName(group.name)).toBe(false);
    });

    test("getDBGroupByName with FULL view misses a BASIC-only cache entry", () => {
      const store = createAppStore();
      const name = "projects/p/databaseGroups/g";
      store.setState({
        dbGroupsByName: {
          [name]: createProto(DatabaseGroupSchema, { name, title: "g" }),
        },
        dbGroupViewByName: { [name]: DatabaseGroupView.BASIC },
      });
      expect(store.getState().getDBGroupByName(name).name).toBe(name);
      const full = store
        .getState()
        .getDBGroupByName(name, DatabaseGroupView.FULL);
      expect(isValidDatabaseGroupName(full.name)).toBe(false);
    });

    test("getOrFetchDBGroupByName returns cached entry without a request", async () => {
      const store = createAppStore();
      const name = "projects/p/databaseGroups/g";
      store.setState({
        dbGroupsByName: {
          [name]: createProto(DatabaseGroupSchema, { name, title: "g" }),
        },
        dbGroupViewByName: { [name]: DatabaseGroupView.BASIC },
      });
      const group = await store.getState().getOrFetchDBGroupByName(name);
      expect(group.name).toBe(name);
    });
  });
});