sailfork / t3code-github / apps/ server/ src/ background/ HostPowerMonitor.test.ts

import type { DesktopHostTelemetrySnapshot } from "@t3tools/contracts";
import { describe, expect, it } from "@effect/vitest";
import * as DateTime from "effect/DateTime";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as PubSub from "effect/PubSub";
import * as Stream from "effect/Stream";

import * as DesktopTelemetryReceiver from "../resourceTelemetry/DesktopTelemetryReceiver.ts";
import * as HostPowerMonitor from "./HostPowerMonitor.ts";

describe("HostPowerMonitor", () => {
  it.effect("publishes semantic power changes without idle-time heartbeat churn", () =>
    Effect.gen(function* () {
      const monitor = yield* HostPowerMonitor.make();
      const initial = {
        source: "electron-main",
        idle: "false",
        idleSeconds: 0,
        locked: "false",
        suspended: false,
        onBattery: "false",
        lowPowerMode: "unknown",
        thermalState: "nominal",
        stale: false,
        updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:00.000Z"),
      } as const;
      yield* monitor.report(initial);

      const nextChange = yield* Stream.runHead(monitor.streamChanges).pipe(Effect.forkChild);
      yield* Effect.yieldNow;
      yield* monitor.report({
        ...initial,
        idleSeconds: 1,
        updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:01.000Z"),
      });
      yield* monitor.report({
        ...initial,
        locked: "true",
        updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:02.000Z"),
      });

      expect(Option.getOrThrow(yield* Fiber.join(nextChange)).locked).toBe("true");
    }),
  );

  it.effect("ignores host power reports older than the latest accepted snapshot", () =>
    Effect.gen(function* () {
      const initial = {
        source: "electron-main",
        idle: "false",
        idleSeconds: 0,
        locked: "false",
        suspended: false,
        onBattery: "false",
        lowPowerMode: "false",
        thermalState: "nominal",
        stale: false,
        updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:00.000Z"),
      } as const;
      const monitor = yield* HostPowerMonitor.make(initial);
      const latestAt = DateTime.makeUnsafe("2026-06-17T12:00:02.000Z");
      yield* monitor.report({
        ...initial,
        locked: "true",
        updatedAt: latestAt,
      });
      yield* monitor.report({
        ...initial,
        updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:01.000Z"),
      });

      const snapshot = yield* monitor.snapshot;
      expect(snapshot.locked).toBe("true");
      expect(DateTime.toEpochMillis(snapshot.updatedAt)).toBe(DateTime.toEpochMillis(latestAt));
    }),
  );

  it.effect(
    "subscribes before reading the desktop snapshot so concurrent power updates survive",
    () =>
      Effect.gen(function* () {
        const sampledAt = DateTime.makeUnsafe("2026-06-17T12:00:00.000Z");
        const initial: DesktopHostTelemetrySnapshot = {
          version: 1,
          type: "desktopTelemetry",
          sequence: 1,
          sampledAtUnixMs: DateTime.toEpochMillis(sampledAt),
          electronPid: 100,
          power: {
            source: "electron-main",
            idle: "false",
            idleSeconds: 0,
            locked: "false",
            suspended: false,
            onBattery: "false",
            lowPowerMode: "unknown",
            thermalState: "nominal",
            stale: false,
            updatedAt: sampledAt,
          },
          speedLimitPercent: Option.none(),
          electronProcesses: [],
        };
        const updated: DesktopHostTelemetrySnapshot = {
          ...initial,
          sequence: 2,
          power: {
            ...initial.power,
            onBattery: "true",
            updatedAt: DateTime.makeUnsafe("2026-06-17T12:00:01.000Z"),
          },
        };
        const desktopChanges = yield* PubSub.sliding<DesktopHostTelemetrySnapshot>(1);
        const changeApplied = yield* Deferred.make<void>();
        const layerReceiver = DesktopTelemetryReceiver.layerTest({
          latest: Effect.succeedSome(initial),
          changes: Stream.empty,
          subscribe: Effect.gen(function* () {
            const subscription = yield* PubSub.subscribe(desktopChanges);
            yield* PubSub.publish(desktopChanges, updated);
            return {
              latest: Option.some(initial),
              changes: Stream.fromSubscription(subscription).pipe(
                Stream.take(1),
                Stream.ensuring(Deferred.succeed(changeApplied, undefined)),
              ),
            };
          }),
        });
        const layer = HostPowerMonitor.layer.pipe(Layer.provide(layerReceiver));

        yield* Effect.gen(function* () {
          const monitor = yield* HostPowerMonitor.HostPowerMonitor;
          yield* Deferred.await(changeApplied);
          expect((yield* monitor.snapshot).onBattery).toBe("true");
        }).pipe(Effect.provide(layer));
      }),
  );
});