sailfork / t3code-github / apps/ mobile/ src/ state/ use-thread-pr.demand.test.tsx

import { RegistryContext } from "@effect/atom-react";
import {
  EnvironmentId,
  ProjectId,
  ThreadId,
  WS_METHODS,
  type PullRequestRef,
} from "@t3tools/contracts";
import type { EnvironmentThreadShell } from "@t3tools/client-runtime/state/shell";
import {
  EnvironmentRegistry,
  EnvironmentSupervisor,
  AVAILABLE_CONNECTION_STATE,
  PrimaryConnectionTarget,
  type SupervisorConnectionState,
  type PreparedConnection,
  type ConnectionCatalogEntry,
} from "@t3tools/client-runtime/connection";
import type { RpcSession } from "@t3tools/client-runtime/rpc";
import * as Effect from "effect/Effect";
import * as Latch from "effect/Latch";
import * as Option from "effect/Option";
import * as Stream from "effect/Stream";
import * as SubscriptionRef from "effect/SubscriptionRef";
import { AtomRegistry } from "effect/reactivity";
import { Activity, act, useState } from "react";
import { createRoot } from "react-dom/client";
import { expect, it } from "@effect/vitest";
import { vi } from "vite-plus/test";

const fixture = vi.hoisted(() => ({
  environment: undefined as EnvironmentRegistry.EnvironmentRegistry["Service"] | undefined,
  active: "active",
  listeners: new Set<() => void>(),
}));

vi.mock("react-native", () => ({
  AppState: {
    get currentState() {
      return fixture.active;
    },
    addEventListener: (_event: string, listener: () => void) => {
      fixture.listeners.add(listener);
      return { remove: () => fixture.listeners.delete(listener) };
    },
  },
}));
vi.mock("../connection/runtime", async () => {
  const { Atom } = await import("effect/reactivity");
  const Layer = await import("effect/Layer");
  const { EnvironmentRegistry } = await import("@t3tools/client-runtime/connection");
  return {
    connectionAtomRuntime: Atom.runtime(
      Layer.suspend(() =>
        Layer.succeed(EnvironmentRegistry.EnvironmentRegistry, fixture.environment!),
      ),
    ),
  };
});
vi.mock("./server", async () => {
  const { Atom } = await import("effect/reactivity");
  const config = Atom.make({ environment: { capabilities: { threadPullRequests: true } } });
  return { serverEnvironment: { configValueAtom: () => config } };
});

import { ThreadPrDemandProvider } from "./thread-pr-demand";
import { useThreadPr } from "./use-thread-pr";

const environmentId = EnvironmentId.make("sidebar-environment");
const reference = {
  projectId: ProjectId.make("project"),
  repository: "acme/app",
  number: 12,
  url: "https://github.com/acme/app/pull/12",
};
function thread(overrides: Partial<EnvironmentThreadShell> = {}): EnvironmentThreadShell {
  return {
    environmentId,
    id: ThreadId.make("thread"),
    pullRequests: [],
    linkedPullRequest: null,
    branchPullRequest: reference,
    ...overrides,
  } as EnvironmentThreadShell;
}

const setup = Effect.fn("TestThreadPr.setup")(function* () {
  (globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true;
  vi.useFakeTimers({
    toFake: ["Date", "setTimeout", "clearTimeout", "setInterval", "clearInterval"],
  });
  vi.setSystemTime(0);
  fixture.active = "active";
  fixture.listeners.clear();
  const requests: Array<{ environmentId: EnvironmentId; input: PullRequestRef }> = [];
  let state = "open";
  let replyGate: Latch.Latch | null = null;
  const target = new PrimaryConnectionTarget({
    environmentId,
    label: "Sidebar environment",
    httpBaseUrl: "https://sidebar.test",
    wsBaseUrl: "wss://sidebar.test",
  });
  const supervisor = yield* Effect.gen(function* () {
    return EnvironmentSupervisor.EnvironmentSupervisor.of({
      target,
      state: yield* SubscriptionRef.make<SupervisorConnectionState>({
        ...AVAILABLE_CONNECTION_STATE,
        phase: "connected" as const,
        desired: true,
        network: "online" as const,
        attempt: 1,
        generation: 1,
      }),
      session: yield* SubscriptionRef.make(
        Option.some({
          client: {
            [WS_METHODS.pullRequestsSummary]: (input: PullRequestRef) =>
              Effect.gen(function* () {
                requests.push({ environmentId: currentEnvironment, input });
                if (replyGate !== null) yield* replyGate.await;
                return {
                  ...input,
                  provider: "github",
                  state,
                  title: `Change ${input.number}`,
                  url: `https://github.com/${input.repository}/pull/${input.number}`,
                  baseBranch: "main",
                  headBranch: "feature",
                  isDraft: false,
                  updatedAt: null,
                };
              }),
            [WS_METHODS.pullRequestsSubscribeRefreshes]: () => Stream.never,
          },
          ready: Effect.void,
        } as unknown as RpcSession),
      ),
      prepared: yield* SubscriptionRef.make(Option.none<PreparedConnection>()),
      connect: Effect.void,
      disconnect: Effect.void,
      retryNow: Effect.void,
    });
  });
  let currentEnvironment = environmentId;
  const environment = {
    entries: yield* SubscriptionRef.make<ReadonlyMap<EnvironmentId, ConnectionCatalogEntry>>(
      new Map(),
    ),
    run: (id, effect) => {
      currentEnvironment = id;
      return Effect.provideService(effect, EnvironmentSupervisor.EnvironmentSupervisor, supervisor);
    },
    followStream: (_id, stream) =>
      Stream.provideService(stream, EnvironmentSupervisor.EnvironmentSupervisor, supervisor),
    stateChanges: () => SubscriptionRef.changes(supervisor.state),
  } satisfies Pick<
    EnvironmentRegistry.EnvironmentRegistry["Service"],
    "entries" | "run" | "followStream" | "stateChanges"
  >;
  fixture.environment =
    environment as unknown as EnvironmentRegistry.EnvironmentRegistry["Service"];
  const registry = AtomRegistry.make();
  const container = document.createElement("div");
  const root = createRoot(container);
  let mounts = 0;
  function Row({ value, name }: { value: EnvironmentThreadShell; name: string }) {
    const [passive] = useState(() => ++mounts);
    const pr = useThreadPr(value);
    return (
      <output data-name={name} data-passive={passive}>
        {pr?.accessibilityLabel ?? "none"}
      </output>
    );
  }
  return {
    requests,
    get mounts() {
      return mounts;
    },
    setState(next: string) {
      state = next;
    },
    holdReplies() {
      replyGate = Latch.makeUnsafe();
    },
    async releaseReplies() {
      await act(async () => {
        replyGate?.openUnsafe();
        replyGate = null;
      });
    },
    badge(name = "sidebar") {
      return container.querySelector(`output[data-name="${name}"]`)?.textContent;
    },
    passive() {
      return container.querySelector("output")?.getAttribute("data-passive");
    },
    async render({
      visible = true,
      value = thread(),
      shared = false,
      activity = "visible",
    }: {
      visible?: boolean;
      value?: EnvironmentThreadShell;
      shared?: boolean;
      activity?: "visible" | "hidden";
    } = {}) {
      await act(async () =>
        root.render(
          <RegistryContext value={registry}>
            <Activity mode={activity}>
              <div hidden={!visible} style={{ width: 320 }}>
                <ThreadPrDemandProvider visible={visible}>
                  <Row value={value} name="sidebar" />
                </ThreadPrDemandProvider>
              </div>
            </Activity>
            {shared ? <Row value={thread({ id: ThreadId.make("shared") })} name="shared" /> : null}
          </RegistryContext>,
        ),
      );
    },
    async advance(ms: number) {
      await act(async () => vi.advanceTimersByTimeAsync(ms));
    },
    async appState(next: string) {
      await act(async () => {
        fixture.active = next;
        for (const listener of fixture.listeners) listener();
      });
    },
    [Symbol.dispose]() {
      act(() => root.unmount());
      registry.dispose();
      expect(fixture.listeners.size).toBe(0);
      vi.useRealTimers();
    },
  };
});

it.effect(
  "releases retained hidden sidebar demand and keeps the badge while reveal revalidates",
  () =>
    Effect.gen(function* () {
      using h = yield* setup();
      yield* Effect.promise(async () => {
        await h.render();
        expect(h.badge()).toBe("#12 pull request open");
        const passive = h.passive();
        expect(h.requests).toHaveLength(1);
        await h.render({ visible: false });
        await h.advance(10_000);
        const afterGrace = h.requests.length;
        await h.advance(180_000);
        expect(h.requests.length - afterGrace).toBe(0);
        expect(h.passive()).toBe(passive);
        h.holdReplies();
        h.setState("closed");
        await h.render();
        expect(h.badge()).toBe("#12 pull request open");
        expect(h.requests.length).toBe(afterGrace + 1);
        expect(h.mounts).toBe(1);
        await h.releaseReplies();
        expect(h.badge()).toBe("#12 pull request closed");
      });
    }),
);

it.effect("does not start a fallback query for a sidebar first mounted hidden", () =>
  Effect.gen(function* () {
    using h = yield* setup();
    yield* Effect.promise(async () => {
      await h.render({ visible: false });
      await h.advance(180_000);
      expect(h.requests).toHaveLength(0);
      expect(h.badge()).toBe("none");
      await h.render();
      expect(h.requests).toHaveLength(1);
      expect(h.badge()).toBe("#12 pull request open");
      expect(h.mounts).toBe(1);
    });
  }),
);

it.effect("keeps a shared visible reader polling while its sidebar reader is hidden", () =>
  Effect.gen(function* () {
    using h = yield* setup();
    yield* Effect.promise(async () => {
      await h.render({ shared: true });
      expect(h.requests).toHaveLength(1);
      await h.render({ visible: false, shared: true });
      await h.advance(180_000);
      expect(h.requests).toHaveLength(4);
      expect(h.badge("shared")).toBe("#12 pull request open");
      h.setState("closed");
      await h.advance(60_000);
      expect(h.requests).toHaveLength(5);
      expect(h.badge("shared")).toBe("#12 pull request closed");
      await h.render({ shared: true });
      expect(h.badge()).toBe("#12 pull request closed");
    });
  }),
);

it.effect.each(["inactive", "background"])("releases sidebar demand while the OS is %s", (state) =>
  Effect.gen(function* () {
    using h = yield* setup();
    yield* Effect.promise(async () => {
      await h.render();
      await h.appState(state);
      await h.advance(10_000);
      const before = h.requests.length;
      await h.advance(180_000);
      expect(h.requests.length - before).toBe(0);
      h.holdReplies();
      await h.appState("active");
      expect(h.badge()).toBe("#12 pull request open");
      expect(h.requests.length - before).toBe(1);
      expect(h.mounts).toBe(1);
    });
  }),
);

it.effect("keeps mounted passive state through an Android-style Activity tab switch", () =>
  Effect.gen(function* () {
    using h = yield* setup();
    yield* Effect.promise(async () => {
      await h.render();
      const passive = h.passive();
      await h.render({ activity: "hidden" });
      await h.advance(10_000);
      const before = h.requests.length;
      await h.advance(180_000);
      expect(h.requests.length - before).toBe(0);
      h.holdReplies();
      await h.render();
      expect(h.badge()).toBe("#12 pull request open");
      expect(h.passive()).toBe(passive);
      expect(h.mounts).toBe(1);
      expect(h.requests.length - before).toBe(1);
    });
  }),
);