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));
}),
);
});