Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

4.0 KB
Raw Blame
import { describe, expect, it } from "@effect/vitest";
import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Schema from "effect/Schema";
import * as TestClock from "effect/testing/TestClock";
import { HttpClient, HttpClientError, HttpClientResponse } from "effect/unstable/http";

import {
  type HttpReadinessFailure,
  waitForHttpReady,
  describeReadinessCause,
} from "./httpReadiness.ts";

class ReadinessTestError extends Schema.TaggedErrorClass<ReadinessTestError>()(
  "ReadinessTestError",
  {
    message: Schema.String,
  },
) {}

describe("HTTP readiness failure classification", () => {
  it.effect("reports typed probe and overall timeouts while preserving diagnostic causes", () =>
    Effect.gen(function* () {
      const started = yield* Deferred.make<void>();
      const failures: HttpReadinessFailure[] = [];

      const client = HttpClient.make(() =>
        Deferred.succeed(started, undefined).pipe(Effect.andThen(Effect.never)),
      );

      const fiber = yield* waitForHttpReady({
        baseUrl: "http://environment.example.test/",
        timeoutMs: 1_000,
        intervalMs: 100,
        probeTimeoutMs: 250,
        makeError: (failure) => {
          failures.push(failure);

          return new ReadinessTestError({ message: failure.kind });
        },
      }).pipe(Effect.flip, Effect.provideService(HttpClient.HttpClient, client), Effect.forkChild);

      yield* Deferred.await(started);
      yield* TestClock.adjust(1_000);
      expect((yield* Fiber.join(fiber)).message).toBe("overall-timeout");
      const probe = failures.find((failure) => failure.kind === "probe-timeout");
      expect(probe?.cause).toEqual({ kind: "probe-timeout", attempt: 1, probeTimeoutMs: 250 });
      const overall = failures.find((failure) => failure.kind === "overall-timeout");
      expect(overall?.cause.baseUrl).toBe("http://environment.example.test/");
      expect(overall?.cause.timeoutMs).toBe(1_000);
      expect(overall?.cause.lastFailure).toBeDefined();
    }).pipe(Effect.provide(TestClock.layer())),
  );

  it.effect("passes request failures through without guessing a timeout from external fields", () =>
    Effect.gen(function* () {
      const failures: HttpReadinessFailure[] = [];
      let attempts = 0;
      const externalCause = { kind: "overall-timeout", timeoutMs: 123 };

      const client = HttpClient.make((request) => {
        attempts += 1;

        return attempts === 1
          ? Effect.fail(
              new HttpClientError.HttpClientError({
                reason: new HttpClientError.TransportError({ request, cause: externalCause }),
              }),
            )
          : Effect.succeed(HttpClientResponse.fromWeb(request, new Response("", { status: 200 })));
      });

      const fiber = yield* waitForHttpReady({
        baseUrl: "http://environment.example.test/",
        intervalMs: 100,
        makeError: (failure) => {
          failures.push(failure);

          return new ReadinessTestError({ message: failure.kind });
        },
      }).pipe(Effect.provideService(HttpClient.HttpClient, client), Effect.forkChild);

      yield* TestClock.adjust(100);
      yield* Fiber.join(fiber);
      expect(failures.map((failure) => failure.kind)).toEqual(["request-failure"]);
      const failure = failures[0];
      expect(failure?.cause).toBeInstanceOf(HttpClientError.HttpClientError);
    }).pipe(Effect.provide(TestClock.layer())),
  );
});

describe("describeReadinessCause", () => {
  it("preserves arbitrary primitive failures and normalizes nested errors", () => {
    const primitives = [
      undefined,
      null,
      "failure",
      1,
      Number.POSITIVE_INFINITY,
      true,
      1n,
      Symbol("failure"),
      () => undefined,
    ];

    for (const cause of primitives) expect(describeReadinessCause(cause)).toBe(cause);
    expect(describeReadinessCause(new Error("outer", { cause: new TypeError("inner") }))).toEqual({
      name: "Error",
      message: "outer",
      cause: { name: "TypeError", message: "inner" },
    });
  });
});