sailfork / t3code-github / apps/ web/ src/ lib/ resourceTelemetryState.browser.test.tsx

import { RegistryContext } from "@effect/atom-react";
import {
  EnvironmentId,
  type ResourceTelemetryHistory,
  type ResourceTelemetrySnapshot,
} from "@t3tools/contracts";
import * as Cause from "effect/Cause";
import * as DateTime from "effect/DateTime";
import * as Schema from "effect/Schema";
import * as Effect from "effect/Effect";
import * as Option from "effect/Option";
import { AsyncResult, Atom, AtomRegistry } from "effect/reactivity";
import type { ReactNode } from "react";
import { describe, expect, it, vi } from "vite-plus/test";

import { act, render } from "../../test/render";

const monitor = vi.hoisted(() => ({
  telemetry:
    vi.fn<
      (args: {
        environmentId: EnvironmentId;
      }) => Atom.Atom<AsyncResult.AsyncResult<ResourceTelemetrySnapshot, MonitorError>>
    >(),
  history:
    vi.fn<
      (args: {
        environmentId: EnvironmentId;
        input: { windowMs: number; bucketMs: number };
      }) => Atom.Atom<AsyncResult.AsyncResult<ResourceTelemetryHistory, MonitorError>>
    >(),
  retry: vi.fn(),
}));

vi.mock("../components/settings/settingsLayout", () => ({
  SettingsSection: ({
    title,
    headerAction,
    children,
  }: {
    title: string;
    headerAction?: ReactNode;
    children: ReactNode;
  }) => (
    <section aria-label={title}>
      {headerAction}
      {children}
    </section>
  ),
}));

vi.mock("../state/environments", () => ({ usePrimaryEnvironment: () => null }));
vi.mock("../state/session", () => ({
  readEnvironmentScope: () => true,
  useEnvironmentScope: () => true,
}));
vi.mock("../state/server", () => ({
  serverEnvironment: {
    resourceTelemetry: monitor.telemetry,
    resourceTelemetryHistory: monitor.history,
  },
}));
vi.mock("../state/use-atom-command", () => ({ useAtomCommand: () => monitor.retry }));

import { ResourceTelemetryDiagnostics } from "../components/settings/ResourceTelemetryDiagnostics";

class MonitorError extends Schema.TaggedError<MonitorError>()("MonitorError", {
  message: Schema.String,
}) {}

const environmentId = EnvironmentId.make("remote");
const startError = "The resource monitor is not available.";
const historyError = "Resource history could not start.";

function setup({ retryFails = false, holdRetry = false } = {}) {
  const readAt = DateTime.makeUnsafe(0);
  const aggregate = {
    processCount: 0,
    currentCpuPercent: 0,
    cpuTimeMs: 0,
    currentRssBytes: 0,
    peakRssBytes: 0,
    ioReadBytes: 0,
    ioWriteBytes: 0,
    ioReadBytesPerSecond: 0,
    ioWriteBytesPerSecond: 0,
    processStarts: 0,
    processExits: 0,
  };
  const source = {
    status: "healthy" as const,
    lastSampleAt: Option.some(readAt),
    lastError: Option.none<string>(),
  };
  const snapshot: ResourceTelemetrySnapshot = {
    readAt,
    sampleIntervalMs: 1000,
    processes: [],
    groups: { backend: aggregate, electron: aggregate, monitor: aggregate, allT3: aggregate },
    power: {
      source: "unknown",
      idle: "unknown",
      idleSeconds: null,
      locked: "unknown",
      suspended: false,
      onBattery: "unknown",
      lowPowerMode: "unknown",
      thermalState: "unknown",
      stale: false,
      updatedAt: readAt,
    },
    speedLimitPercent: Option.none(),
    attribution: { readAt, entries: [] },
    health: {
      native: source,
      desktop: source,
      sidecarVersion: Option.none(),
      sidecarPid: Option.none(),
      restartCount: 1,
      collectionDurationMicros: 0,
      scannedProcessCount: 0,
      retainedProcessCount: 0,
      inaccessibleProcessCount: 0,
    },
  };
  const history: ResourceTelemetryHistory = {
    readAt,
    windowMs: 900000,
    bucketMs: 30000,
    sampleIntervalMs: 1000,
    retainedSampleCount: 0,
    buckets: [],
    topProcesses: [],
    health: snapshot.health,
  };
  let running = false;
  const telemetryQueries = Atom.family((_environmentId: EnvironmentId) =>
    Atom.make(
      Effect.suspend(() =>
        running ? Effect.succeed(snapshot) : Effect.fail(new MonitorError({ message: startError })),
      ),
    ).pipe(Atom.keepAlive),
  );
  monitor.telemetry.mockReset();
  monitor.telemetry.mockImplementation(({ environmentId }) => telemetryQueries(environmentId));
  const historyReads = vi.fn<(key: string) => void>();
  const historyQueries = Atom.family((key: string) =>
    Atom.make(
      Effect.suspend(() => {
        historyReads(key);
        return running
          ? Effect.succeed(history)
          : Effect.fail(new MonitorError({ message: historyError }));
      }),
    ).pipe(Atom.keepAlive),
  );
  monitor.history.mockReset();
  monitor.history.mockImplementation(({ environmentId, input }) =>
    historyQueries(`${environmentId}:${input.windowMs}`),
  );
  let releaseRetry = () => {};
  const retryRelease = new Promise<void>((resolve) => {
    releaseRetry = resolve;
  });
  monitor.retry.mockReset();
  monitor.retry.mockImplementation(async () => {
    if (holdRetry) await retryRelease;
    if (retryFails)
      return AsyncResult.failure(Cause.fail(new MonitorError({ message: "Restart failed." })));
    running = true;
    return AsyncResult.success({ accepted: true, snapshot });
  });
  const registry = AtomRegistry.make();
  return {
    registry,
    historyQueries,
    historyReads,
    releaseRetry,
    [Symbol.dispose]: () => registry.dispose(),
  };
}

describe("resource monitor retry", () => {
  it("clears the settings and history errors after a successful retry without remounting", async () => {
    using fixture = setup();
    await using screen = await render(
      <RegistryContext.Provider value={fixture.registry}>
        <ResourceTelemetryDiagnostics environmentId={environmentId} />
      </RegistryContext.Provider>,
    );
    await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
    await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();

    await screen.getByRole("button", { name: "Retry monitor" }).click();

    await expect.element(screen.getByText(startError, { exact: true })).not.toBeInTheDocument();
    await expect.element(screen.getByText(historyError, { exact: true })).not.toBeInTheDocument();
    await expect.element(screen.getByText("Native healthy", { exact: true })).toBeVisible();
    await expect
      .element(screen.getByRole("button", { name: "Retry monitor" }))
      .not.toBeInTheDocument();
  });

  it.each([false, true])(
    "refreshes the changed history window only in the retry environment (switch environment: %s)",
    async (switchEnvironment) => {
      using fixture = setup({ holdRetry: true });
      const view = (selectedEnvironment: EnvironmentId) => (
        <RegistryContext.Provider value={fixture.registry}>
          <ResourceTelemetryDiagnostics environmentId={selectedEnvironment} />
        </RegistryContext.Provider>
      );
      await using screen = await render(view(environmentId));
      await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
      await screen.getByRole("button", { name: "Retry monitor" }).click();
      await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeDisabled();
      const selectedEnvironment = switchEnvironment ? EnvironmentId.make("other") : environmentId;
      if (switchEnvironment) await screen.rerender(view(selectedEnvironment));
      await screen.getByRole("button", { name: "5m", exact: true }).click();
      await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
      const selectedKey = `${selectedEnvironment}:300000`;
      expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Failure");
      fixture.historyReads.mockClear();

      await act(() => fixture.releaseRetry());

      if (switchEnvironment) {
        await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeEnabled();
        await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
        expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Failure");
        expect(fixture.historyReads).not.toHaveBeenCalled();
      } else {
        await expect.element(screen.getByText(startError, { exact: true })).not.toBeInTheDocument();
        await expect
          .element(screen.getByText(historyError, { exact: true }))
          .not.toBeInTheDocument();
        expect(fixture.registry.get(fixture.historyQueries(selectedKey))._tag).toBe("Success");
        expect(fixture.historyReads.mock.calls.map(([key]) => key)).toEqual([selectedKey]);
        await screen.getByRole("button", { name: "15m", exact: true }).click();
        await expect
          .element(screen.getByText(historyError, { exact: true }))
          .not.toBeInTheDocument();
      }
      expect(fixture.registry.get(fixture.historyQueries(`${environmentId}:900000`))._tag).toBe(
        "Success",
      );
      expect(monitor.retry).toHaveBeenCalledExactlyOnceWith({ environmentId, input: {} });
    },
  );

  it("keeps the failed monitor and history errors visible when retry fails", async () => {
    using fixture = setup({ retryFails: true });
    await using screen = await render(
      <RegistryContext.Provider value={fixture.registry}>
        <ResourceTelemetryDiagnostics environmentId={environmentId} />
      </RegistryContext.Provider>,
    );
    await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
    await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();

    await screen.getByRole("button", { name: "Retry monitor" }).click();

    await expect.element(screen.getByRole("button", { name: "Retry monitor" })).toBeEnabled();
    expect(monitor.retry).toHaveBeenCalledExactlyOnceWith({ environmentId, input: {} });
    await expect.element(screen.getByText(startError, { exact: true })).toBeVisible();
    await expect.element(screen.getByText(historyError, { exact: true })).toBeVisible();
  });
});