import { assert, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Queue from "effect/Queue";
import * as Ref from "effect/Ref";
import * as TestClock from "effect/testing/TestClock";
import * as ServerActivation from "../serverActivation.ts";
import * as Scheduler from "./Scheduler.ts";
it.effect("keeps other sources running after a source defects", () =>
Effect.gen(function* () {
const scheduler = yield* Scheduler.Scheduler;
const receipts = yield* Queue.unbounded<string>();
yield* scheduler.register(
"broken",
Queue.offer(receipts, "broken").pipe(Effect.andThen(Effect.die("fixture failure"))),
);
yield* scheduler.register("healthy", Queue.offer(receipts, "healthy").pipe(Effect.asVoid));
for (let tick = 0; tick < 3; tick += 1) {
if (tick > 0) yield* TestClock.adjust("5 seconds");
assert.deepEqual([yield* Queue.take(receipts), yield* Queue.take(receipts)].sort(), [
"broken",
"healthy",
]);
}
}).pipe(Effect.provide(Scheduler.layer)),
);
it.effect("does not overlap slow work or hold up another source", () =>
Effect.gen(function* () {
const scheduler = yield* Scheduler.Scheduler;
const started = yield* Deferred.make<void>();
const release = yield* Deferred.make<void>();
const runs = yield* Ref.make(0);
const receipts = yield* Queue.unbounded<void>();
yield* scheduler.register(
"slow",
Ref.update(runs, (n) => n + 1).pipe(
Effect.andThen(Deferred.succeed(started, undefined)),
Effect.andThen(Deferred.await(release)),
),
);
yield* scheduler.register("healthy", Queue.offer(receipts, undefined).pipe(Effect.asVoid));
yield* Deferred.await(started);
yield* Queue.take(receipts);
yield* TestClock.adjust("10 seconds");
yield* Queue.take(receipts);
yield* Queue.take(receipts);
assert.equal(yield* Ref.get(runs), 1);
yield* Deferred.succeed(release, undefined);
yield* TestClock.adjust("5 seconds");
yield* Queue.take(receipts);
assert.equal(yield* Ref.get(runs), 2);
}).pipe(Effect.provide(Scheduler.layer)),
);
it.effect("unregisters closed sources and interrupts their in-flight work", () =>
Effect.gen(function* () {
const scheduler = yield* Scheduler.Scheduler;
const started = yield* Deferred.make<void>();
const stopped = yield* Deferred.make<void>();
const runs = yield* Ref.make(0);
const registration = yield* Effect.scoped(
scheduler
.register(
"scoped",
Ref.update(runs, (n) => n + 1).pipe(
Effect.andThen(Deferred.succeed(started, undefined)),
Effect.andThen(Effect.never),
Effect.ensuring(Deferred.succeed(stopped, undefined)),
),
)
.pipe(Effect.andThen(Effect.never)),
).pipe(Effect.forkChild);
yield* Deferred.await(started);
yield* Fiber.interrupt(registration);
yield* Deferred.await(stopped);
const receipts = yield* Queue.unbounded<void>();
yield* scheduler.register("remaining", Queue.offer(receipts, undefined).pipe(Effect.asVoid));
yield* Queue.take(receipts);
yield* TestClock.adjust("5 seconds");
yield* Queue.take(receipts);
assert.equal(yield* Ref.get(runs), 1);
}).pipe(Effect.provide(Scheduler.layer)),
);
it.effect("holds due work and the clock until startup recovery activates the server", () =>
Effect.gen(function* () {
const activation = yield* Deferred.make<void>();
const runs = yield* Ref.make(0);
const ran = yield* Deferred.make<void>();
yield* Effect.gen(function* () {
const scheduler = yield* Scheduler.Scheduler;
yield* scheduler.register(
"due",
Ref.update(runs, (n) => n + 1).pipe(Effect.andThen(Deferred.succeed(ran, undefined))),
);
yield* TestClock.adjust("10 seconds");
assert.equal(yield* Ref.get(runs), 0);
yield* Deferred.succeed(activation, undefined);
yield* Deferred.await(ran);
}).pipe(
Effect.provide(Scheduler.layer),
Effect.provideService(ServerActivation.ServerActivation, Deferred.await(activation)),
);
assert.isAtLeast(yield* Ref.get(runs), 1);
}),
);