Skip to content

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

18.1 KB
Raw Blame
import { act } from "react";
import { Code, ConnectError } from "@connectrpc/connect";
import { createRoot } from "react-dom/client";
import { beforeEach, describe, expect, test, vi } from "vitest";

(
  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
).IS_REACT_ACT_ENVIRONMENT = true;

const mocks = vi.hoisted(() => ({
  useUnsavedChangesGuard: vi.fn(),
  onDismiss: vi.fn(),
  onCreated: vi.fn(),
  prepareSampleProjectInstance: vi.fn(),
  captureMetric: vi.fn(),
  pushNotification: vi.fn(),
  openAgent: vi.fn(),
  isSaaSMode: false,
  sampleAvailable: true,
  sampleInstances: [] as { instance: string }[],
  totalInstanceCount: 0,
  instanceCountLimit: 10,
  activatedInstanceCount: 0,
  providerProps: undefined as Record<string, unknown> | undefined,
  instanceFormContext: {
    basicInfo: { engine: 0 },
    state: { isRequesting: false },
    setState: vi.fn(),
    valueChanged: false,
  },
}));

let CreateInstanceView: typeof import("./CreateInstanceView").CreateInstanceView;

vi.mock("react-i18next", () => ({
  initReactI18next: { type: "3rdParty", init: () => {} },
  useTranslation: () => ({
    t: (key: string, values?: { total?: number }) => {
      const translation =
        ({
        "instance.use-sample-instance":
          "Use sample instance (Available for 7 days)",
        "instance.use-sample-instance-self-host": "Use sample instance",
        "instance.preparing-sample-instance":
          "Preparing Sample Project Instance…",
        "instance.prepare-sample-instance-failed":
          "Failed to prepare Sample Project Instance.",
        "instance.sample-project-instance-description":
          "Use a Sample Project Instance to explore Bytebase with a ready-to-use database for 7 days.",
        "instance.sample-project-instance-description-self-host":
          "Use a Sample Project Instance to explore Bytebase with a ready-to-use database.",
        "instance.sample-project-instance-title":
          "Try a Sample Project Instance",
        "subscription.usage.instance-count.title": "Instance quota reached",
        "subscription.usage.instance-count.runoutof":
          "You have reached the limit of {{total}} instances.",
        })[key] ?? key;
      return translation.replace("{{total}}", String(values?.total ?? ""));
    },
  }),
}));

vi.mock("@/hooks/useUnsavedChangesGuard", () => ({
  useUnsavedChangesGuard: mocks.useUnsavedChangesGuard,
}));

vi.mock("@/app/analytics/provider", () => ({
  behaviorAnalytics: { captureMetric: mocks.captureMetric },
}));

vi.mock("@/stores/app", () => ({
  useAppStore: Object.assign(
    <T,>(selector: (state: Record<string, unknown>) => T) =>
      selector({
        isSaaSMode: () => mocks.isSaaSMode,
        serverInfo: {
          sample: {
            available: mocks.sampleAvailable,
            instances: mocks.sampleInstances,
          },
        },
        totalInstanceCount: () => mocks.totalInstanceCount,
        prepareSampleProjectInstance: mocks.prepareSampleProjectInstance,
      }),
    {
      getState: () => ({
        instanceCountLimit: () => mocks.instanceCountLimit,
        activatedInstanceCount: () => mocks.activatedInstanceCount,
      }),
    }
  ),
}));

vi.mock("@/stores", () => ({
  pushNotification: mocks.pushNotification,
}));

vi.mock("@/modules/agent/store/agent", () => ({
  useAgentStore: {
    getState: () => ({ open: mocks.openAgent }),
  },
}));

vi.mock("@/modules/agent/logic/instanceConnectionHelp", () => ({
  openAgentWithPrompt: vi.fn(),
}));

vi.mock("@/components/instance", () => ({
  InfoPanel: ({ children }: { children: React.ReactNode }) => (
    <div>{children}</div>
  ),
  InfoPanelContent: () => <div />,
  InstanceFormBody: ({ onAskAgent }: { onAskAgent?: () => void }) => (
    <div data-testid="instance-form-body">
      <button type="button" onClick={() => onAskAgent?.()}>
        instance.ask-agent
      </button>
    </div>
  ),
  InstanceFormButtons: ({ className }: { className?: string }) => (
    <div>
      <button
        type="button"
        data-testid="instance-form-buttons"
        className={className}
        disabled={mocks.instanceFormContext.state.isRequesting}
      >
        Create
      </button>
    </div>
  ),
  InstanceFormProvider: ({
    children,
    onDismiss,
    ...props
  }: {
    children: React.ReactNode;
    onDismiss?: () => void;
    parent?: string;
    project?: unknown;
  }) => (
    <div
      ref={() => {
        mocks.providerProps = props;
      }}
    >
        <button type="button" data-testid="dismiss" onClick={onDismiss}>
          dismiss
        </button>
        {children}
      </div>
  ),
  useInstanceFormContext: () => mocks.instanceFormContext,
}));

beforeEach(async () => {
  vi.clearAllMocks();
  mocks.isSaaSMode = false;
  mocks.sampleAvailable = true;
  mocks.sampleInstances = [];
  mocks.totalInstanceCount = 0;
  mocks.instanceCountLimit = 10;
  mocks.activatedInstanceCount = 0;
  mocks.prepareSampleProjectInstance.mockResolvedValue({
    name: "projects/demo/instances/sample",
  });
  mocks.providerProps = undefined;
  mocks.instanceFormContext.state.isRequesting = false;
  mocks.instanceFormContext.setState.mockImplementation(
    (
      updater: (state: { isRequesting: boolean }) => {
        isRequesting: boolean;
      }
    ) => {
      mocks.instanceFormContext.state = updater(
        mocks.instanceFormContext.state
      );
    }
  );
  mocks.instanceFormContext.valueChanged = false;
  globalThis.ResizeObserver = class ResizeObserver {
    observe() {}
    unobserve() {}
    disconnect() {}
  } as typeof ResizeObserver;
  ({ CreateInstanceView } = await import("./CreateInstanceView"));
});

describe("CreateInstanceView", () => {
  test("opens the page-detected Agent landing from the create-instance form", async () => {
    const container = document.createElement("div");
    const root = createRoot(container);

    await act(async () => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const askAgentButton = Array.from(
      container.querySelectorAll("button")
    ).find((button) => button.textContent?.includes("instance.ask-agent"));
    expect(askAgentButton).toBeDefined();

    await act(async () => {
      askAgentButton?.click();
    });

    expect(mocks.openAgent).toHaveBeenCalledOnce();

    await act(async () => {
      root.unmount();
    });
  });

  test("keeps the scroll container flush with the page edge", () => {
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const page = container.firstElementChild;
    expect(page).not.toHaveClass("px-4");
    expect(page).not.toHaveClass("sm:px-6");

    const bodyPadding = container.querySelector(
      "[data-testid='instance-form-body']"
    )?.parentElement;
    expect(bodyPadding).toHaveClass("px-4");
    expect(bodyPadding).toHaveClass("sm:px-6");

    const buttons = container.querySelector(
      "[data-testid='instance-form-buttons']"
    );
    expect(buttons).not.toHaveClass("px-4");
    expect(buttons).not.toHaveClass("sm:px-6");

    act(() => {
      root.unmount();
    });
  });

  test("guards navigation when the create form has unsaved changes", () => {
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(mocks.useUnsavedChangesGuard).toHaveBeenLastCalledWith(false);

    mocks.instanceFormContext.valueChanged = true;
    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(mocks.useUnsavedChangesGuard).toHaveBeenLastCalledWith(true);

    mocks.instanceFormContext.state.isRequesting = true;
    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(mocks.useUnsavedChangesGuard).toHaveBeenLastCalledWith(false);

    act(() => {
      root.unmount();
    });
  });

  test("uses the provided dismissal callback", () => {
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const dismiss = container.querySelector(
      "[data-testid='dismiss']"
    ) as HTMLButtonElement;
    act(() => {
      dismiss.click();
    });

    expect(mocks.onDismiss).toHaveBeenCalledOnce();

    act(() => {
      root.unmount();
    });
  });

  test("forwards project ownership to the form provider", () => {
    const container = document.createElement("div");
    const root = createRoot(container);
    const project = { name: "projects/demo" };

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          project={project as never}
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(mocks.providerProps).toEqual({
      parent: "projects/demo",
      project,
    });

    act(() => {
      root.unmount();
    });
  });

  test("dismisses SaaS sample creation when the instance quota is reached", () => {
    mocks.isSaaSMode = true;
    mocks.instanceCountLimit = 1;
    mocks.activatedInstanceCount = 1;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(mocks.pushNotification).toHaveBeenCalledWith({
      module: "bytebase",
      style: "CRITICAL",
      title: "Instance quota reached",
      description: "You have reached the limit of 1 instances.",
    });
    expect(mocks.onDismiss).toHaveBeenCalledOnce();

    act(() => {
      root.unmount();
    });
  });

  test("prepares the sample instance and follows the existing created flow", async () => {
    mocks.isSaaSMode = true;
    const instance = { name: "projects/demo/instances/sample" };
    mocks.prepareSampleProjectInstance.mockResolvedValue(instance);
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const button = [...container.querySelectorAll("button")].find((element) =>
      element.textContent?.includes("Use sample instance")
    ) as HTMLButtonElement;
    await act(async () => {
      button.click();
    });

    expect(mocks.prepareSampleProjectInstance).toHaveBeenCalledWith(
      "projects/demo"
    );
    expect(mocks.captureMetric).toHaveBeenCalledWith({
      event: "sample instance requested",
      properties: { source: "instance_creation" },
    });
    expect(mocks.captureMetric.mock.invocationCallOrder[0]).toBeLessThan(
      mocks.prepareSampleProjectInstance.mock.invocationCallOrder[0]
    );
    expect(mocks.onCreated).toHaveBeenCalledWith(instance);

    act(() => {
      root.unmount();
    });
  });

  test("hides sample instance creation when the target is unavailable", () => {
    mocks.isSaaSMode = true;
    mocks.sampleAvailable = false;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).not.toContain("Use sample instance");

    act(() => {
      root.unmount();
    });
  });

  test("hides sample instance creation when a sample was already provisioned", () => {
    mocks.isSaaSMode = true;
    mocks.sampleInstances = [{ instance: "instances/sample" }];
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).not.toContain("Use sample instance");

    act(() => {
      root.unmount();
    });
  });

  test("hides sample instance creation when the workspace has an instance", () => {
    mocks.isSaaSMode = true;
    mocks.totalInstanceCount = 1;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).not.toContain("Use sample instance");

    act(() => {
      root.unmount();
    });
  });

  test("disables the sample action while preparation is running", async () => {
    mocks.isSaaSMode = true;
    let resolvePreparation: (instance: { name: string }) => void;
    mocks.prepareSampleProjectInstance.mockReturnValue(
      new Promise((resolve) => {
        resolvePreparation = resolve;
      })
    );
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const button = [...container.querySelectorAll("button")].find((element) =>
      element.textContent?.includes("Use sample instance")
    ) as HTMLButtonElement;
    act(() => {
      button.click();
    });

    expect(button).toBeDisabled();
    expect(button).toHaveTextContent("Preparing Sample Project Instance…");
    expect(
      container.querySelector("[data-testid='instance-form-buttons']")
    ).toBeDisabled();

    await act(async () => {
      resolvePreparation!({ name: "projects/demo/instances/sample" });
    });

    act(() => {
      root.unmount();
    });
  });

  test("disables the sample action while regular creation is running", () => {
    mocks.isSaaSMode = true;
    mocks.instanceFormContext.state.isRequesting = true;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const button = [...container.querySelectorAll("button")].find((element) =>
      element.textContent?.includes("Use sample instance")
    ) as HTMLButtonElement;
    expect(button).toBeDisabled();

    act(() => {
      root.unmount();
    });
  });

  test("shows localized feedback when sample preparation fails", async () => {
    mocks.isSaaSMode = true;
    mocks.prepareSampleProjectInstance.mockRejectedValue(
      new ConnectError(
        "The sample instance cannot be provisioned. Try again later.",
        Code.Internal
      )
    );
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    const button = [...container.querySelectorAll("button")].find((element) =>
      element.textContent?.includes("Use sample instance")
    ) as HTMLButtonElement;
    await act(async () => {
      button.click();
    });

    expect(mocks.pushNotification).toHaveBeenCalledTimes(1);
    expect(mocks.pushNotification).toHaveBeenCalledWith({
      module: "bytebase",
      style: "CRITICAL",
      title: "Failed to prepare Sample Project Instance.",
      description:
        "[internal] The sample instance cannot be provisioned. Try again later.",
    });
    expect(mocks.captureMetric).toHaveBeenCalledWith({
      event: "sample instance requested",
      properties: { source: "instance_creation" },
    });

    act(() => {
      root.unmount();
    });
  });

  test("shows permanent sample creation for a self-hosted project", () => {
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).toContain("Use sample instance");
    expect(container.textContent).toContain("ready-to-use database.");
    expect(container.textContent).not.toContain("7 days");

    act(() => {
      root.unmount();
    });
  });

  test("keeps seven-day sample copy for SaaS", () => {
    mocks.isSaaSMode = true;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          parent="projects/demo"
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).toContain(
      "Use sample instance (Available for 7 days)"
    );
    expect(container.textContent).toContain("ready-to-use database for 7 days.");

    act(() => {
      root.unmount();
    });
  });

  test("keeps sample creation out of workspace-owned instance creation", () => {
    mocks.isSaaSMode = true;
    const container = document.createElement("div");
    const root = createRoot(container);

    act(() => {
      root.render(
        <CreateInstanceView
          onDismiss={mocks.onDismiss}
          onCreated={mocks.onCreated}
        />
      );
    });

    expect(container.textContent).not.toContain("Use sample instance");

    act(() => {
      root.unmount();
    });
  });
});