Deflake concurrent health-check coalescing tests (#1844)

Rhys Sullivan committed 2 months ago

Commit 9fa1e9f1 parent 35dba111 file · +40 −15Browse files

Unified · Split

packages/core/sdk/src/connections.test.ts+40−15

   it.effect("concurrent lists past the freshness gate collapse to one probe", () =>
     Effect.gen(function* () {
       const gate = yield* Deferred.make<void>();
+      // Completed on probe entry, AFTER `counters.probes` has been bumped:
+      // awaiting it is the explicit "a probe has started" ordering point (a
+      // wall-clock sleep is a timing assumption that loses under suite load).
+      const entered = yield* Deferred.make<void>();
       const { executor, counters, stamp, persisted } = yield* makeHealthHarness({
-        probe: Deferred.await(gate).pipe(
+        probe: Deferred.succeed(entered, void 0).pipe(
+          Effect.andThen(Deferred.await(gate)),
           Effect.map(() => ({
             status: "healthy" as const,
             checkedAt: Date.now(),
           { concurrency: "unbounded" },
         ),
       );
-      // The probe is held open by the gate, so NOTHING has been persisted yet:
+      // Wait until the first probe has provably started. The gate still holds
-      // every one of the five lists must pass the freshness check and reach
+      // it open, so NOTHING has been persisted: every list that runs must pass
-      // the probe path. Give them real time to get there — the counter then
+      // the freshness check into the probe path, and the in-flight gate must
-      // says how many probes actually started.
+      // keep the count at one — any duplicate a later list starts is caught by
-      yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 25)));
+      // the final count below.
+      yield* Deferred.await(entered);
       expect(counters.probes).toBe(1);
       yield* Deferred.succeed(gate, void 0);
   it.effect("concurrent checks collapse to one credential resolution", () =>
     Effect.gen(function* () {
       const gate = yield* Deferred.make<void>();
+      // Completed by the provider on entry, AFTER the resolve counter has
+      // been bumped: awaiting it is the explicit "a resolution has started"
+      // ordering point. A wall-clock sleep here is a timing assumption — under
+      // parallel suite load the forked checks may not have finished their row
+      // loads yet, and the counter reads 0.
+      const entered = yield* Deferred.make<void>();
       const { executor, counters, stamp, persisted, hooks } = yield* makeHealthHarness();
       // No declared probe spec + an OAuth client on the row routes checkHealth
       // down the credential-only path: the verdict is "the credential
       // behind the same in-flight gate as probing, so concurrent checks must
       // collapse to ONE resolution.
       yield* stamp({ oauth_client: "acme", expires_at: null });
-      hooks.onResolve = Deferred.await(gate);
+      hooks.onResolve = Deferred.succeed(entered, void 0).pipe(
+        Effect.andThen(Deferred.await(gate)),
+      );
       counters.resolves = 0;
       const ref = { owner: "org", integration: INTEG, name: ConnectionName.make("main") } as const;
           concurrency: "unbounded",
         }),
       );
-      // The resolution is held open by the gate, so nothing has been
+      // Wait until the first resolution has provably entered the provider.
-      // persisted: both checks must reach the credential path. Give them real
+      // The gate still holds it open, so nothing has been persisted: while it
-      // time to get there — the counter then says how many resolutions started.
+      // holds, the in-flight gate must keep the count at exactly one — and any
-      yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 25)));
+      // duplicate the second check ever starts is caught by the final count
+      // below.
+      yield* Deferred.await(entered);
       expect(counters.resolves).toBe(1);
       yield* Deferred.succeed(gate, void 0);
     Effect.gen(function* () {
       const counters = { probes: 0 };
       const gate = yield* Deferred.make<void>();
+      // Completed by the probe that brings the count to two: awaiting it is
+      // the explicit "both probes started" ordering point. A collided gate
+      // never completes it (the second check joins the first probe's Deferred
+      // instead of starting its own), which fails the test by timeout.
+      const bothEntered = yield* Deferred.make<void>();
       // Every probe increments the shared counter and then parks on the gate,
       // so both checks are provably in flight at once: nothing is persisted,
       // and a collided gate would let the second check join the first probe's
         checkHealth: () =>
           Effect.suspend(() => {
             counters.probes += 1;
-            return Deferred.await(gate).pipe(
+            const arrived =
+              counters.probes >= 2 ? Deferred.succeed(bothEntered, void 0) : Effect.void;
+            return arrived.pipe(
+              Effect.andThen(Deferred.await(gate)),
               Effect.map(() => ({
                 status: "healthy" as const,
                 checkedAt: Date.now(),
       const checkA = yield* Effect.forkChild(executorA.connections.checkHealth(ref));
       const checkB = yield* Effect.forkChild(executorB.connections.checkHealth(ref));
-      // Give both fibers real time to reach the probe path while the gate
+      // Wait until both probes have provably started; the gate holds every
-      // holds every probe open; the counter then says how many started.
+      // probe open, so both checks are in flight at once and nothing has been
-      yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 25)));
+      // persisted.
+      yield* Deferred.await(bothEntered);
       expect(counters.probes).toBe(2);
       yield* Deferred.succeed(gate, void 0);

Deflake concurrent health-check coalescing tests (#1844)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code