import type { HostPowerSnapshot } 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 Ref from "effect/Ref";
import * as Semaphore from "effect/Semaphore";
import {
commitCollectionControlUpdate,
synchronizeCollectionControlOnStart,
} from "./NativeTelemetryClient.ts";
const basePower: HostPowerSnapshot = {
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"),
};
describe("commitCollectionControlUpdate", () => {
it.effect("retains desired demand and retries unapplied sidecar state", () =>
Effect.gen(function* () {
const initial = {
hostPower: basePower,
liveSubscriberCount: 0,
sampleIntervalMs: 5_000,
};
const desired = yield* Ref.make(initial);
const applied = yield* Ref.make(initial);
const failure = new Error("sidecar write failed");
const receivedStates: Array<readonly [number, number]> = [];
const received = yield* commitCollectionControlUpdate(
desired,
applied,
(current) => ({
...current,
liveSubscriberCount: 1,
sampleIntervalMs: 1_000,
}),
(previous, next) => {
receivedStates.push([previous.sampleIntervalMs, next.sampleIntervalMs]);
return Effect.fail(failure);
},
).pipe(Effect.flip);
expect(received).toBe(failure);
expect(yield* Ref.get(desired)).toEqual({
...initial,
liveSubscriberCount: 1,
sampleIntervalMs: 1_000,
});
expect(yield* Ref.get(applied)).toEqual(initial);
yield* commitCollectionControlUpdate(
desired,
applied,
(current) => current,
(previous, next) => {
receivedStates.push([previous.sampleIntervalMs, next.sampleIntervalMs]);
return Effect.void;
},
);
expect(receivedStates).toEqual([
[5_000, 1_000],
[5_000, 1_000],
]);
expect(yield* Ref.get(applied)).toEqual(yield* Ref.get(desired));
}),
);
it.effect("serializes startup synchronization with runtime control updates", () =>
Effect.gen(function* () {
const initial = {
hostPower: basePower,
liveSubscriberCount: 0,
sampleIntervalMs: 5_000,
};
const desired = yield* Ref.make(initial);
const applied = yield* Ref.make(initial);
const ready = yield* Ref.make(false);
const mutex = yield* Semaphore.make(1);
const startupApplying = yield* Deferred.make<void>();
const releaseStartup = yield* Deferred.make<void>();
const appliedIntervals: Array<number> = [];
const startupFiber = yield* synchronizeCollectionControlOnStart(
mutex,
desired,
applied,
(control) =>
Effect.sync(() => {
appliedIntervals.push(control.sampleIntervalMs);
}).pipe(
Effect.andThen(Deferred.succeed(startupApplying, undefined)),
Effect.andThen(Deferred.await(releaseStartup)),
Effect.asVoid,
),
Ref.set(ready, true),
).pipe(Effect.forkChild);
yield* Deferred.await(startupApplying);
const updateFiber = yield* mutex
.withPermits(1)(
commitCollectionControlUpdate(
desired,
applied,
(current) => ({
...current,
liveSubscriberCount: 1,
sampleIntervalMs: 1_000,
}),
(_previous, next) =>
Effect.gen(function* () {
expect(yield* Ref.get(ready)).toBe(true);
appliedIntervals.push(next.sampleIntervalMs);
}),
),
)
.pipe(Effect.forkChild);
yield* Effect.yieldNow;
expect(yield* Ref.get(desired)).toEqual(initial);
yield* Deferred.succeed(releaseStartup, undefined);
yield* Fiber.join(startupFiber);
yield* Fiber.join(updateFiber);
expect(appliedIntervals).toEqual([5_000, 1_000]);
expect(yield* Ref.get(applied)).toEqual(yield* Ref.get(desired));
}),
);
});