sailfork / t3code-github / apps/ server/ src/ environment/ staleWhileRevalidate.test.ts

import { assert, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Fiber from "effect/Fiber";
import * as Ref from "effect/Ref";
import * as Scope from "effect/Scope";
import * as TestClock from "effect/testing/TestClock";

import { makeStaleWhileRevalidate } from "./staleWhileRevalidate.ts";

it.effect("computes once, then answers from memory until the ttl lapses", () =>
  Effect.gen(function* () {
    const calls = yield* Ref.make(0);
    const read = yield* makeStaleWhileRevalidate(
      Ref.updateAndGet(calls, (count) => count + 1),
      "60 seconds",
    );

    assert.equal(yield* read, 1);
    yield* TestClock.adjust("59 seconds");
    assert.equal(yield* read, 1);
    assert.equal(yield* Ref.get(calls), 1);
  }).pipe(Effect.scoped),
);

it.effect("serves the stale value while one background refresh replaces it", () =>
  Effect.gen(function* () {
    const calls = yield* Ref.make(0);
    const release = yield* Deferred.make<void>();
    const started = yield* Deferred.make<void>();
    const refreshed = yield* Deferred.make<Fiber.Fiber<unknown, unknown>>();
    const read = yield* makeStaleWhileRevalidate(
      Effect.gen(function* () {
        const call = yield* Ref.updateAndGet(calls, (count) => count + 1);
        if (call > 1) {
          yield* Deferred.succeed(started, undefined);
          yield* Deferred.await(release);
          yield* Deferred.succeed(refreshed, yield* Effect.fiber);
        }
        return call;
      }),
      "60 seconds",
    );

    assert.equal(yield* read, 1);
    yield* TestClock.adjust("61 seconds");
    // The refresh is blocked, yet callers are answered immediately and only
    // one refresh starts however many callers arrive.
    assert.equal(yield* read, 1);
    assert.equal(yield* read, 1);
    yield* Deferred.await(started);
    assert.equal(yield* Ref.get(calls), 2);

    yield* Deferred.succeed(release, undefined);
    yield* Fiber.await(yield* Deferred.await(refreshed));
    assert.equal(yield* read, 2);
  }),
);

it.effect("shares one first scan that an interrupted caller does not cancel", () =>
  Effect.gen(function* () {
    const calls = yield* Ref.make(0);
    const release = yield* Deferred.make<void>();
    const started = yield* Deferred.make<void>();
    const read = yield* makeStaleWhileRevalidate(
      Ref.updateAndGet(calls, (count) => count + 1).pipe(
        Effect.tap(() => Deferred.succeed(started, undefined)),
        Effect.tap(() => Deferred.await(release)),
      ),
      "60 seconds",
    );

    // A connect that times out or disconnects mid-scan leaves the scan running.
    const interrupted = yield* read.pipe(Effect.forkChild);
    yield* Deferred.await(started);
    yield* Fiber.interrupt(interrupted);

    const next = yield* read.pipe(Effect.forkChild);
    yield* Deferred.succeed(release, undefined);
    assert.equal(yield* Fiber.join(next), 1);
    assert.equal(yield* Ref.get(calls), 1);
  }).pipe(Effect.scoped),
);

it.effect("starts over after a failed first scan", () =>
  Effect.gen(function* () {
    const calls = yield* Ref.make(0);
    const read = yield* makeStaleWhileRevalidate(
      Ref.updateAndGet(calls, (count) => count + 1).pipe(
        Effect.filterOrElse(
          (call) => call !== 1,
          () => Effect.die("probe crashed"),
        ),
      ),
      "60 seconds",
    );

    assert.isTrue(Exit.isFailure(yield* Effect.exit(read)));
    assert.equal(yield* read, 2);
  }).pipe(Effect.scoped),
);

it.effect("abandons a hung refresh so a later call can start another", () =>
  Effect.gen(function* () {
    const calls = yield* Ref.make(0);
    const started = yield* Deferred.make<Fiber.Fiber<unknown, unknown>>();
    const interrupted = yield* Deferred.make<void>();
    const refreshed = yield* Deferred.make<Fiber.Fiber<unknown, unknown>>();
    const read = yield* makeStaleWhileRevalidate(
      Ref.updateAndGet(calls, (count) => count + 1).pipe(
        Effect.flatMap((call) =>
          call === 2
            ? Effect.fiber.pipe(
                Effect.flatMap((fiber) => Deferred.succeed(started, fiber)),
                Effect.andThen(Effect.never),
                Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
              )
            : Effect.succeed(call).pipe(
                Effect.tap(() =>
                  call === 3
                    ? Effect.fiber.pipe(
                        Effect.flatMap((fiber) => Deferred.succeed(refreshed, fiber)),
                      )
                    : Effect.void,
                ),
              ),
        ),
      ),
      "60 seconds",
    );

    assert.equal(yield* read, 1);
    yield* TestClock.adjust("61 seconds");
    assert.equal(yield* read, 1);
    yield* Deferred.await(started);
    assert.equal(yield* Ref.get(calls), 2);

    // The hung refresh times out, releasing the claim for the next caller.
    yield* TestClock.adjust("30 seconds");
    yield* Deferred.await(interrupted);
    yield* Fiber.await(yield* Deferred.await(started));
    assert.equal(yield* read, 1);
    yield* Fiber.await(yield* Deferred.await(refreshed));
    assert.equal(yield* Ref.get(calls), 3);
    assert.equal(yield* read, 3);
  }).pipe(Effect.scoped),
);

it.effect("interrupts a background refresh when the owning scope closes", () =>
  Effect.gen(function* () {
    const interrupted = yield* Deferred.make<void>();
    const started = yield* Deferred.make<void>();
    const scope = yield* Scope.make();
    const calls = yield* Ref.make(0);
    const read = yield* makeStaleWhileRevalidate(
      Ref.updateAndGet(calls, (count) => count + 1).pipe(
        Effect.filterOrElse(
          (call) => call === 1,
          () =>
            Deferred.succeed(started, undefined).pipe(
              Effect.andThen(Effect.never),
              Effect.onInterrupt(() => Deferred.succeed(interrupted, undefined)),
            ),
        ),
      ),
      "60 seconds",
    ).pipe(Scope.provide(scope));

    yield* read;
    yield* TestClock.adjust("61 seconds");
    yield* read;
    yield* Deferred.await(started);
    yield* Scope.close(scope, Exit.void);
    yield* Deferred.await(interrupted);
  }),
);