sailfork / t3code-github / .repos/ effect/ packages/ platform/ node-shared/ test/ Dns.test-utils.ts

import { assert, describe, it } from "@effect/vitest"
import * as Duration from "effect/Duration"
import * as Effect from "effect/Effect"
import * as Hex from "effect/encoding/Hex"
import * as Equal from "effect/Equal"
import * as Dns from "effect/net/Dns"
import * as Host from "effect/net/Host"
import * as NetAddress from "effect/net/NetAddress"
import * as Result from "effect/Result"
import type * as Scope from "effect/Scope"
import * as NodeDnsApi from "node:dns"
import * as Fs from "node:fs/promises"
import * as Os from "node:os"
import * as Path from "node:path"
import { GenericContainer, type StartedTestContainer, Wait } from "testcontainers"
import { afterAll, beforeAll } from "vitest"

const name = Host.domainNameFromStringUnsafe
const ip = NetAddress.ipFromStringUnsafe

/**
 * The records every platform should return for the fixture zone below.
 */
const expected: { readonly [K in Dns.RecordType]: ReadonlyArray<Dns.RecordFor<K>> } = {
  A: [
    Dns.makeRecordUnsafe("A", { address: ip("192.0.2.1") as NetAddress.Ipv4Address }),
    Dns.makeRecordUnsafe("A", { address: ip("192.0.2.2") as NetAddress.Ipv4Address })
  ],
  AAAA: [Dns.makeRecordUnsafe("AAAA", { address: ip("2001:db8::1") as NetAddress.Ipv6Address })],
  CAA: [Dns.makeRecordUnsafe("CAA", { critical: false, tag: "issue", value: "ca.example.test" })],
  CNAME: [Dns.makeRecordUnsafe("CNAME", { target: name("example.test.") })],
  MX: [Dns.makeRecordUnsafe("MX", { exchange: name("mail.example.test."), priority: 10 })],
  NAPTR: [
    Dns.makeRecordUnsafe("NAPTR", {
      order: 100,
      preference: 10,
      flags: "S",
      service: "SIP+D2U",
      regexp: "",
      replacement: name("_sip._udp.example.test.")
    })
  ],
  NS: [Dns.makeRecordUnsafe("NS", { host: name("ns1.example.test.") })],
  PTR: [Dns.makeRecordUnsafe("PTR", { host: name("example.test.") })],
  SOA: [
    Dns.makeRecordUnsafe("SOA", {
      primary: name("ns1.example.test."),
      admin: "hostmaster.example.test.",
      serial: 2024010101,
      refresh: Duration.seconds(3600),
      retry: Duration.seconds(600),
      expire: Duration.seconds(604800),
      minimum: Duration.seconds(300)
    })
  ],
  SRV: [Dns.makeRecordUnsafe("SRV", { target: name("db1.example.test."), port: 5432, priority: 10, weight: 5 })],
  TLSA: [
    Dns.makeRecordUnsafe("TLSA", {
      certUsage: 3,
      selector: 1,
      matchingType: 1,
      data: Result.getOrThrow(Hex.decode("38a88126a15ae8e643ce9447c3ce9a874ea0e05255d07ee12227809edbe5c7f1"))
    })
  ],
  TXT: [Dns.makeRecordUnsafe("TXT", { chunks: ["v=spf1 ", "-all"] })]
}

/**
 * Asserts that two record lists hold the same records, in any order. Name
 * servers may rotate the order of records in an answer.
 */
const assertRecords = (actual: ReadonlyArray<Dns.DnsRecord>, records: ReadonlyArray<Dns.DnsRecord>) => {
  assert.strictEqual(actual.length, records.length, `expected ${records.map(Dns.formatRecord).join(", ")}`)
  for (const record of records) {
    assert.isTrue(
      actual.some((candidate) => Equal.equals(candidate, record)),
      `expected ${Dns.formatRecord(record)} in ${actual.map(Dns.formatRecord).join(", ")}`
    )
  }
}

const corefile = `
example.test {
  file /etc/coredns/example.test.db
}
2.0.192.in-addr.arpa {
  file /etc/coredns/2.0.192.in-addr.arpa.db
}
edge.test {
  file /etc/coredns/edge.test.db
}
`

// Mirrors `expected`, plus records that cannot be represented. Names outside
// the zones are refused.
const exampleZone = `
$ORIGIN example.test.
$TTL 300
@           IN SOA   ns1.example.test. hostmaster.example.test. 2024010101 3600 600 604800 300
@           IN NS    ns1.example.test.
@           IN A     192.0.2.1
@           IN A     192.0.2.2
@           IN AAAA  2001:db8::1
@           IN MX    10 mail.example.test.
@           IN TXT   "v=spf1 " "-all"
@           IN CAA   0 issue "ca.example.test"
@           IN NAPTR 100 10 "S" "SIP+D2U" "" _sip._udp.example.test.
ns1         IN A     192.0.2.53
www         IN CNAME example.test.
_pg._tcp    IN SRV   10 5 5432 db1.example.test.
_443._tcp   IN TLSA  3 1 1 38a88126a15ae8e643ce9447c3ce9a874ea0e05255d07ee12227809edbe5c7f1
bad-mx      IN MX    10 bad\\032host.example.test.
`

const reverseZone = `
$ORIGIN 2.0.192.in-addr.arpa.
$TTL 300
@           IN SOA   ns1.example.test. hostmaster.example.test. 1 3600 600 604800 300
@           IN NS    ns1.example.test.
1           IN PTR   example.test.
2           IN PTR   good.example.test.
2           IN PTR   bad\\032host.example.test.
`

// Records that platform resolvers report in unusual forms: a root primary name,
// a mailbox with an escaped dot, timers of 2^31 seconds or more, UTF-8 text,
// and a PTR name whose label holds a dot, a space, UTF-8, and a backslash.
const edgeZone = `
$ORIGIN edge.test.
$TTL 300
@           IN SOA   . john\\.doe.example.test. 1 4294967295 2147483648 604800 300
@           IN NS    ns1.example.test.
@           IN TXT   "gr\\195\\188\\195\\159"
_svc._tcp   IN PTR   v2\\.0\\032Caf\\195\\169\\092x._svc._tcp.edge.test.
_dot._tcp   IN PTR   printer\\..
`

/**
 * Starts a CoreDNS container serving the fixture zones and returns the address
 * of its UDP listener.
 */
export const startDnsServer = async (): Promise<{
  readonly nameServer: NetAddress.InetAddressV4
  readonly stop: () => Promise<void>
}> => {
  // The fixtures are bind-mounted rather than copied: under Bun, the archive
  // testcontainers builds for copied content loses its last file.
  const directory = await Fs.mkdtemp(Path.join(Os.tmpdir(), "effect-dns-"))
  let container: StartedTestContainer | undefined
  const stop = async () => {
    try {
      await container?.stop()
    } finally {
      await Fs.rm(directory, { recursive: true, force: true })
    }
  }
  try {
    await Fs.chmod(directory, 0o755)
    for (
      const [file, content] of [
        ["Corefile", corefile],
        ["example.test.db", exampleZone],
        ["2.0.192.in-addr.arpa.db", reverseZone],
        ["edge.test.db", edgeZone]
      ]
    ) {
      await Fs.writeFile(Path.join(directory, file), content, { mode: 0o644 })
    }
    container = await new GenericContainer("coredns/coredns:1.14.7")
      .withBindMounts([{ source: directory, target: "/etc/coredns", mode: "ro" }])
      .withCommand(["-conf", "/etc/coredns/Corefile"])
      .withExposedPorts("53/udp")
      .withWaitStrategy(Wait.forLogMessage(/CoreDNS-/))
      .start()
    // The resolver APIs accept only IP addresses for name servers.
    const { address } = await NodeDnsApi.promises.lookup(container.getHost(), { family: 4 })
    return {
      nameServer: NetAddress.inetAddressFromStringUnsafe(
        `${address}:${container.getMappedPort("53/udp")}`
      ) as NetAddress.InetAddressV4,
      stop
    }
  } catch (error) {
    await stop()
    throw error
  }
}

const isBun = typeof process !== "undefined" && process.versions.bun !== undefined
const isDeno = "Deno" in globalThis

/**
 * Runs end-to-end tests of a platform `Dns` service against a CoreDNS
 * container. The only skipped tests cover documented runtime bugs that the
 * platform services cannot work around.
 */
export const describeDnsServer = (
  label: string,
  make: (
    nameServer: NetAddress.InetAddress
  ) => Effect.Effect<Dns.Dns["Service"], NetAddress.NetAddressError, Scope.Scope>
) =>
  describe(label, () => {
    let server: Awaited<ReturnType<typeof startDnsServer>>
    beforeAll(async () => {
      server = await startDnsServer()
    }, 120_000)
    afterAll(async () => {
      await server?.stop()
    })

    const dns = () => make(server.nameServer)

    it.effect("looks up localhost from the hosts file", () =>
      Effect.gen(function*() {
        const addresses = yield* (yield* dns()).lookup(name("localhost"), { family: "IPv4" })
        assert.isTrue(addresses.some((address) => NetAddress.formatIp(address) === "127.0.0.1"))
      }))

    it.effect("queries every record type", () =>
      Effect.gen(function*() {
        const resolver = yield* dns()
        for (const type of ["A", "AAAA", "CAA", "MX", "NAPTR", "NS", "SOA"] as const) {
          assertRecords(yield* resolver.resolve(name("example.test."), type), expected[type])
        }
        assertRecords(yield* resolver.resolve(name("www.example.test"), "CNAME"), expected.CNAME)
        assertRecords(yield* resolver.resolve(name("_pg._tcp.example.test"), "SRV"), expected.SRV)
      }))

    // Bun's resolver and `Deno.resolveDns` cannot query TLSA records.
    it.effect("queries TLSA records where the runtime supports them", () =>
      Effect.gen(function*() {
        const query = (yield* dns()).resolve(name("_443._tcp.example.test"), "TLSA")
        if (isBun || isDeno) {
          const error = yield* Effect.flip(query)
          assert.strictEqual(error.reason, "Unsupported")
          assert.strictEqual(error.recordType, "TLSA")
        } else {
          assertRecords(yield* query, expected.TLSA)
        }
      }))

    // Bun returns each character string of a TXT record as a separate record,
    // so the chunks of a record cannot be reassembled:
    // https://github.com/oven-sh/bun/issues/44692
    it.effect.skipIf(isBun)("keeps the chunks of a TXT record together", () =>
      Effect.gen(function*() {
        assertRecords(yield* (yield* dns()).resolve(name("example.test."), "TXT"), expected.TXT)
      }))

    it.effect("converts unusual record data", () =>
      Effect.gen(function*() {
        const resolver = yield* dns()
        assertRecords(yield* resolver.resolve(name("edge.test"), "SOA"), [
          Dns.makeRecordUnsafe("SOA", {
            primary: name("."),
            admin: "john\\.doe.example.test.",
            serial: 1,
            refresh: Duration.seconds(4294967295),
            retry: Duration.seconds(2147483648),
            expire: Duration.seconds(604800),
            minimum: Duration.seconds(300)
          })
        ])
        assertRecords(yield* resolver.resolve(name("edge.test"), "TXT"), [
          Dns.makeRecordUnsafe("TXT", { chunks: ["grüß"] })
        ])
        assertRecords(yield* resolver.resolve(name("_svc._tcp.edge.test"), "PTR"), [
          Dns.makeRecordUnsafe("PTR", { host: "v2\\.0 Café\\\\x._svc._tcp.edge.test." })
        ])
      }))

    it.effect("keeps the root after a label ending with an escaped dot", () =>
      Effect.gen(function*() {
        const records = yield* (yield* dns()).resolve(name("_dot._tcp.edge.test"), "PTR")
        assert.deepStrictEqual(records.map(Dns.formatRecord), ["PTR printer\\.."])
      }))

    it.effect("looks up the host names of an address, skipping invalid names", () =>
      Effect.gen(function*() {
        const resolver = yield* dns()
        assert.deepStrictEqual<ReadonlyArray<string>>(yield* resolver.reverse(ip("192.0.2.1")), ["example.test."])
        assert.deepStrictEqual<ReadonlyArray<string>>(yield* resolver.reverse(ip("192.0.2.2")), [
          "good.example.test."
        ])
      }))

    it.effect("fails when no record can be represented", () =>
      Effect.gen(function*() {
        const error = yield* Effect.flip((yield* dns()).resolve(name("bad-mx.example.test"), "MX"))
        assert.strictEqual(error.reason, "InvalidResponse")
      }))

    it.effect("reports missing names and records", () =>
      Effect.gen(function*() {
        const resolver = yield* dns()
        const missingName = yield* Effect.flip(resolver.resolve(name("missing.example.test"), "A"))
        assert.strictEqual(missingName.reason, "NotFound")
        const missingRecord = yield* Effect.flip(resolver.resolve(name("ns1.example.test."), "SRV"))
        assert.strictEqual(missingRecord.reason, "NotFound")
        const missingAddress = yield* Effect.flip(resolver.reverse(ip("192.0.2.9")))
        assert.strictEqual(missingAddress.reason, "NotFound")
      }))

    // `Deno.resolveDns` reports every error response, including refused
    // queries, with the same `NotFound` error as a missing name.
    it.effect.skipIf(isDeno)("reports refused queries", () =>
      Effect.gen(function*() {
        const error = yield* Effect.flip((yield* dns()).resolve(name("outside.invalid"), "A"))
        assert.strictEqual(error.reason, "Refused")
      }))
  })