import type { Dispatch, ReactElement, SetStateAction } from "react";import { afterEach, beforeEach, describe, expect, it, vi } from "vite-plus/test";import * as Cause from "effect/Cause";import { AsyncResult } from "effect/unstable/reactivity";import type { EnvironmentId } from "@t3tools/contracts"; const testState = vi.hoisted(() => ({  updateServer: vi.fn(),  toast: vi.fn(),})); const hooks = vi.hoisted(() => {  let cursor = 0;  let slots: unknown[] = [];  const nextIndex = () => cursor++;   return {    beginRender() {      cursor = 0;    },    reset() {      cursor = 0;      slots = [];    },    useEffect() {      nextIndex();    },    useMemoCache(size: number): unknown[] {      const index = nextIndex();      if (!slots[index]) {        slots[index] = Array.from({ length: size }, () => Symbol.for("react.memo_cache_sentinel"));      }      return slots[index] as unknown[];    },    useRef<T>(initialValue: T): { current: T } {      const index = nextIndex();      if (!slots[index]) {        slots[index] = { current: initialValue };      }      return slots[index] as { current: T };    },    useState<T>(initialValue: T | (() => T)): [T, Dispatch<SetStateAction<T>>] {      const index = nextIndex();      if (index >= slots.length) {        slots[index] =          typeof initialValue === "function" ? (initialValue as () => T)() : initialValue;      }      const setValue: Dispatch<SetStateAction<T>> = (nextValue) => {        const previous = slots[index] as T;        slots[index] =          typeof nextValue === "function" ? (nextValue as (value: T) => T)(previous) : nextValue;      };      return [slots[index] as T, setValue];    },  };}); vi.mock("react", async (importOriginal) => {  const actual = await importOriginal<typeof import("react")>();  return {    ...actual,    useEffect: hooks.useEffect,    useRef: hooks.useRef,    useState: hooks.useState,  };}); vi.mock("react/compiler-runtime", () => ({ c: hooks.useMemoCache }));vi.mock("~/hooks/useCopyToClipboard", () => ({  useCopyToClipboard: () => ({ copyToClipboard: vi.fn() }),}));vi.mock("~/state/server", () => ({  serverEnvironment: { updateServer: Symbol("updateServer") },}));vi.mock("~/state/use-atom-command", () => ({  useAtomCommand: () => testState.updateServer,}));vi.mock("./ui/toast", () => ({  toastManager: { add: testState.toast },})); import { ServerUpdateAction } from "./ServerUpdateAction"; type ActionElement = ReactElement<{  readonly disabled?: boolean;  readonly onClick?: () => void;}>; function renderAction(): ActionElement {  hooks.beginRender();  return ServerUpdateAction({    environmentId: "env-test" as EnvironmentId,    serverLabel: "Test server",    selfUpdate: "boot-service",    targetVersion: "0.0.29",  }) as ActionElement;} function deferred<T>() {  let resolve!: (value: T) => void;  const promise = new Promise<T>((complete) => {    resolve = complete;  });  return { promise, resolve };} async function flushPromises(): Promise<void> {  await Promise.resolve();  await Promise.resolve();  await Promise.resolve();  await Promise.resolve();  await Promise.resolve();} describe("ServerUpdateAction", () => {  beforeEach(() => {    vi.useFakeTimers();    hooks.reset();    testState.updateServer.mockReset();    testState.toast.mockReset();  });   afterEach(() => {    vi.useRealTimers();  });   it("starts a fresh reconnect timeout after a long install succeeds", async () => {    const update =      deferred<        ReturnType<typeof AsyncResult.success<{ targetVersion: string; method: "boot-service" }>>      >();    testState.updateServer.mockReturnValue(update.promise);     renderAction().props.onClick?.();    expect(renderAction().props.disabled).toBe(true);     await vi.advanceTimersByTimeAsync(11 * 60_000);    update.resolve(      AsyncResult.success({        targetVersion: "0.0.29",        method: "boot-service",      }),    );    await flushPromises();     // The click-based deadline would have fired by now. Success gets a fresh    // twelve-minute reconnect window, so the action remains disabled.    await vi.advanceTimersByTimeAsync(2 * 60_000);    expect(renderAction().props.disabled).toBe(true);    expect(testState.toast).not.toHaveBeenCalledWith(      expect.objectContaining({ title: "Server update timed out" }),    );     await vi.advanceTimersByTimeAsync(10 * 60_000);    expect(renderAction().props.disabled).not.toBe(true);    expect(testState.toast).toHaveBeenCalledWith(      expect.objectContaining({ title: "Server update timed out" }),    );  });   it("does not let an expired request clear a newer retry", async () => {    const first = deferred<ReturnType<typeof AsyncResult.failure>>();    const retry =      deferred<        ReturnType<typeof AsyncResult.success<{ targetVersion: string; method: "boot-service" }>>      >();    testState.updateServer.mockReturnValueOnce(first.promise).mockReturnValueOnce(retry.promise);     renderAction().props.onClick?.();    await vi.advanceTimersByTimeAsync(12 * 60_000);    expect(renderAction().props.disabled).not.toBe(true);     renderAction().props.onClick?.();    expect(renderAction().props.disabled).toBe(true);     first.resolve(AsyncResult.failure(Cause.fail(new Error("first request failed late"))));    await flushPromises();     expect(renderAction().props.disabled).toBe(true);    expect(testState.updateServer).toHaveBeenCalledTimes(2);     retry.resolve(AsyncResult.success({ targetVersion: "0.0.29", method: "boot-service" }));    await flushPromises();    expect(renderAction().props.disabled).toBe(true);  });   it("quietly releases the action when a restart RPC is interrupted", async () => {    testState.updateServer.mockResolvedValue(AsyncResult.failure(Cause.interrupt()));     renderAction().props.onClick?.();    await flushPromises();     expect(renderAction().props.disabled).not.toBe(true);    expect(testState.toast).not.toHaveBeenCalledWith(      expect.objectContaining({ title: "Server update failed" }),    );  });});