sailfork / t3code-github / apps/ mobile/ src/ features/ pull-requests/ guide/ useReviewGuide.test.tsx

import {
  NavigationContext,
  type NavigationProp,
  type ParamListBase,
} from "@react-navigation/native";
import { AsyncResult } 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(() => ({
  enabled: true,
  generate: vi.fn(),
  query: {
    data: null as { run: { _tag: "Running" | "Completed" | "Failed" } | null } | null,
    isPending: false,
    refresh: vi.fn<() => void>(),
  },
  otherQuery: {
    data: null as { run: { _tag: "Running" | "Completed" | "Failed" } | null } | null,
    isPending: false,
    refresh: vi.fn<() => void>(),
  },
}));

vi.mock("@react-navigation/native", async () => {
  const { createRequire } = await import("node:module");
  const { realpathSync } = await import("node:fs");
  const require = createRequire(import.meta.url);
  const nativeRequire = createRequire(
    realpathSync(require.resolve("@react-navigation/native/package.json")),
  );
  // Use the shipped focus hook without importing the React Native view layer.
  const { NavigationContext, useFocusEffect }: typeof import("@react-navigation/native") =
    nativeRequire("@react-navigation/core");
  return { NavigationContext, useFocusEffect };
});
vi.mock("@effect/atom-react", () => ({
  useAtomValue: (atom: unknown) =>
    atom === "settings" ? { reviewGuidesEnabled: mocks.enabled } : true,
}));
vi.mock("../../../state/server", () => ({
  serverEnvironment: { settingsValueAtom: () => "settings" },
}));
vi.mock("../../../state/pull-requests", () => ({
  composerPullRequests: {
    reviewGuide: (target: { number: number; environmentId: string }) =>
      target.environmentId === "environment" && target.number === 1 ? 1 : 2,
    generateReviewGuide: { permissionAtom: () => "permission" },
  },
}));
vi.mock("../../../state/query", () => ({
  useEnvironmentQuery: (number: number) => ({ ...(number === 1 ? mocks.query : mocks.otherQuery) }),
}));
vi.mock("../../../state/use-atom-command", () => ({ useAtomCommand: () => mocks.generate }));
vi.mock("../usePullRequestConnected", () => ({ usePullRequestConnected: () => true }));
vi.mock("../usePullRequestDiff", () => ({
  pullRequestTarget: (params: unknown) => params,
}));

import { useReviewGuide } from "./useReviewGuide";

function createNavigation() {
  const listeners = { focus: new Set<() => void>(), blur: new Set<() => void>() };
  let focused = true;
  return {
    value: {
      isFocused: () => focused,
      addListener: (event: keyof typeof listeners, listener: () => void) => {
        listeners[event].add(listener);
        return () => listeners[event].delete(listener);
      },
    } as unknown as NavigationProp<ParamListBase>,
    focus(next: boolean) {
      focused = next;
      act(() => {
        for (const listener of listeners[next ? "focus" : "blur"]) listener();
      });
    },
  };
}

function setup() {
  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
  mocks.enabled = true;
  mocks.generate = vi.fn().mockResolvedValue(AsyncResult.success(undefined));
  mocks.query = { data: null, isPending: false, refresh: vi.fn() };
  mocks.otherQuery = { data: null, isPending: false, refresh: vi.fn() };
  const root = createRoot(document.createElement("div"));
  const navigation = createNavigation();
  const params = {
    environmentId: "environment",
    projectId: "project",
    repository: "repo",
    number: 1,
  };
  let current: ReturnType<typeof useReviewGuide>;
  function Probe({
    number,
    environmentId,
    visible,
  }: {
    number: number;
    environmentId: string;
    visible?: boolean;
  }) {
    const state = useReviewGuide({ ...params, number, environmentId }, visible);
    useLayoutEffect(() => {
      current = state;
    });
    return null;
  }
  return {
    render(number = 1, environmentId = params.environmentId, visible?: boolean) {
      act(() =>
        root.render(
          <NavigationContext.Provider value={navigation.value}>
            <Probe number={number} environmentId={environmentId} visible={visible} />
          </NavigationContext.Provider>,
        ),
      );
    },
    get current() {
      return current;
    },
    focus: navigation.focus,
    [Symbol.dispose]() {
      act(() => root.unmount());
    },
  };
}

it("refreshes on focus and PR changes without refreshing again for query rerenders", () => {
  using screen = setup();
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);

  mocks.query = { ...mocks.query, isPending: true };
  screen.render();
  mocks.query = { ...mocks.query, isPending: false, data: { run: { _tag: "Completed" } } };
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);

  screen.focus(false);
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  screen.focus(true);
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);

  screen.render(2);
  expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
  screen.render(2);
  expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
});

it("preserves the polling deadline across rerenders and stops polling on blur or completion", () => {
  vi.useFakeTimers();
  using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
  using screen = setup();
  mocks.query.data = { run: { _tag: "Running" } };
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);

  act(() => vi.advanceTimersByTime(4_000));
  mocks.query = { ...mocks.query, isPending: true, data: { run: { _tag: "Running" } } };
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  act(() => vi.advanceTimersByTime(1_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);

  screen.focus(false);
  act(() => vi.advanceTimersByTime(10_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
  screen.focus(true);
  expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
  act(() => vi.advanceTimersByTime(5_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(4);

  mocks.query = { ...mocks.query, isPending: false, data: { run: { _tag: "Completed" } } };
  screen.render();
  const refreshesOnCompletion = mocks.query.refresh.mock.calls.length;
  act(() => vi.advanceTimersByTime(10_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(refreshesOnCompletion);
});

it("retires the old environment's polling on target change and clears polling on unmount", () => {
  vi.useFakeTimers();
  using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
  {
    using screen = setup();
    mocks.query.data = { run: { _tag: "Running" } };
    mocks.otherQuery.data = { run: { _tag: "Running" } };
    screen.render();
    act(() => vi.advanceTimersByTime(4_000));

    screen.render(1, "other-environment");
    expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
    expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
    act(() => vi.advanceTimersByTime(1_000));
    expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
    expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
    act(() => vi.advanceTimersByTime(4_000));
    expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
    expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
  }
  act(() => vi.advanceTimersByTime(10_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
  expect(vi.getTimerCount()).toBe(0);
});

it("suspends only manual refresh while hidden, including focus and target changes", () => {
  vi.useFakeTimers();
  using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
  {
    using screen = setup();
    mocks.query.data = { run: { _tag: "Running" } };
    mocks.otherQuery.data = { run: { _tag: "Running" } };
    screen.render();
    const cached = screen.current.data;
    screen.render(1, "environment", false);
    act(() => vi.advanceTimersByTime(60_000));
    expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
    expect(screen.current.data).toBe(cached);
    screen.render();
    expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
    act(() => vi.advanceTimersByTime(5_000));
    expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
    screen.render(1, "environment", false);
    screen.focus(false);
    screen.focus(true);
    expect(mocks.query.refresh).toHaveBeenCalledTimes(3);

    screen.render(2, "other-environment", false);
    act(() => vi.advanceTimersByTime(5_000));
    expect(mocks.otherQuery.refresh).not.toHaveBeenCalled();
    screen.focus(false);
    screen.render(2, "other-environment", true);
    expect(mocks.otherQuery.refresh).not.toHaveBeenCalled();
    screen.focus(true);
    expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(1);
    act(() => vi.advanceTimersByTime(5_000));
    expect(mocks.otherQuery.refresh).toHaveBeenCalledTimes(2);
    expect(mocks.query.refresh).toHaveBeenCalledTimes(3);
  }
  expect(vi.getTimerCount()).toBe(0);
});

it("keeps disabled, completed and failed guides idle and refreshes once on reveal", () => {
  vi.useFakeTimers();
  using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
  using screen = setup();
  mocks.enabled = false;
  screen.render();
  act(() => vi.advanceTimersByTime(5_000));
  expect(mocks.query.refresh).not.toHaveBeenCalled();
  mocks.enabled = true;
  mocks.query.data = { run: null };
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  act(() => vi.advanceTimersByTime(10_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  screen.render(1, "environment", false);
  mocks.query.data = { run: { _tag: "Failed" } };
  screen.render(1, "environment", false);
  expect(mocks.query.refresh).toHaveBeenCalledTimes(1);
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
  act(() => vi.advanceTimersByTime(10_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(2);
  expect(vi.getTimerCount()).toBe(0);
});

it("leaves generation running when hidden and accepts its completion without a refresh", async () => {
  vi.useFakeTimers();
  using _timers = { [Symbol.dispose]: () => vi.useRealTimers() };
  using screen = setup();
  const generated = Promise.withResolvers<ReturnType<typeof AsyncResult.success<void>>>();
  mocks.generate.mockReturnValue(generated.promise);
  screen.render();
  let writing: Promise<void>;
  act(() => {
    writing = screen.current.write();
  });
  expect(screen.current.running).toBe(true);
  screen.render(1, "environment", false);
  const beforeHidden = mocks.query.refresh.mock.calls.length;
  act(() => vi.advanceTimersByTime(60_000));
  expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden);
  expect(mocks.generate).toHaveBeenCalledTimes(1);
  expect(screen.current.running).toBe(true);
  await act(async () => {
    generated.resolve(AsyncResult.success(undefined));
    await writing;
  });
  expect(screen.current.running).toBe(false);
  expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden);
  screen.render();
  expect(mocks.query.refresh).toHaveBeenCalledTimes(beforeHidden + 1);
  expect(vi.getTimerCount()).toBe(0);
});