sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ Cloudflare/ Workers/ HttpServer.test.ts

import * as Cloudflare from "@alchemy.run/cloudflare";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as Alchemy from "alchemy";
import * as Effect from "effect/Effect";
import * as Cookies from "effect/http/Cookies";
import * as HttpClient from "effect/http/HttpClient";
import * as HttpClientRequest from "effect/http/HttpClientRequest";
import * as HttpClientResponse from "effect/http/HttpClientResponse";
import * as ChildProcess from "effect/process/ChildProcess";
import * as Schedule from "effect/Schedule";
import * as Socket from "effect/socket/Socket";
import * as Stream from "effect/Stream";
import { expectUrlContains } from "../Utils/Http.ts";
import { requestWorker, waitUntilStable } from "../Utils/WorkerRequest.ts";
import HttpServerWorker, { readyMarker, sensitiveContext } from "./fixtures/http-server-worker.ts";
import RawResponseWorker from "./fixtures/raw-response/worker.ts";
import NoSignalWorker from "./fixtures/request-abort/no-signal-worker.ts";
import RequestAbortWorker from "./fixtures/request-abort/worker.ts";

const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
  providers: Cloudflare.providers(),
});

const Stack = Alchemy.Stack(
  "WorkersHttpServerStack",
  { providers: Cloudflare.providers(), state: Cloudflare.state() },
  Effect.gen(function* () {
    const worker = yield* HttpServerWorker;
    return { url: worker.url.as<string>() };
  }),
);

const stack = beforeAll(deploy(Stack));
afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack));

/**
 * GET `url` until it serves `status` with an empty body. Both error routes
 * respond with no body, which also distinguishes them from the workers.dev
 * placeholder page (a 404 *with* a body) during edge propagation.
 */
const getEmptyResponse = (url: string, status: number) =>
  Effect.gen(function* () {
    const client = yield* HttpClient.HttpClient;
    const response = yield* client.get(url);
    const body = yield* response.text;
    if (response.status !== status || body !== "") {
      return yield* Effect.fail(
        new Error(
          `expected empty ${status} from ${url}, got ${response.status}: ${body.slice(0, 160)}`,
        ),
      );
    }
    return response;
  }).pipe(Effect.retry({ schedule: Schedule.spaced("1500 millis"), times: 20 }));

test(
  "a Respondable defect keeps its intended response over the wire",
  Effect.gen(function* () {
    const { url } = yield* stack;
    yield* expectUrlContains(url, readyMarker);

    yield* getEmptyResponse(`${url}/missing`, 404);
  }),
  {
    tags: ["provider:cloudflare", "provider:cloudflare:worker", "live"],
    timeout: 180_000,
  },
);

test(
  "a failed handler responds 500 without exposing the cause",
  Effect.gen(function* () {
    const { url } = yield* stack;
    yield* expectUrlContains(url, readyMarker);

    const response = yield* getEmptyResponse(`${url}/boom`, 500);
    const wireResponse = JSON.stringify(response.headers);
    for (const sensitiveValue of sensitiveContext) {
      expect(wireResponse).not.toContain(sensitiveValue);
    }
  }),
  {
    tags: ["provider:cloudflare", "provider:cloudflare:worker", "live"],
    timeout: 180_000,
  },
);

// `HttpServerResponse.fromWeb` responses take Effect-level status, headers and
// cookies on GET and HEAD, bodyless responses (HEAD, 204/205/304) still close
// their request scope, and a raw 101 upgrade passes through untouched.
for (const dev of [false, true]) {
  const { test: providerTest } = Test.make({ providers: Cloudflare.providers(), dev });

  providerTest.provider(
    `web responses over HTTP (${dev ? "local" : "live"})`,
    (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();
        const worker = yield* stack.deploy(RawResponseWorker);
        const client = yield* HttpClient.HttpClient;
        const ready = yield* client.get(`${worker.url!}/ready`).pipe(
          Effect.flatMap((response) => response.text),
          Effect.retry({ schedule: Schedule.spaced("1 second"), times: 8 }),
          Effect.repeat({
            schedule: Schedule.spaced("1 second"),
            times: 8,
            until: (body) => body === "raw-response:ready",
          }),
        );
        expect(ready).toBe("raw-response:ready");

        for (const path of [
          "/status",
          "/native",
          "/constructed-header",
          "/explicit-status",
          "/cookie",
          "/stream",
          "/no-content",
          "/reset-content",
          "/not-modified",
        ]) {
          for (const method of ["GET", "HEAD"] as const) {
            const url = `${worker.url!}${path}`;
            // Routes can propagate after /ready starts serving.
            const { response, body } = yield* Effect.gen(function* () {
              const response = yield* method === "GET" ? client.get(url) : client.head(url);
              return { response, body: yield* response.text };
            }).pipe(
              Effect.repeat({
                schedule: Schedule.spaced("1 second"),
                times: 8,
                until: ({ response }) =>
                  response.status !== 404 || response.headers["x-native"] !== undefined,
              }),
            );
            const mutated = path === "/status" || path === "/stream";
            const status =
              path === "/no-content"
                ? 204
                : path === "/reset-content"
                  ? 205
                  : path === "/not-modified"
                    ? 304
                    : path === "/explicit-status"
                      ? 201
                      : mutated
                        ? 418
                        : 202;
            expect(response.status).toBe(status);
            expect(response.headers["x-native"]).toBe(
              mutated ? "effect" : path === "/constructed-header" ? "constructed" : "native",
            );
            expect(response.headers["x-remove"]).toBe(mutated ? undefined : "native");
            if (mutated) {
              expect(response.headers["x-observed-status"]).toBe("202");
              expect(response.headers["x-observed-native"]).toBe("native");
            }
            expect(Cookies.toRecord(response.cookies)).toEqual(
              path === "/cookie" ? { a: "1", b: "2", session: "abc" } : { a: "1", b: "2" },
            );
            expect(body).toBe(
              method === "HEAD" || [204, 205, 304].includes(status)
                ? ""
                : path === "/stream"
                  ? "raw-response:streamed"
                  : "raw-response:body",
            );
            const finalized = yield* client
              .get(`${worker.url!}/finalized?entry=${encodeURIComponent(`${method}:${path}`)}`)
              .pipe(
                Effect.flatMap((response) => response.text),
                Effect.repeat({
                  schedule: Schedule.spaced("1 second"),
                  times: 8,
                  until: (body) => body === "true",
                }),
              );
            expect({ request: `${method} ${path}`, finalized }).toEqual({
              request: `${method} ${path}`,
              finalized: "true",
            });
          }
        }

        yield* Effect.gen(function* () {
          const socket = yield* Socket.makeWebSocket(
            `${worker.url!.replace(/^http/, "ws")}/websocket`,
          );
          const reader = yield* socket.reader;
          const writer = yield* socket.writer;
          yield* writer.write("response-upgrade");
          expect(yield* reader.pull).toEqual(["response-upgrade"]);
        }).pipe(Effect.scoped, Effect.provide(Socket.layerWebSocketConstructorGlobal));
        yield* stack.destroy();
      }),
    {
      tags: ["provider:cloudflare", "provider:cloudflare:worker", ...(dev ? ["local"] : ["live"])],
    },
  );
}

/**
 * Holds a raw HTTP/1.1 request open over `openssl s_client`. Closing the
 * scope SIGKILLs the client, so the kernel drops the connection without a TLS
 * `close_notify`, the way a client that went away does. (A `close_notify`
 * reads as an HTTP half-close, which Cloudflare keeps serving, and Bun's
 * `node:tls` sends one even from `destroy()`.)
 */
const rawRequest = (host: string, request: string) =>
  ChildProcess.make(
    "openssl",
    ["s_client", "-connect", `${host}:443`, "-servername", host, "-alpn", "http/1.1", "-quiet"],
    {
      // `-quiet` keeps the connection open after stdin ends.
      stdin: Stream.make(request).pipe(Stream.encodeText),
      stdout: "ignore",
      stderr: "ignore",
      killSignal: "SIGKILL",
    },
  );

/**
 * Deploy `worker`, send `/slow` over a raw connection, kill the client once
 * the handler has started, and return what the handler recorded within
 * `polls` seconds afterwards.
 */
const disconnectMidRequest = (worker: { url: string | undefined }, polls: number) =>
  Effect.gen(function* () {
    // `/ready` calls the journal Durable Object, whose first calls after a
    // deploy can fail with an opaque "internal error".
    yield* waitUntilStable(
      `request-abort Worker at ${worker.url}`,
      requestWorker(HttpClientRequest.get(`${worker.url!}/ready`)).pipe(
        Effect.flatMap((response) => response.text),
        Effect.map((body) => body === "request-abort:ready"),
        Effect.catch(() => Effect.succeed(false)),
      ),
      { timeout: "60 seconds" },
    );
    const id = yield* Effect.sync(() => crypto.randomUUID());
    const events = requestWorker(HttpClientRequest.get(`${worker.url!}/events?id=${id}`)).pipe(
      Effect.flatMap(HttpClientResponse.filterStatusOk),
      Effect.flatMap((response) => response.json),
      Effect.map((body) => body as string[]),
      Effect.retry({ schedule: Schedule.spaced("1 second"), times: 10 }),
    );

    const host = yield* Effect.sync(() => new URL(worker.url!).host);
    yield* Effect.scoped(
      Effect.gen(function* () {
        yield* rawRequest(host, `GET /slow?id=${id} HTTP/1.1\r\nHost: ${host}\r\n\r\n`);
        yield* events.pipe(
          Effect.repeat({
            schedule: Schedule.spaced("500 millis"),
            times: 30,
            until: (events) => events.includes("started"),
          }),
        );
      }),
    );

    return yield* events.pipe(
      Effect.repeat({
        schedule: Schedule.spaced("1 second"),
        times: polls,
        until: (events) => events.some((event) => event.startsWith("released:")),
      }),
    );
  });

// A client that disconnects interrupts the handler, so its resources are
// released as an interruption instead of staying open for nobody. Live only:
// local workerd does not fire `request.signal` when the client disconnects.
test.provider(
  "a client disconnect interrupts the handler",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const worker = yield* stack.deploy(RequestAbortWorker);
      const events = yield* disconnectMidRequest(worker, 20);
      expect(events).toEqual(["started", "released:interrupt"]);
      yield* stack.destroy();
    }),
  { timeout: 120_000 },
);

// Without `enable_request_signal`, Cloudflare cancels the request when the
// client disconnects and the handler's finalizers never run.
test.provider(
  "without enable_request_signal a client disconnect skips the handler's release",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();
      const worker = yield* stack.deploy(NoSignalWorker);
      const events = yield* disconnectMidRequest(worker, 10);
      expect(events).toEqual(["started"]);
      yield* stack.destroy();
    }),
  { timeout: 120_000 },
);