Skip to content

Your lightweight open-source personal agent.

15.1 KB
Raw Blame
import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { HostNavigationContext, HostSwitcher, RemoteHostMenu, type HostPicker } from "@/components/remote/HostSwitcher";
import { readRecentRemotes, rememberRecentRemote } from "@/lib/remote-instances";

vi.mock("@/providers/ClientProvider", () => ({ useClient: () => ({ client: {
  status: "open", onStatus: () => () => {},
} }) }));

function picker(count: number): HostPicker {
  return {
    kind: "shell", name: "Local", hostname: "My-Mac", localName: "My-Mac",
    currentId: null, recentIds: [], pending: null, error: "", offline: false,
    profiles: Array.from({ length: count }, (_, index) => ({
      id: `00000000-0000-4000-8000-${String(index + 1).padStart(12, "0")}`,
      name: index === 1 ? "研发服务器" : `Server ${index + 1}`,
      host: `ubuntu@host-${index + 1}.test`, state: "closed",
    })),
    select: vi.fn(), manage: vi.fn(), cancel: vi.fn(), clearError: vi.fn(), restoreFocus: vi.fn(),
  };
}

async function openMenu(value: HostPicker) {
  const view = render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
  await userEvent.click(screen.getByRole("button", { name: "Switch host" }));
  await screen.findByRole("menu");
  return view;
}

beforeEach(() => window.localStorage.clear());
afterEach(() => { cleanup(); vi.restoreAllMocks(); });

describe("host switcher", () => {
  it("announces the host only once when its display name is the hostname", async () => {
    const value = { ...picker(1), name: "team-host", hostname: "team-host" };
    render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    expect(screen.getByRole("status").textContent).toBe("team-host, Connected");
    const trigger = screen.getByRole("button", { name: "Switch host" });
    expect(trigger).not.toHaveAttribute("title");
    await userEvent.hover(trigger);
    const tooltip = await screen.findByRole("tooltip");
    expect(within(tooltip).getByText("team-host")).toBeVisible();
    expect(within(tooltip).getByText("Connected")).toBeVisible();
  });

  it("does not borrow the local socket's Connected status while restoring a remote", () => {
    const value = picker(1);
    value.currentId = value.profiles[0].id;
    value.name = value.profiles[0].name;
    value.profiles[0].state = "connecting";
    value.pending = value.profiles[0];
    render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    expect(screen.getByRole("status")).not.toHaveTextContent("Connected");
    expect(screen.getByRole("status")).toHaveTextContent("Connecting");
  });

  it("keeps the current host identity visible until a pending switch is ready", async () => {
    const value = picker(2);
    value.pending = value.profiles[0];
    render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    const trigger = screen.getByRole("button", { name: "Switch host" });
    expect(within(trigger).getByText("Local", { exact: true })).toBeVisible();
    await userEvent.hover(trigger);
    expect(await screen.findByRole("tooltip")).toHaveTextContent("Connecting to Server 1");
    expect(within(trigger).getByRole("status")).toHaveTextContent("Local, My-Mac, Connected. Connecting to Server 1");
    await userEvent.click(trigger);
    expect(screen.getByRole("menuitem", { name: "Local nanobot My-Mac" })).toHaveAttribute("aria-current", "true");
    expect(screen.getByRole("menuitem", { name: "Server 1 [email protected]" })).not.toHaveAttribute("aria-current");
  });

  it("does not label a healthy host offline when switching to another host fails", async () => {
    const value = { ...picker(2), error: "Destination SSH is unreachable" };
    render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    const trigger = screen.getByRole("button", { name: "Switch host" });
    expect(within(trigger).getByRole("status")).toHaveTextContent("Local, My-Mac, Connected");
    await userEvent.hover(trigger);
    expect(await screen.findByRole("tooltip")).toHaveTextContent(value.error);
    expect(trigger).not.toHaveTextContent("Offline");
    await userEvent.click(trigger);
    expect(screen.getByRole("alert")).toHaveTextContent(value.error);
  });

  it("keeps a truly disconnected host offline independently of switch errors", () => {
    const value = { ...picker(2), offline: true, name: "Team server", hostname: "team-host" };
    render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    expect(screen.getByRole("status")).toHaveTextContent("Team server, team-host, Server connection lost");
  });

  it("keeps remote sidebar identity and connection status separate from pending or failed switches", async () => {
    const value = { kind: "embedded" as const, name: "Team server", hostname: "team-host", pendingName: "Another server", open: vi.fn() };
    const view = render(<HostNavigationContext.Provider value={value}><HostSwitcher /></HostNavigationContext.Provider>);
    const trigger = screen.getByRole("button", { name: "Switch host" });
    expect(within(trigger).getByText("Team server", { exact: true })).toBeVisible();
    expect(within(trigger).getByRole("status")).toHaveTextContent("Team server, team-host, Connected. Connecting to Another server");
    view.rerender(<HostNavigationContext.Provider value={{ ...value, pendingName: undefined, error: "Destination SSH is unreachable" }}><HostSwitcher /></HostNavigationContext.Provider>);
    expect(within(trigger).getByRole("status")).toHaveTextContent("Team server, team-host, Connected");
    await userEvent.hover(trigger);
    expect(await screen.findByRole("tooltip")).toHaveTextContent("Destination SSH is unreachable");
  });
  it.each([0, 1, 5])("keeps %i saved hosts simple without search", async (count) => {
    await openMenu(picker(count));
    expect(screen.queryByRole("textbox")).not.toBeInTheDocument();
    expect(screen.getAllByRole("menuitem")).toHaveLength(count + 2);
  });

  it.each([6, 10, 20])("searches %i saved hosts, with management outside the scroll area", async (count) => {
    await openMenu(picker(count));
    const input = screen.getByRole("textbox", { name: "Search hosts…" });
    await waitFor(() => expect(input).toHaveFocus());
    const group = screen.getByRole("group", { name: "Switch host" });
    expect(within(group).getAllByRole("menuitem")).toHaveLength(count + 1);
    expect(group).toHaveClass("overflow-y-auto", "min-h-0");
    expect(group).not.toContainElement(screen.getByRole("menuitem", { name: "Manage connections" }));
    await userEvent.type(input, "HOST-6.TEST");
    expect(within(group).getAllByRole("menuitem")).toHaveLength(1);
    expect(within(group).getByText("Server 6")).toBeVisible();
    expect(input).toHaveFocus();
  });

  it("finds names with spaces, non-Latin names and the local machine", async () => {
    await openMenu(picker(20));
    const input = screen.getByRole("textbox");
    await userEvent.type(input, "Server 20");
    expect(screen.getByRole("menuitem", { name: "Server 20 [email protected]" })).toBeVisible();
    fireEvent.change(input, { target: { value: "研发" } });
    expect(screen.getByRole("menuitem", { name: "研发服务器 [email protected]" })).toBeVisible();
    fireEvent.change(input, { target: { value: "My-Mac" } });
    expect(screen.getByRole("menuitem", { name: "Local nanobot My-Mac" })).toBeVisible();
    expect(screen.queryByText("Server 20")).not.toBeInTheDocument();
  });

  it("keeps search focused while the pointer crosses results", async () => {
    await openMenu(picker(10));
    const input = screen.getByRole("textbox");
    await waitFor(() => expect(input).toHaveFocus());
    const row = screen.getByRole("menuitem", { name: "Server 1 [email protected]" });
    fireEvent.pointerMove(row, { pointerType: "mouse", clientX: 25 });
    fireEvent.pointerOut(row, { pointerType: "mouse" });
    expect(input).toHaveFocus();
    await userEvent.type(input, "Server 10");
    expect(screen.getByRole("menuitem", { name: "Server 10 [email protected]" })).toBeVisible();
  });

  it("supports arrow navigation back to search, then Enter selection", async () => {
    const value = picker(10);
    await openMenu(value);
    const input = screen.getByRole("textbox");
    await userEvent.type(input, "host-10");
    await userEvent.keyboard("{ArrowDown}");
    expect(screen.getByRole("menuitem", { name: "Server 10 [email protected]" })).toHaveFocus();
    await userEvent.keyboard("{ArrowUp}");
    expect(input).toHaveFocus();
    await userEvent.keyboard("{Enter}");
    expect(value.select).toHaveBeenCalledWith(value.profiles[9].id);
    await waitFor(() => expect(screen.queryByRole("menu")).not.toBeInTheDocument());
  });

  it("does not connect or close when confirming IME input", async () => {
    const value = picker(10);
    await openMenu(value);
    const input = screen.getByRole("textbox");
    fireEvent.compositionStart(input);
    fireEvent.change(input, { target: { value: "研发" } });
    fireEvent.keyDown(input, { key: "Enter", isComposing: true });
    fireEvent.keyDown(input, { key: "Escape", isComposing: true });
    expect(value.select).not.toHaveBeenCalled();
    expect(screen.getByRole("menu")).toBeVisible();
    fireEvent.compositionEnd(input);
    fireEvent.keyDown(input, { key: "Enter" });
    expect(value.select).toHaveBeenCalledWith(value.profiles[1].id);
  });

  it("does not select a host on empty search Enter", async () => {
    const value = picker(10);
    await openMenu(value);
    await waitFor(() => expect(screen.getByRole("textbox")).toHaveFocus());
    await userEvent.keyboard("{Enter}");
    expect(value.select).not.toHaveBeenCalled();
  });

  it("shows an empty result without hiding management or selecting it on Enter", async () => {
    const value = picker(10);
    await openMenu(value);
    await userEvent.type(screen.getByRole("textbox"), "missing");
    expect(screen.getByRole("status", { name: "" })).toHaveTextContent("No matching hosts");
    await userEvent.keyboard("{Enter}");
    expect(value.select).not.toHaveBeenCalled();
    expect(value.manage).not.toHaveBeenCalled();
    await userEvent.keyboard("{ArrowDown}{Enter}");
    expect(value.manage).toHaveBeenCalledOnce();
  });

  it("clears search on reopen and restores focus on Escape", async () => {
    const value = picker(10);
    await openMenu(value);
    await userEvent.type(screen.getByRole("textbox"), "Server 10");
    await userEvent.keyboard("{Escape}");
    await waitFor(() => expect(value.restoreFocus).toHaveBeenCalled());
    await userEvent.click(screen.getByRole("button", { name: "Switch host" }));
    expect(await screen.findByRole("textbox")).toHaveValue("");
    expect(screen.getAllByRole("menuitem")).toHaveLength(12);
  });

  it("pins local, then current and recent hosts, without live reordering or duplicates", async () => {
    const value = picker(20);
    value.currentId = value.profiles[19].id;
    value.recentIds = [value.profiles[8].id, value.currentId, "deleted-id"];
    const rendered = await openMenu(value);
    const names = () => within(screen.getByRole("group")).getAllByRole("menuitem").map((item) => item.getAttribute("aria-label") || item.textContent);
    expect(names().slice(0, 4)).toEqual(["Local nanobotMy-Mac", "Server 20 [email protected]", "Server 9 [email protected]", "Server 1 [email protected]"]);
    const before = names();
    rendered.rerender(<HostNavigationContext.Provider value={{ ...value, recentIds: [value.profiles[5].id] }}><HostSwitcher /></HostNavigationContext.Provider>);
    expect(names()).toEqual(before);
  });

  it("uses the same searchable menu for the parent-owned remote sidebar", async () => {
    const value = picker(20);
    render(<RemoteHostMenu picker={value} anchor={{ left: 48, top: 540, width: 160, height: 32 }} onClose={vi.fn()} />);
    const input = await screen.findByRole("textbox");
    await userEvent.type(input, "host-20");
    await userEvent.click(screen.getByRole("menuitem", { name: "Server 20 [email protected]" }));
    expect(value.select).toHaveBeenCalledWith(value.profiles[19].id);
  });

  it("keeps search available if the directory shrinks while filtering", async () => {
    const value = picker(10);
    const rendered = await openMenu(value);
    await userEvent.type(screen.getByRole("textbox"), "host-10");
    rendered.rerender(<HostNavigationContext.Provider value={{ ...value, profiles: value.profiles.slice(0, 5) }}><HostSwitcher /></HostNavigationContext.Provider>);
    const input = screen.getByRole("textbox");
    expect(input).toHaveValue("host-10");
    await userEvent.clear(input);
    expect(within(screen.getByRole("group")).getAllByRole("menuitem")).toHaveLength(6);
  });

  it("does not autofocus search and summon the keyboard on touch devices", async () => {
    const original = window.matchMedia.bind(window);
    vi.spyOn(window, "matchMedia").mockImplementation((query) => ({ ...original(query), matches: query === "(pointer: coarse)" }));
    await openMenu(picker(20));
    expect(screen.getByRole("menu")).toHaveFocus();
    expect(screen.getByRole("textbox")).not.toHaveFocus();
    await userEvent.click(screen.getByRole("menuitem", { name: "Server 20 [email protected]" }));
    await waitFor(() => expect(screen.queryByRole("menu")).not.toBeInTheDocument());
  });

  it("keeps cancel and errors accessible even when no hosts match", async () => {
    const value = picker(20);
    value.pending = value.profiles[3]; value.error = "Try again";
    await openMenu(value);
    await userEvent.type(screen.getByRole("textbox"), "missing");
    expect(screen.getByRole("alert")).toHaveTextContent("Try again");
    await userEvent.click(screen.getByRole("button", { name: "Close" }));
    expect(value.clearError).toHaveBeenCalledOnce();
    await userEvent.click(screen.getByRole("menuitem", { name: "Cancel switch" }));
    expect(value.cancel).toHaveBeenCalledOnce();
  });
});

describe("recent host preferences", () => {
  it("keeps only bounded, unique profile IDs and ignores malformed storage", () => {
    window.localStorage.setItem("nanobot.recent-remote-instances", "not json");
    expect(readRecentRemotes()).toEqual([]);
    const ids = picker(25).profiles.map(({ id }) => id);
    window.localStorage.setItem("nanobot.recent-remote-instances", JSON.stringify([null, "http://secret", ids[0], ...ids]));
    expect(readRecentRemotes()).toEqual(ids.slice(0, 20));
    const next = rememberRecentRemote(ids[5], readRecentRemotes());
    expect(next).toHaveLength(20);
    expect(next[0]).toBe(ids[5]);
    expect(readRecentRemotes()).toEqual(next);
  });

  it("keeps switching available when browser storage is disabled", () => {
    vi.spyOn(window.localStorage, "getItem").mockImplementation(() => { throw new Error("disabled"); });
    vi.spyOn(window.localStorage, "setItem").mockImplementation(() => { throw new Error("disabled"); });
    expect(readRecentRemotes()).toEqual([]);
    expect(rememberRecentRemote(picker(1).profiles[0].id, [])).toEqual([picker(1).profiles[0].id]);
  });
});