Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

8.8 KB
Raw Blame
import type { TestProps, TestValue } from "../test-support/reactTree";
import type { ReactElement } from "react";
import {
  DEFAULT_SERVER_SETTINGS,
  EnvironmentId,
  type ImageGenerationSettings,
  type ImageProviderStatus,
  type UnifiedSettings,
} from "@akeru/contracts";
import { beforeEach, describe, expect, it, vi } from "vite-plus/test";

import { visitElements } from "../test-support/reactTree";
import { reactHookHarness as hooks } from "../../test/reactHookHarness";

const atoms = vi.hoisted(() => ({
  testImageProvider: Symbol("testImageProvider"),
  logoutSubscriptionAuth: Symbol("logoutSubscriptionAuth"),
}));

const commands = vi.hoisted(() => ({
  test: vi.fn(),
  logout: vi.fn(),
}));

const query = vi.hoisted(() => ({
  lastAtom: null as { imageProviders: { environmentId: EnvironmentId; input: {} } } | null,
  providers: null as ReadonlyArray<ImageProviderStatus> | null,
  error: null as string | null,
  isPending: false,
  refresh: vi.fn(),
}));

const settingsState = vi.hoisted(() => ({
  imageGeneration: null as ImageGenerationSettings | null,
  updateSettings: vi.fn(),
}));

const navigation = vi.hoisted(() => ({ openSettings: vi.fn() }));

const confirm = vi.hoisted(() => ({ request: vi.fn() }));

vi.mock("react", async (importOriginal) => {
  const actual = await importOriginal<typeof import("react")>();
  const { reactHookHarness } = await import("../../test/reactHookHarness");

  return {
    ...actual,
    useCallback: reactHookHarness.useCallback,
    useMemo: reactHookHarness.useMemo,
    useRef: reactHookHarness.useRef,
    useState: reactHookHarness.useState,
  };
});

vi.mock("react/compiler-runtime", async () => {
  const { reactHookHarness } = await import("../../test/reactHookHarness");

  return { c: reactHookHarness.useMemoCache };
});

vi.mock("../../state/server", () => ({
  serverEnvironment: {
    imageProviders: <T,>(args: T) => ({ imageProviders: args }),
    testImageProvider: atoms.testImageProvider,
    logoutSubscriptionAuth: atoms.logoutSubscriptionAuth,
  },
}));

vi.mock("../../state/query", () => ({
  useEnvironmentQuery: (atom: NonNullable<typeof query.lastAtom>) => {
    query.lastAtom = atom;

    return {
      data: query.providers ? { providers: query.providers } : null,
      error: query.error,
      isPending: query.isPending,
      refresh: query.refresh,
    };
  },
}));

vi.mock("../../state/use-atom-command", () => ({
  useAtomCommand: (atom: symbol) =>
    atom === atoms.testImageProvider ? commands.test : commands.logout,
}));

vi.mock("../../hooks/useSettings", () => ({
  useEnvironmentSettings: <T,>(
    _environmentId: EnvironmentId,
    selector: (settings: UnifiedSettings) => T,
  ) =>
    selector({
      ...DEFAULT_SERVER_SETTINGS,
      imageGeneration: settingsState.imageGeneration ?? DEFAULT_SERVER_SETTINGS.imageGeneration,
    } as UnifiedSettings),
  useUpdateEnvironmentSettings: () => settingsState.updateSettings,
}));

vi.mock("../../settingsDialogStore", () => ({
  openSettings: navigation.openSettings,
  useSettingsEnvironmentId: () => null,
}));

vi.mock("../../confirmDialog", () => ({ requestConfirmDialog: confirm.request }));

import {
  ImageGenerationRoutingSection,
  ImageGenerationSettingsContent,
  ImageProviderRow,
} from "./ImageGenerationSettings";

const environmentId = EnvironmentId.make("remote-device");

function providerStatus(
  provider: ImageProviderStatus["provider"],
  overrides: Partial<ImageProviderStatus> = {},
): ImageProviderStatus {
  return {
    provider,
    label: provider === "chatgpt" ? "ChatGPT" : "Grok",
    connected: true,
    enabled: true,
    health: "detected",
    operations: ["generate"],
    ...overrides,
  };
}

function renderContent(): ReactElement<TestProps> {
  hooks.beginRender();

  return ImageGenerationSettingsContent({ environmentId }) as ReactElement<TestProps>;
}

function findRow(tree: TestValue, provider: ImageProviderStatus["provider"]) {
  const row = visitElements(
    tree,
    (element) => element.type === ImageProviderRow && element.props.provider === provider,
  );

  expect(row).not.toBeNull();

  return row!.props as {
    readonly status: ImageProviderStatus | undefined;
    readonly loadFailed: boolean;
    readonly onToggle: (enabled: boolean) => void;
    readonly onTest: () => void;
    readonly onDisconnect: () => void;
    readonly onConnect: () => void;
  };
}

async function flushPromises(): Promise<void> {
  for (let index = 0; index < 4; index += 1) await Promise.resolve();
}

describe("ImageGenerationSettingsContent environment wiring", () => {
  beforeEach(() => {
    hooks.reset();
    query.lastAtom = null;
    query.providers = [providerStatus("chatgpt"), providerStatus("grok")];
    query.error = null;
    query.isPending = false;
    query.refresh.mockReset();
    settingsState.imageGeneration = {
      chatgptEnabled: true,
      grokEnabled: false,
      defaultProvider: "chatgpt",
      fallbackOrder: ["chatgpt"],
    };
    settingsState.updateSettings.mockReset();
    commands.test.mockReset().mockResolvedValue({ _tag: "Success" });
    commands.logout.mockReset().mockResolvedValue({ _tag: "Success" });
    navigation.openSettings.mockReset();
    confirm.request.mockReset().mockResolvedValue(true);
  });

  it("lists image providers for the selected environment", () => {
    const tree = renderContent();
    expect(query.lastAtom).toEqual({ imageProviders: { environmentId, input: {} } });
    expect(findRow(tree, "grok").status?.provider).toBe("grok");
  });

  it("persists a provider toggle as an image generation settings patch", () => {
    findRow(renderContent(), "grok").onToggle(true);
    expect(settingsState.updateSettings).toHaveBeenCalledWith({
      imageGeneration: { grokEnabled: true, fallbackOrder: ["chatgpt", "grok"] },
    });
  });

  it("persists routing changes", () => {
    const routing = visitElements(
      renderContent(),
      (element) => element.type === ImageGenerationRoutingSection,
    );

    (routing!.props.onChange as (patch: Partial<ImageGenerationSettings>) => void)({
      defaultProvider: "grok",
    });
    expect(settingsState.updateSettings).toHaveBeenCalledWith({
      imageGeneration: { defaultProvider: "grok" },
    });
  });

  it("runs the health test in this environment and refreshes provider status", async () => {
    findRow(renderContent(), "grok").onTest();
    await flushPromises();
    expect(commands.test).toHaveBeenCalledWith({ environmentId, input: { provider: "grok" } });
    expect(query.refresh).toHaveBeenCalledTimes(1);
  });

  it("disconnects the matching subscription after confirmation", async () => {
    findRow(renderContent(), "chatgpt").onDisconnect();
    await flushPromises();
    expect(confirm.request).toHaveBeenCalledTimes(1);
    expect(commands.logout).toHaveBeenCalledWith({
      environmentId,
      input: { provider: "openai-codex" },
    });
    expect(query.refresh).toHaveBeenCalledTimes(1);

    findRow(renderContent(), "grok").onDisconnect();
    await flushPromises();
    expect(commands.logout).toHaveBeenLastCalledWith({ environmentId, input: { provider: "xai" } });
  });

  it("keeps the subscription when the user cancels or no confirm host answers", async () => {
    confirm.request.mockResolvedValueOnce(false);
    findRow(renderContent(), "grok").onDisconnect();
    await flushPromises();

    confirm.request.mockReturnValueOnce(null);
    findRow(renderContent(), "grok").onDisconnect();
    await flushPromises();

    expect(commands.logout).not.toHaveBeenCalled();
    expect(query.refresh).not.toHaveBeenCalled();
  });

  it("opens the provider login row in the same environment", () => {
    findRow(renderContent(), "grok").onConnect();
    expect(navigation.openSettings).toHaveBeenCalledWith(
      "providers",
      "subscription-provider-xai",
      environmentId,
    );
    findRow(renderContent(), "chatgpt").onConnect();
    expect(navigation.openSettings).toHaveBeenLastCalledWith(
      "providers",
      "subscription-provider-openai-codex",
      environmentId,
    );
  });

  it("marks rows as loading while provider status is pending", () => {
    query.providers = null;
    query.isPending = true;
    const tree = renderContent();
    const row = findRow(tree, "grok");
    expect(row.status).toBeUndefined();
    expect(row.loadFailed).toBe(false);
    expect(
      visitElements(
        tree,
        (element) => element.props["aria-label"] === "Retry loading image providers",
      ),
    ).toBeNull();
  });

  it("reports a load failure and retries the provider query", () => {
    query.providers = null;
    query.error = "Connection lost";
    const tree = renderContent();
    expect(findRow(tree, "grok").loadFailed).toBe(true);

    const retry = visitElements(
      tree,
      (element) => element.props["aria-label"] === "Retry loading image providers",
    );

    expect(retry).not.toBeNull();
    (retry!.props.onClick as () => void)();
    expect(query.refresh).toHaveBeenCalledTimes(1);
  });
});