sailfork / t3code-github / .repos/ effect/ packages/ platform/ node/ test/ NodeHttpClient.test.ts

import { NodeHttpServer } from "@effect/platform-node"
import * as NodeClient from "@effect/platform-node/NodeHttpClient"
import Undici from "@effect/platform-node/Undici"
import { assert, describe, expect, it } from "@effect/vitest"
import { Struct } from "effect"
import * as Context from "effect/Context"
import * as Deferred from "effect/Deferred"
import * as Effect from "effect/Effect"
import * as Fiber from "effect/Fiber"
import { flow } from "effect/Function"
import {
  FetchHttpClient,
  HttpBody,
  HttpClient,
  HttpClientRequest,
  HttpClientResponse,
  HttpRouter,
  HttpServer,
  HttpServerRequest,
  HttpServerResponse,
  Multipart,
  UrlParams
} from "effect/http"
import * as Layer from "effect/Layer"
import * as Schedule from "effect/Schedule"
import * as Schema from "effect/Schema"
import type * as Socket from "effect/socket/Socket"
import * as Stream from "effect/Stream"
import { mkdtempSync, openAsBlob, rmSync, truncateSync, writeFileSync } from "node:fs"
import * as Http from "node:http"
import type * as Net from "node:net"
import { tmpdir } from "node:os"
import { join } from "node:path"

const Todo = Schema.Struct({
  userId: Schema.Number,
  id: Schema.Number,
  title: Schema.String,
  completed: Schema.Boolean
})
const TodoWithoutId = Schema.Struct({
  ...Struct.omit(Todo.fields, ["id"])
})
const largeResponseBody = "a".repeat(10 * 1024 * 1024)
const responseBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47])
const formDataResponses = [
  {
    name: "URL-encoded",
    path: "/form/url-encoded",
    contentType: "application/x-www-form-urlencoded",
    body: "tag=one&tag=two"
  },
  {
    name: "multipart",
    path: "/form/multipart",
    contentType: "multipart/form-data; boundary=effect-test",
    body: [
      "--effect-test",
      "Content-Disposition: form-data; name=\"tag\"",
      "",
      "one",
      "--effect-test",
      "Content-Disposition: form-data; name=\"tag\"",
      "",
      "two",
      "--effect-test--",
      ""
    ].join("\r\n")
  }
] as const

const makeLocalServerClient = Effect.gen(function*() {
  const client = yield* HttpClient.HttpClient
  const createTodo = (todo: typeof TodoWithoutId.Type) =>
    HttpClientRequest.post("/todos").pipe(
      HttpClientRequest.schemaBodyJson(TodoWithoutId)(todo),
      Effect.flatMap(client.execute),
      Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo))
    )
  return {
    client,
    createTodo
  } as const
})
interface LocalServerClient extends Effect.Success<typeof makeLocalServerClient> {}
const LocalServerClient = Context.Service<LocalServerClient>("test/LocalServerClient")
const LocalServerClientLayer = Layer.effect(LocalServerClient)(makeLocalServerClient)
const LocalServerRoutes = HttpRouter.serve(HttpRouter.addAll([
  HttpRouter.route(
    "GET",
    "/todos/1",
    Effect.succeed(HttpServerResponse.jsonUnsafe({
      userId: 1,
      id: 1,
      title: "test",
      completed: false
    }))
  ),
  HttpRouter.route(
    "POST",
    "/todos",
    Effect.gen(function*() {
      const todo = yield* HttpServerRequest.schemaBodyJson(TodoWithoutId)
      return HttpServerResponse.jsonUnsafe({ ...todo, id: 201 })
    })
  ),
  HttpRouter.route("GET", "/text", Effect.succeed(HttpServerResponse.text("test"))),
  HttpRouter.route(
    "QUERY",
    "/search",
    Effect.gen(function*() {
      const request = yield* HttpServerRequest.HttpServerRequest
      return HttpServerResponse.jsonUnsafe({
        method: request.method,
        contentType: request.headers["content-type"],
        body: yield* request.text
      })
    })
  ),
  HttpRouter.route("GET", "/bytes", Effect.succeed(HttpServerResponse.uint8Array(responseBytes))),
  HttpRouter.route(
    "POST",
    "/multipart",
    Effect.gen(function*() {
      const request = yield* HttpServerRequest.HttpServerRequest
      const parts = yield* request.multipartStream.pipe(
        Stream.mapEffect((part) =>
          Effect.gen(function*() {
            if (Multipart.isField(part)) {
              return { key: part.key, value: part.value }
            }
            const content = yield* part.contentEffect
            return {
              key: part.key,
              name: part.name,
              contentType: part.contentType,
              content: new TextDecoder().decode(content)
            }
          })
        ),
        Stream.runCollect
      )
      return HttpServerResponse.jsonUnsafe(parts)
    })
  ),
  HttpRouter.route(
    "POST",
    "/bom-json",
    Effect.gen(function*() {
      const request = yield* HttpServerRequest.HttpServerRequest
      return HttpServerResponse.text(`\uFEFF${JSON.stringify(yield* request.json)}`, {
        contentType: "application/json"
      })
    })
  ),
  HttpRouter.route(
    "POST",
    "/question-form",
    Effect.gen(function*() {
      const request = yield* HttpServerRequest.HttpServerRequest
      return HttpServerResponse.text(`?${UrlParams.toString(yield* request.urlParamsBody)}`, {
        contentType: "application/x-www-form-urlencoded"
      })
    })
  ),
  ...formDataResponses.map(({ body, contentType, path }) =>
    HttpRouter.route("GET", path, Effect.succeed(HttpServerResponse.text(body, { contentType })))
  ),
  HttpRouter.route("GET", "/large", Effect.succeed(HttpServerResponse.text(largeResponseBody))),
  HttpRouter.route("GET", "/hang", Effect.never),
  HttpRouter.route(
    "GET",
    "/redirect",
    Effect.succeed(HttpServerResponse.text("redirecting", {
      status: 302,
      headers: { location: "/redirected" }
    }))
  ),
  HttpRouter.route("GET", "/redirected", Effect.succeed(HttpServerResponse.text("redirected"))),
  HttpRouter.route("HEAD", "/todos", Effect.succeed(HttpServerResponse.empty({ status: 200 }))),
  HttpRouter.route(
    "POST",
    "/upgrade",
    Effect.succeed(HttpServerResponse.jsonUnsafe({ message: "unauthorized" }, { status: 401 }))
  )
]))
;[
  {
    name: "fetch",
    layer: NodeClient.layerFetch
  },
  {
    name: "node:http",
    layer: NodeClient.layerNodeHttp
  },
  {
    name: "undici",
    layer: NodeClient.layerUndici
  }
].forEach(({ layer, name }) => {
  const layerTest = HttpServer.layerTestClient.pipe(
    Layer.provide(layer),
    Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
  )
  const localServerTestLayer = Layer.merge(LocalServerClientLayer, LocalServerRoutes).pipe(
    Layer.provideMerge(layerTest)
  )

  describe(`NodeHttpClient - ${name}`, () => {
    it.effect("text", () =>
      Effect.gen(function*() {
        const response = yield* HttpClient.get("/text?existing=1", {
          urlParams: { value: "a#b" },
          hash: "fragment"
        })
        const url = new URL(response.url)
        assert.strictEqual(url.pathname, "/text")
        assert.strictEqual(url.search, "?existing=1&value=a%23b")
        assert.strictEqual(url.hash, "")
        expect(yield* response.text).toBe("test")
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("accessing text preserves response bytes", () =>
      Effect.gen(function*() {
        const response = yield* HttpClient.get("/bytes")
        void response.text
        assert.deepStrictEqual(new Uint8Array(yield* response.arrayBuffer), responseBytes)
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("request and response json ignore a leading UTF-8 BOM", () =>
      Effect.gen(function*() {
        const response = yield* HttpClient.post("/bom-json", {
          body: HttpBody.text("\uFEFF{\"a\":1}", "application/json")
        })
        assert.deepStrictEqual(yield* response.json, { a: 1 })
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("request and response urlParamsBody preserve a leading question mark", () =>
      Effect.gen(function*() {
        const response = yield* HttpClient.post("/question-form", {
          body: HttpBody.text("?name=value", "application/x-www-form-urlencoded")
        })
        // the server echoes its parsed key behind another raw question mark
        assert.deepStrictEqual([...yield* response.urlParamsBody], [["??name", "value"]])
      }).pipe(Effect.provide(localServerTestLayer)))

    if (name !== "fetch") {
      it.live("continues uploading while reading a streaming response", () => {
        const server = Http.createServer((request, response) => {
          request.on("error", () => {})
          response.writeHead(200, { "content-type": "text/plain" })
          response.write("ready\n")
          request.pipe(response)
        })
        const testLayer = HttpServer.layerTestClient.pipe(
          Layer.provide(layer),
          Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
        )
        return Effect.gen(function*() {
          const readingResponse = yield* Deferred.make<void>()
          const encoder = new TextEncoder()
          const body = Stream.succeed(encoder.encode("first")).pipe(
            Stream.concat(Stream.fromEffect(
              Deferred.await(readingResponse).pipe(Effect.as(encoder.encode("second")))
            ))
          )
          const response = yield* HttpClient.post("/", { body: HttpBody.stream(body) })
          const text = yield* response.stream.pipe(
            Stream.tap(() => Deferred.succeed(readingResponse, undefined)),
            Stream.decodeText(),
            Stream.mkString
          )
          assert.strictEqual(text, "ready\nfirstsecond")
        }).pipe(
          Effect.timeout("2 seconds"),
          Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
          Effect.provide(testLayer)
        )
      })

      it.live.each([
        { source: "global", FormData: globalThis.FormData },
        { source: "undici", FormData: Undici.FormData }
      ])("sends $source form data request bodies as multipart", ({ FormData }) =>
        Effect.gen(function*() {
          const formData = new FormData()
          formData.append("title", "effect")
          formData.append("file", new Blob(["file contents"], { type: "text/plain" }), "notes.txt")
          const response = yield* HttpClient.post("/multipart", {
            body: HttpBody.formData(formData as globalThis.FormData),
            headers: { "content-type": "multipart/form-data; boundary=caller-boundary" }
          }).pipe(
            Effect.timeout("2 seconds")
          )
          assert.deepStrictEqual(yield* response.json, [
            { key: "title", value: "effect" },
            { key: "file", name: "notes.txt", contentType: "text/plain", content: "file contents" }
          ])
        }).pipe(Effect.provide(localServerTestLayer)))

      it.live("returns TransportError when a form data file cannot be read", () =>
        Effect.gen(function*() {
          const directory = yield* Effect.acquireRelease(
            Effect.sync(() => mkdtempSync(join(tmpdir(), "effect-form-data-"))),
            (directory) => Effect.sync(() => rmSync(directory, { recursive: true, force: true }))
          )
          const path = join(directory, "notes.txt")
          writeFileSync(path, "file contents")
          const blob = yield* Effect.promise(() => openAsBlob(path, { type: "text/plain" }))
          const formData = new FormData()
          formData.append("file", blob, "notes.txt")
          truncateSync(path, 0)

          const error = yield* HttpClient.post("/multipart", { body: HttpBody.formData(formData) }).pipe(
            Effect.timeout("2 seconds"),
            Effect.flip
          )
          assert(error._tag === "HttpClientError", `Expected HttpClientError, got ${error._tag}`)
          assert.strictEqual(error.reason._tag, "TransportError")
        }).pipe(Effect.provide(localServerTestLayer)))
    }

    if (name === "undici") {
      it.effect.each(formDataResponses)("parses $name response form data", ({ path }) =>
        Effect.gen(function*() {
          const response = yield* HttpClient.get(path)
          const form = yield* response.formData
          assert.deepStrictEqual(form.getAll("tag"), ["one", "two"])
        }).pipe(Effect.provide(localServerTestLayer)))
    }

    it.effect("local server followRedirects", () =>
      Effect.gen(function*() {
        const client = (yield* HttpClient.HttpClient).pipe(
          HttpClient.followRedirects()
        )
        const response = yield* client.get("/redirect")
        expect(new URL(response.url).pathname).toBe("/redirected")
        expect(yield* response.text).toBe("redirected")
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("text stream", () =>
      Effect.gen(function*() {
        const client = yield* HttpClient.HttpClient
        const response = yield* client.get("/text").pipe(
          Effect.map((_) => _.stream),
          Stream.unwrap,
          Stream.decodeText(),
          Stream.mkString
        )
        expect(response).toBe("test")
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("local server", () =>
      Effect.gen(function*() {
        const local = yield* LocalServerClient
        const response = yield* local.client.get("/todos/1").pipe(
          Effect.flatMap(HttpClientResponse.schemaBodyJson(Todo, {
            reviver: (key, value) => key === "title" ? "revived" : value
          }))
        )
        expect(response.id).toBe(1)
        expect(response.title).toBe("revived")
      }).pipe(
        Effect.provide(localServerTestLayer)
      ))

    it.effect("local server schemaBodyJson", () =>
      Effect.gen(function*() {
        const local = yield* LocalServerClient
        const response = yield* local.createTodo({
          userId: 1,
          title: "test",
          completed: false
        })
        expect(response.title).toBe("test")
      }).pipe(
        Effect.provide(localServerTestLayer)
      ))

    it.effect("round trips QUERY method, body, and content type through the local server", () =>
      Effect.gen(function*() {
        const body = JSON.stringify({ query: "effect" })
        const response = yield* HttpClient.query("/search", {
          body: HttpBody.text(body, "application/json")
        })

        assert.strictEqual(response.status, 200)
        assert.deepStrictEqual(yield* response.json, {
          method: "QUERY",
          contentType: "application/json",
          body
        })
      }).pipe(Effect.provide(localServerTestLayer)))

    it.effect("head request with schemaJson", () =>
      Effect.gen(function*() {
        const client = yield* HttpClient.HttpClient
        const response = yield* client.head("/todos").pipe(
          Effect.flatMap(
            HttpClientResponse.schemaJson(Schema.Struct({ status: Schema.Literal(200) }))
          )
        )
        expect(response).toEqual({ status: 200 })
      }).pipe(Effect.provide(localServerTestLayer)))

    it.live("interrupt", () =>
      Effect.gen(function*() {
        const client = yield* HttpClient.HttpClient
        const response = yield* client.get("/hang").pipe(
          Effect.flatMap((_) => _.text),
          Effect.timeout(1),
          Effect.asSome,
          Effect.catchTag("TimeoutError", () => Effect.succeedNone)
        )
        expect(response._tag).toEqual("None")
      }).pipe(Effect.provide(localServerTestLayer)))

    if (name !== "fetch") {
      it.effect("reads a refused upgrade as an ordinary response", () =>
        Effect.gen(function*() {
          const response = yield* HttpClient.execute(
            HttpClientRequest.post("/upgrade").pipe(HttpClientRequest.upgrade("tcp"))
          )
          assert.strictEqual(response.status, 401)
          const error = yield* Effect.flip(response.upgrade)
          assert.strictEqual(error.reason._tag, "StatusCodeError")
          assert.deepStrictEqual(yield* response.json, { message: "unauthorized" })
        }).pipe(Effect.provide(localServerTestLayer)))
    }

    it.effect("close early", () =>
      Effect.gen(function*() {
        const response = yield* HttpClient.get("/large")
        expect(response.status).toBe(200)
      }).pipe(Effect.provide(localServerTestLayer)))
  })
})

it.live("followRedirects releases redirect response bodies with a single socket", () =>
  Effect.gen(function*() {
    const client = (yield* HttpClient.HttpClient).pipe(HttpClient.followRedirects())
    const response = yield* client.get("/redirect")
    expect(yield* response.text).toBe("redirected")
  }).pipe(
    Effect.timeout("2 seconds"),
    Effect.provide(LocalServerRoutes.pipe(
      Layer.provideMerge(HttpServer.layerTestClient),
      Layer.provide(NodeClient.layerNodeHttpOptions({ maxSockets: 1 })),
      Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
    ))
  ))

it.live("followRedirects releases scoped redirect response bodies with a single socket", () =>
  Effect.gen(function*() {
    const client = (yield* HttpClient.HttpClient).pipe(HttpClient.withScope, HttpClient.followRedirects())
    const response = yield* client.get("/redirect")
    expect(yield* response.text).toBe("redirected")
  }).pipe(
    Effect.scoped,
    Effect.timeout("2 seconds"),
    Effect.provide(LocalServerRoutes.pipe(
      Layer.provideMerge(HttpServer.layerTestClient),
      Layer.provide(NodeClient.layerNodeHttpOptions({ maxSockets: 1 })),
      Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
    ))
  ))

it.live("releases an immediately failing form data stream and connection before layer teardown", () => {
  const server = Http.createServer((request) => {
    request.on("error", () => {})
    request.resume()
  })
  const layer = HttpServer.layerTestClient.pipe(
    Layer.provide(NodeClient.layerNodeHttp),
    Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
  )
  return Effect.gen(function*() {
    const streams: Array<ReadableStream<Uint8Array<ArrayBuffer>>> = []
    class BrokenFile extends File {
      override stream() {
        const stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
          start(controller) {
            controller.error(new Error("file read failed"))
          }
        })
        streams.push(stream)
        return stream
      }
    }
    const formData = new FormData()
    formData.append("file", new BrokenFile(["file contents"], "notes.txt"))
    const error = yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(
      Effect.timeout("2 seconds"),
      Effect.match({ onFailure: (error) => error, onSuccess: () => undefined })
    )
    assert.strictEqual(streams.length, 1)
    assert(error?._tag === "HttpClientError", `Expected HttpClientError, got ${error?._tag}`)
    assert.strictEqual(error.reason._tag, "TransportError")
    assert.strictEqual(streams[0].locked, false)
    const connections = yield* Effect.sleep("10 millis").pipe(
      Effect.andThen(Effect.callback<number, Error>((resume) => {
        server.getConnections((error, count) => resume(error ? Effect.fail(error) : Effect.succeed(count)))
      })),
      Effect.repeat({ while: (count) => count !== 0, schedule: Schedule.spaced("10 millis") }),
      Effect.timeout("1 second")
    )
    assert.strictEqual(connections, 0)
  }).pipe(
    Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
    Effect.provide(layer)
  )
})

it.live("returns TransportError when a form data file stream cannot be created", () =>
  Effect.gen(function*() {
    class ThrowingFile extends File {
      override stream(): never {
        throw new Error("file stream failed")
      }
    }
    const formData = new FormData()
    formData.append("file", new ThrowingFile([], "notes.txt"))
    const error = yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(Effect.flip)
    assert.strictEqual(error.reason._tag, "TransportError")
  }).pipe(Effect.provide(HttpServer.layerTestClient.pipe(
    Layer.provide(NodeClient.layerNodeHttp),
    Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
  ))))

it.live("reads backpressured form data files on demand and releases them on interruption", () => {
  const server = Http.createServer((request) => request.pause())
  let read = 0
  let stream: ReadableStream | undefined
  class LargeFile extends File {
    override stream() {
      return stream = new ReadableStream<Uint8Array<ArrayBuffer>>({
        pull(controller) {
          if (read === 64 * 1024 * 1024) return controller.close()
          read += 64 * 1024
          controller.enqueue(new Uint8Array(64 * 1024))
        }
      })
    }
  }
  return Effect.gen(function*() {
    const formData = new FormData()
    formData.append("file", new LargeFile([], "large.bin"))
    yield* HttpClient.post("/", { body: HttpBody.formData(formData) }).pipe(Effect.timeout("1 second"), Effect.ignore)
    // The server never reads the upload, so only socket buffers should fill.
    assert.isBelow(read, 16 * 1024 * 1024)
    yield* Effect.sync(() => stream?.locked).pipe(
      Effect.repeat({ while: (locked) => locked !== false, schedule: Schedule.spaced("10 millis") }),
      Effect.timeout("1 second")
    )
  }).pipe(
    Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
    Effect.provide(HttpServer.layerTestClient.pipe(
      Layer.provide(NodeClient.layerNodeHttp),
      Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
    ))
  )
})

it.live.each(["response completion", "response interruption", "upload failure"] as const)(
  "releases an unfinished keep-alive upload after %s before layer teardown",
  (mode) =>
    Effect.gen(function*() {
      const uploadBlocked = yield* Deferred.make<void>()
      const uploadFinalized = yield* Deferred.make<void>()
      const failUpload = yield* Deferred.make<void>()
      const connectionClosed = yield* Deferred.make<void>()
      const server = Http.createServer((request, response) => {
        request.on("error", () => {})
        request.socket.once("close", () => Deferred.doneUnsafe(connectionClosed, Effect.void))
        request.once("data", () => {
          response.writeHead(200, { "content-type": "text/plain" })
          if (mode === "response completion") {
            response.end("ready")
          } else {
            response.write("ready")
          }
        })
      })
      const layer = HttpServer.layerTestClient.pipe(
        Layer.provide(NodeClient.layerNodeHttpNoAgent.pipe(
          Layer.provide(NodeClient.layerAgentOptions({ keepAlive: true }))
        )),
        Layer.provideMerge(NodeHttpServer.layer(() => server, { port: 0 }))
      )
      yield* Effect.gen(function*() {
        const body = Stream.succeed(new TextEncoder().encode("first")).pipe(
          Stream.concat(Stream.fromEffect(
            Deferred.succeed(uploadBlocked, undefined).pipe(
              Effect.andThen(Deferred.await(failUpload)),
              Effect.andThen(Effect.fail("upload failed"))
            )
          )),
          Stream.ensuring(Deferred.succeed(uploadFinalized, undefined))
        )
        const response = yield* HttpClient.post("/", { body: HttpBody.stream(body) })
        yield* Deferred.await(uploadBlocked)
        if (mode === "response completion") {
          assert.strictEqual(yield* response.text, "ready")
        } else if (mode === "response interruption") {
          const reading = yield* Deferred.make<void>()
          const reader = yield* response.stream.pipe(
            Stream.tap(() => Deferred.succeed(reading, undefined)),
            Stream.runDrain,
            Effect.forkChild
          )
          yield* Deferred.await(reading)
          yield* Fiber.interrupt(reader)
        } else {
          const error = yield* response.stream.pipe(
            Stream.tap(() => Deferred.succeed(failUpload, undefined)),
            Stream.runDrain,
            Effect.timeout("1 second"),
            Effect.flip
          )
          assert.strictEqual(error._tag, "HttpClientError")
        }
        // Check while the agent is still alive: layer teardown must not mask a leak.
        yield* Deferred.await(uploadFinalized).pipe(Effect.timeout("1 second"))
        if (mode !== "response completion") {
          yield* Deferred.await(connectionClosed).pipe(Effect.timeout("1 second"))
        }
      }).pipe(
        Effect.timeout("2 seconds"),
        Effect.ensuring(Effect.sync(() => server.closeAllConnections())),
        Effect.provide(layer)
      )
    })
)

it.live("returns a stream body encoding failure", () =>
  Effect.gen(function*() {
    yield* Effect.gen(function*() {
      const request = yield* HttpServerRequest.HttpServerRequest
      yield* request.text
      return HttpServerResponse.empty()
    }).pipe(HttpServer.serveEffect())
    const error = yield* HttpClient.post("/", {
      body: HttpBody.stream(Stream.fail("encode failure"))
    }).pipe(Effect.timeout("1 second"), Effect.flip)
    assert(error._tag === "HttpClientError")
    assert.strictEqual(error.reason._tag, "EncodeError")
    assert.strictEqual(error.reason.cause, "encode failure")
  }).pipe(Effect.provide(HttpServer.layerTestClient.pipe(
    Layer.provide(NodeClient.layerNodeHttp),
    Layer.provideMerge(NodeHttpServer.layer(Http.createServer, { port: 0 }))
  ))))

// Answers upgrade requests by hand, sending bytes in the same write as the
// response head, like a Docker Engine attach endpoint.
const makeUpgradeServer = (onClose?: () => void) => {
  const sockets = new Set<Net.Socket>()
  return Effect.acquireRelease(
    Effect.callback<Http.Server>((resume) => {
      const server = Http.createServer()
      server.on("connection", (socket) => {
        sockets.add(socket)
        socket.once("close", () => sockets.delete(socket))
      })
      server.on("upgrade", (request: Http.IncomingMessage, socket: Net.Socket) => {
        if (onClose !== undefined) socket.once("close", onClose)
        socket.write(
          "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\n" +
            `Upgrade: ${request.headers.upgrade}\r\nX-Url: ${request.url}\r\n` +
            `X-Authorization: ${request.headers.authorization}\r\n\r\nhello|`
        )
        socket.on("data", (chunk) => socket.write(`echo:${chunk}|`))
        socket.on("end", () => socket.end("bye"))
      })
      server.listen(0, "127.0.0.1", () => resume(Effect.succeed(server)))
    }),
    (server) =>
      Effect.callback<void>((resume) => {
        for (const socket of sockets) socket.destroy()
        server.closeAllConnections()
        server.close(() => resume(Effect.void))
      })
  ).pipe(
    Effect.map((server) =>
      HttpClient.mapRequest(flow(
        HttpClientRequest.prependUrl(`http://127.0.0.1:${(server.address() as Net.AddressInfo).port}/base`),
        HttpClientRequest.bearerToken("token")
      ))
    )
  )
}

const readUntilClose = Effect.fnUntraced(function*(reader: Socket.Reader) {
  const decoder = new TextDecoder()
  let text = ""
  while (true) {
    const chunks = yield* reader.pull.pipe(
      Effect.catchReason("SocketError", "SocketCloseError", () => Effect.succeed(undefined))
    )
    if (chunks === undefined) return text
    for (const chunk of chunks) text += typeof chunk === "string" ? chunk : decoder.decode(chunk)
  }
})

describe("NodeHttpClient upgrade", () => {
  ;[
    { name: "node:http", layer: NodeClient.layerNodeHttp },
    { name: "undici", layer: NodeClient.layerUndici }
  ].forEach(({ layer, name }) => {
    describe(name, () => {
      it.effect("hands over the connection of a 101 response", () =>
        Effect.gen(function*() {
          const client = (yield* HttpClient.HttpClient).pipe(yield* makeUpgradeServer())
          const response = yield* client.execute(
            HttpClientRequest.post("/attach").pipe(HttpClientRequest.upgrade("tcp"))
          )
          assert.strictEqual(response.status, 101)
          assert.strictEqual(response.headers["upgrade"], "tcp")
          assert.strictEqual(response.headers["x-url"], "/base/attach")
          assert.strictEqual(response.headers["x-authorization"], "Bearer token")

          const socket = yield* response.upgrade
          const reader = yield* socket.reader
          // releasing the writer half-closes, so the server answers "bye"
          yield* Effect.scoped(Effect.flatMap(socket.writer, (writer) => writer.write("ping")))
          assert.strictEqual(yield* readUntilClose(reader), "hello|echo:ping|bye")
        }).pipe(Effect.provide(layer)))
      it.live("closes the upgraded connection when the request scope closes", () =>
        Effect.gen(function*() {
          const closed = yield* Deferred.make<void>()
          const client = (yield* HttpClient.HttpClient).pipe(
            yield* makeUpgradeServer(() => Deferred.doneUnsafe(closed, Effect.void)),
            HttpClient.withScope
          )
          yield* Effect.scoped(Effect.gen(function*() {
            const response = yield* client.execute(
              HttpClientRequest.post("/attach").pipe(HttpClientRequest.upgrade("tcp"))
            )
            assert.strictEqual(response.status, 101)
          }))
          yield* Deferred.await(closed).pipe(Effect.timeout("1 second"))
        }).pipe(Effect.provide(layer)))
    })
  })

  it.effect("fetch rejects an upgrade request before calling fetch", () =>
    Effect.gen(function*() {
      let calls = 0
      const error = yield* HttpClient.execute(
        HttpClientRequest.post("http://127.0.0.1:1/attach").pipe(HttpClientRequest.upgrade("tcp"))
      ).pipe(
        Effect.provideService(
          FetchHttpClient.Fetch,
          Object.assign(() => {
            calls++
            return Promise.resolve(new Response(""))
          }, { preconnect: () => {} })
        ),
        Effect.flip
      )
      assert.strictEqual(error.reason._tag, "TransportError")
      assert.strictEqual(calls, 0)
    }).pipe(Effect.provide(NodeClient.layerFetch)))
})