sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ Queue/ DeadLetterQueue.test.ts

import * as Cloudflare from "@alchemy.run/cloudflare";
import { CloudflareEnvironment } from "@alchemy.run/cloudflare/CloudflareEnvironment";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as queues from "@distilled.cloud/cloudflare/queues";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import { MinimumLogLevel } from "effect/References";
import * as Schedule from "effect/Schedule";
import * as Stream from "effect/Stream";
import DeadLetterWorker, {
  ByNameQueue,
  ByRefQueue,
  ByResourceQueue,
  DeadLetters,
  type DeadLetterSource,
} from "./fixtures/dead-letter-worker.ts";

const { test } = Test.make({ providers: Cloudflare.providers() });

const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");

class NotYetDeadLettered extends Data.TaggedError("NotYetDeadLettered")<{
  received: string[];
}> {}

const sources: DeadLetterSource[] = ["resource", "ref", "name"];

/**
 * `consumeQueueMessages(queue, { deadLetterQueue })` accepts the dead-letter
 * queue as a Queue resource, a `Queue.ref(...)`, or its name. Each source
 * queue's handler always fails, so its message is dead-lettered and must
 * reach the dead-letter queue's own consumer (#2464).
 */
test.provider(
  "dead-letters by Queue resource, Queue.ref, and queue name reach the dead-letter consumer",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      // The dead-letter queue must be in state for `Queue.ref` to resolve.
      yield* stack.deploy(DeadLetters);

      const out = yield* stack.deploy(
        Effect.gen(function* () {
          const deadLetters = yield* DeadLetters;
          const worker = yield* DeadLetterWorker;
          return {
            url: worker.url,
            deadLetterQueueName: deadLetters.queueName,
            sourceQueueIds: [
              (yield* ByResourceQueue).queueId,
              (yield* ByRefQueue).queueId,
              (yield* ByNameQueue).queueId,
            ],
          };
        }),
      );
      const baseUrl = out.url as string;

      // Out of band: each source queue's consumer names the dead-letter queue.
      const { accountId } = yield* yield* CloudflareEnvironment;
      for (const queueId of out.sourceQueueIds) {
        const consumers = yield* queues.listConsumers
          .items({ accountId, queueId })
          .pipe(Stream.runCollect);
        expect(
          Array.from(consumers).map((consumer) =>
            "deadLetterQueue" in consumer ? consumer.deadLetterQueue : undefined,
          ),
        ).toEqual([out.deadLetterQueueName]);
      }

      for (const source of sources) {
        const res = yield* HttpClient.execute(
          HttpClientRequest.post(`${baseUrl}/send/${source}`).pipe(
            HttpClientRequest.bodyText("poison"),
          ),
        ).pipe(
          Effect.flatMap((res) =>
            res.status === 202
              ? Effect.succeed(res)
              : Effect.fail(new Error(`Worker not ready: ${res.status}`)),
          ),
          Effect.retry({
            schedule: Schedule.max([
              Schedule.min([Schedule.exponential("500 millis"), Schedule.spaced("3 seconds")]),
              Schedule.recurs(10),
            ]),
          }),
        );
        expect(res.status).toBe(202);
      }

      const expected = sources.map((source) => `${source}:poison`);
      const received = yield* HttpClient.get(`${baseUrl}/dead-letters`).pipe(
        Effect.flatMap(HttpClientResponse.filterStatusOk),
        Effect.flatMap((res) => res.json),
        Effect.map((body) => (body as { received: string[] }).received),
        Effect.flatMap((received) =>
          expected.every((entry) => received.includes(entry))
            ? Effect.succeed(received)
            : Effect.fail(new NotYetDeadLettered({ received })),
        ),
        Effect.retry({
          schedule: Schedule.max([
            Schedule.min([Schedule.exponential("500 millis"), Schedule.spaced("4 seconds")]),
            Schedule.recurs(15),
          ]),
        }),
      );
      // Queues deliver at least once, so a message can be recorded twice.
      expect([...new Set(received)].sort()).toEqual([...expected].sort());

      yield* stack.destroy();
    }).pipe(logLevel),
  {
    tags: [
      "provider:cloudflare",
      "provider:cloudflare:queue",
      "provider:cloudflare:worker",
      "live",
    ],
    timeout: 180_000,
  },
);