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

import { NodeRedis } from "@effect/platform-node"
import { describe, it } from "@effect/vitest"
import { Deferred, Effect, Fiber, Layer } from "effect"
import { Redis } from "effect/persistence"
import * as Net from "node:net"

// A loopback peer that accepts a connection and, unless `onData` replies,
// never answers.
const makePeer = Effect.fnUntraced(function*(onData?: (socket: Net.Socket, data: string) => void) {
  const received = yield* Deferred.make<void>()
  const closed = yield* Deferred.make<void>()
  const sockets = new Set<Net.Socket>()
  const server = Net.createServer((socket) => {
    sockets.add(socket)
    socket.on("error", () => {})
    socket.once("data", () => Deferred.doneUnsafe(received, Effect.void))
    if (onData) socket.on("data", (data) => onData(socket, data.toString()))
    socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void))
  })
  yield* Effect.acquireRelease(
    Effect.callback<void>((resume) => {
      server.listen(0, "127.0.0.1", () => resume(Effect.void))
    }),
    () =>
      Effect.callback<void>((resume) => {
        for (const socket of sockets) socket.destroy()
        server.close(() => resume(Effect.void))
      })
  )
  const port = (server.address() as Net.AddressInfo).port
  return { port, received, closed } as const
})

// A peer that answers every command with `+OK`, except those `stall` matches,
// which never get a reply. Connections are numbered in the order they first
// send data, so the shared client is connection 0.
const makeStallingPeer = Effect.fnUntraced(function*(stall: (connection: number, command: string) => boolean) {
  const stalled = yield* Deferred.make<void>()
  const closed = yield* Deferred.make<void>()
  const connections = new Map<Net.Socket, number>()
  const { port } = yield* makePeer((socket, data) => {
    if (!connections.has(socket)) connections.set(socket, connections.size)
    for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) {
      if (stall(connections.get(socket)!, command.toUpperCase())) {
        socket.once("close", () => Deferred.doneUnsafe(closed, Effect.void))
        Deferred.doneUnsafe(stalled, Effect.void)
      } else {
        socket.write("+OK\r\n")
      }
    }
  })
  const layer = NodeRedis.layer({
    socket: { host: "127.0.0.1", port },
    // Keep every connection's handshake to `SELECT`.
    database: 1,
    RESP: 2,
    disableClientInfo: true,
    maintNotifications: "disabled"
  })
  return { layer, stalled, closed } as const
})

describe("NodeRedis", () => {
  for (const tls of [false, true]) {
    it.live(`interrupts a stalled ${tls ? "TLS" : "Redis"} handshake`, () =>
      Effect.gen(function*() {
        const peer = yield* makePeer()
        const fiber = yield* Layer.build(NodeRedis.layer({
          socket: tls ? { host: "127.0.0.1", port: peer.port, tls } : { host: "127.0.0.1", port: peer.port },
          // `SELECT` guarantees a handshake on every node-redis version.
          database: 1
        })).pipe(Effect.scoped, Effect.forkChild)
        yield* Deferred.await(peer.received)
        yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
        yield* Deferred.await(peer.closed)
      }))
  }

  it.live("bounds shutdown while a command is stalled", () =>
    Effect.gen(function*() {
      const stalled = yield* Deferred.make<void>()
      const ended = yield* Deferred.make<void>()
      const peer = yield* makePeer((socket, data) => {
        // Complete the connection handshake, but never reply to PING.
        for (const [, command] of data.matchAll(/\*\d+\r\n\$\d+\r\n(\w+)\r\n/g)) {
          if (command === "PING") Deferred.doneUnsafe(stalled, Effect.void)
          else socket.write("+OK\r\n")
        }
      })
      const fiber = yield* Effect.gen(function*() {
        const { client } = yield* NodeRedis.NodeRedis
        client.once("end", () => Deferred.doneUnsafe(ended, Effect.void))
        const redis = yield* Redis.Redis
        yield* redis.send("PING")
      }).pipe(
        Effect.provide(NodeRedis.layer({
          socket: { host: "127.0.0.1", port: peer.port },
          // Keep the connection handshake to at most `HELLO`.
          RESP: 2,
          disableClientInfo: true,
          maintNotifications: "disabled"
        })),
        Effect.forkChild
      )
      yield* Deferred.await(stalled)
      yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
      yield* Deferred.await(peer.closed)
      // The client is fully destroyed, not just disconnected by the abort signal.
      yield* Deferred.await(ended)
    }))

  for (const command of ["SELECT", "SUBSCRIBE"]) {
    it.live(`interrupts a subscriber stalled on ${command}`, () =>
      Effect.gen(function*() {
        const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === command)
        const fiber = yield* Effect.gen(function*() {
          const redis = yield* Redis.Redis
          yield* redis.subscribe("channel")
        }).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild)
        yield* Deferred.await(peer.stalled)
        yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
        yield* Deferred.await(peer.closed)
      }))
  }

  it.live("interrupts a stalled reserved connection", () =>
    Effect.gen(function*() {
      const peer = yield* makeStallingPeer((connection, received) => connection > 0 && received === "SELECT")
      const fiber = yield* Effect.gen(function*() {
        const redis = yield* Redis.Redis
        yield* redis.reserve
      }).pipe(Effect.scoped, Effect.provide(peer.layer), Effect.forkChild)
      yield* Deferred.await(peer.stalled)
      yield* Fiber.interrupt(fiber).pipe(Effect.timeout("2 seconds"))
      // The connection attempt is aborted rather than left to open later.
      yield* Deferred.await(peer.closed)
    }))
})