sailfork / t3code-github / apps/ mobile/ src/ state/ queries.debounce.test.tsx

import { AuthFilesystemReadScope, EnvironmentId } from "@t3tools/contracts";
import { RegistryContext } from "@effect/atom-react";
import type { VcsRefTarget } from "@t3tools/client-runtime/state/vcs";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import { act, useLayoutEffect } from "react";
import { createRoot } from "react-dom/client";
import { expect, it, vi } from "vite-plus/test";

const mocks = vi.hoisted(() => ({
  sessionAtom: {},
  searchEntries: vi.fn(() => null),
  listRefs: vi.fn(),
  refresh: vi.fn(),
}));

vi.mock("./session", () => ({
  environmentSession: { sessionStateAtom: () => mocks.sessionAtom },
}));
vi.mock("./presentation", () => ({
  useEnvironmentPresentation: () => ({
    isReady: true,
    presentation: { connection: { phase: "connected", error: null } },
  }),
}));
vi.mock("./pull-requests", () => ({ composerPullRequests: {} }));
vi.mock("./projects", () => ({
  projectEnvironment: { searchEntries: mocks.searchEntries },
}));
vi.mock("./atom-registry", () => ({ appAtomRegistry: { refresh: mocks.refresh } }));
vi.mock("./orchestration", () => ({ orchestrationEnvironment: {} }));
vi.mock("./vcs", () => ({ vcsEnvironment: { listRefs: mocks.listRefs } }));
vi.mock("./threads", () => ({ olderSettledThreads: {}, threadFamilies: {} }));
vi.mock("./query", () => ({
  useEnvironmentQuery: (atom: unknown) => ({
    data:
      atom === mocks.sessionAtom
        ? { authenticated: true, scopes: [AuthFilesystemReadScope] }
        : null,
    error: null,
    isPending: false,
    refresh: () => {},
  }),
}));

import {
  useComposerPathSearch,
  usePaginatedBranches,
  type ComposerPathSearchTarget,
} from "./queries";

function setup() {
  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
  vi.useFakeTimers();
  mocks.searchEntries.mockClear();
  const root = createRoot(document.createElement("div"));
  function Probe({ target }: { readonly target: ComposerPathSearchTarget }) {
    useComposerPathSearch(target);
    return null;
  }

  return {
    render(target: ComposerPathSearchTarget) {
      act(() => root.render(<Probe target={{ ...target }} />));
    },
    [Symbol.dispose]() {
      act(() => root.unmount());
      vi.useRealTimers();
    },
  };
}

const target = {
  environmentId: EnvironmentId.make("test-environment"),
  cwd: "/repo",
  query: "src",
};

it("keeps the original search deadline when rerenders have equivalent targets", () => {
  using harness = setup();
  harness.render({ ...target, query: null });
  harness.render({ ...target, query: " src " });
  act(() => vi.advanceTimersByTime(100));
  harness.render(target);
  act(() => vi.advanceTimersByTime(99));
  expect(mocks.searchEntries).not.toHaveBeenCalled();

  act(() => vi.advanceTimersByTime(1));
  expect(mocks.searchEntries).toHaveBeenCalledExactlyOnceWith({
    environmentId: target.environmentId,
    input: { cwd: target.cwd, query: target.query, limit: 20 },
  });
});

it.each([
  { field: "environment", changed: { ...target, environmentId: EnvironmentId.make("other") } },
  { field: "project directory", changed: { ...target, cwd: "/other" } },
  { field: "query", changed: { ...target, query: "test" } },
])("restarts the search deadline when the $field changes", ({ changed }) => {
  using harness = setup();
  harness.render({ ...target, query: null });
  harness.render(target);
  act(() => vi.advanceTimersByTime(100));
  harness.render(changed);

  act(() => vi.advanceTimersByTime(100));
  expect(mocks.searchEntries).not.toHaveBeenCalled();
  act(() => vi.advanceTimersByTime(99));
  expect(mocks.searchEntries).not.toHaveBeenCalled();

  act(() => vi.advanceTimersByTime(1));
  expect(mocks.searchEntries).toHaveBeenCalledExactlyOnceWith({
    environmentId: changed.environmentId,
    input: { cwd: changed.cwd, query: changed.query, limit: 20 },
  });
});

it("keeps compiled branch results stable and resets pagination for a new target or refresh", () => {
  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
  const registry = AtomRegistry.make();
  const pages = Atom.family((key: string) => {
    const [, cwd, cursor] = JSON.parse(key) as [string, string, number | null];
    return Atom.make(
      AsyncResult.success({
        refs: [
          { name: `${cwd}-${cursor ?? 0}`, current: false, isDefault: false, worktreePath: null },
        ],
        isRepo: true,
        hasPrimaryRemote: true,
        nextCursor: cursor === null ? 100 : null,
        totalCount: 2,
      }),
    );
  });
  mocks.listRefs.mockImplementation(
    ({
      environmentId,
      input,
    }: {
      environmentId: EnvironmentId;
      input: { cwd: string; cursor?: number };
    }) => pages(JSON.stringify([environmentId, input.cwd, input.cursor ?? null])),
  );
  mocks.refresh.mockClear();
  const root = createRoot(document.createElement("div"));
  using _cleanup = {
    [Symbol.dispose]() {
      act(() => root.unmount());
      registry.dispose();
    },
  };
  let current: ReturnType<typeof usePaginatedBranches>;
  function Probe({ target }: { target: VcsRefTarget }) {
    const result = usePaginatedBranches(target);
    useLayoutEffect(() => {
      current = result;
    });
    return null;
  }
  const render = (cwd: string | null, options: Partial<VcsRefTarget> = {}) =>
    act(() =>
      root.render(
        <RegistryContext.Provider value={registry}>
          <Probe target={{ environmentId: target.environmentId, cwd, ...options }} />
        </RegistryContext.Provider>,
      ),
    );
  render("/repo");
  const first = current!;
  render("/repo");
  expect(current!.data).toBe(first.data);
  expect(current!.refs).toBe(first.refs);
  expect(current!.refresh).toBe(first.refresh);
  expect(current!.loadNext).toBe(first.loadNext);
  act(() =>
    registry.set(
      pages(JSON.stringify([target.environmentId, "/repo", null])),
      AsyncResult.success({
        ...first.data!,
        refs: [{ name: "/repo-0", current: true, isDefault: false, worktreePath: null }],
      }),
    ),
  );
  expect(current!.refs[0]?.current).toBe(true);
  act(() => current!.loadNext());
  expect(current!.refs.map((ref) => ref.name)).toEqual(["/repo-0", "/repo-100"]);
  act(() => current!.refresh());
  expect(current!.refs.map((ref) => ref.name)).toEqual(["/repo-0"]);
  expect(mocks.refresh).toHaveBeenCalledExactlyOnceWith(
    pages(JSON.stringify([target.environmentId, "/repo", null])),
  );
  act(() => current!.loadNext());
  render("/other");
  expect(current!.refs.map((ref) => ref.name)).toEqual(["/other-0"]);
  act(() => current!.loadNext());
  render("/other", { query: "feature" });
  expect(current!.refs).toHaveLength(1);
  act(() => current!.loadNext());
  render("/other", { environmentId: EnvironmentId.make("other-environment"), query: "feature" });
  expect(current!.refs).toHaveLength(1);
  render(null);
  expect(current!.data).toBeNull();
  expect(current!.refs).toEqual([]);
});