refactor: match /test/unit structure to /src

test/unit/node/socket.test.ts

@@ -0,0 +1,127 @@
+import { field, logger } from "@coder/logger"
+import { promises as fs } from "fs"
+import * as net from "net"
+import * as path from "path"
+import * as tls from "tls"
+import { Emitter } from "../../../src/common/emitter"
+import { tmpdir } from "../../../src/node/constants"
+import { SocketProxyProvider } from "../../../src/node/socket"
+import { generateCertificate } from "../../../src/node/util"
+
+describe("SocketProxyProvider", () => {
+  const provider = new SocketProxyProvider()
+
+  const onServerError = new Emitter<{ event: string; error: Error }>()
+  const onClientError = new Emitter<{ event: string; error: Error }>()
+  const onProxyError = new Emitter<{ event: string; error: Error }>()
+  const fromServerToClient = new Emitter<Buffer>()
+  const fromClientToServer = new Emitter<Buffer>()
+  const fromClientToProxy = new Emitter<Buffer>()
+
+  let errors = 0
+  let close = false
+  const onError = ({ event, error }: { event: string; error: Error }): void => {
+    if (!close || event === "error") {
+      logger.error(event, field("error", error.message))
+      ++errors
+    }
+  }
+  onServerError.event(onError)
+  onClientError.event(onError)
+  onProxyError.event(onError)
+
+  let server: tls.TLSSocket
+  let proxy: net.Socket
+  let client: tls.TLSSocket
+
+  const getData = <T>(emitter: Emitter<T>): Promise<T> => {
+    return new Promise((resolve) => {
+      const d = emitter.event((t) => {
+        d.dispose()
+        resolve(t)
+      })
+    })
+  }
+
+  beforeAll(async () => {
+    const cert = await generateCertificate("localhost")
+    const options = {
+      cert: await fs.readFile(cert.cert),
+      key: await fs.readFile(cert.certKey),
+      rejectUnauthorized: false,
+    }
+
+    await fs.mkdir(path.join(tmpdir, "tests"), { recursive: true })
+    const socketPath = await provider.findFreeSocketPath(path.join(tmpdir, "tests/tls-socket-proxy"))
+    await fs.rmdir(socketPath, { recursive: true })
+
+    return new Promise<void>((_resolve) => {
+      const resolved: { [key: string]: boolean } = { client: false, server: false }
+      const resolve = (type: "client" | "server"): void => {
+        resolved[type] = true
+        if (resolved.client && resolved.server) {
+          // We don't need any more connections.
+          main.close() // eslint-disable-line @typescript-eslint/no-use-before-define
+          _resolve()
+        }
+      }
+      const main = tls
+        .createServer(options, (s) => {
+          server = s
+          server
+            .on("data", (d) => fromClientToServer.emit(d))
+            .on("error", (error) => onServerError.emit({ event: "error", error }))
+            .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+          resolve("server")
+        })
+        .on("error", (error) => onServerError.emit({ event: "error", error }))
+        .on("end", () => onServerError.emit({ event: "end", error: new Error("unexpected end") }))
+        .on("close", () => onServerError.emit({ event: "close", error: new Error("unexpected close") }))
+        .listen(socketPath, () => {
+          client = tls
+            .connect({ ...options, path: socketPath })
+            .on("data", (d) => fromServerToClient.emit(d))
+            .on("error", (error) => onClientError.emit({ event: "error", error }))
+            .on("end", () => onClientError.emit({ event: "end", error: new Error("unexpected end") }))
+            .on("close", () => onClientError.emit({ event: "close", error: new Error("unexpected close") }))
+            .once("connect", () => resolve("client"))
+        })
+    })
+  })
+
+  it("should work without a proxy", async () => {
+    server.write("server->client")
+    const dataFromServerToClient = (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server->client")
+    client.write("client->server")
+    const dataFromClientToServer = (await getData(fromClientToServer)).toString()
+    expect(dataFromClientToServer).toBe("client->server")
+    expect(errors).toEqual(0)
+  })
+
+  it("should work with a proxy", async () => {
+    expect(server instanceof tls.TLSSocket).toBe(true)
+    proxy = (await provider.createProxy(server))
+      .on("data", (d) => fromClientToProxy.emit(d))
+      .on("error", (error) => onProxyError.emit({ event: "error", error }))
+      .on("end", () => onProxyError.emit({ event: "end", error: new Error("unexpected end") }))
+      .on("close", () => onProxyError.emit({ event: "close", error: new Error("unexpected close") }))
+
+    provider.stop() // We don't need more proxies.
+
+    proxy.write("server proxy->client")
+    const dataFromServerToClient = (await getData(fromServerToClient)).toString()
+    expect(dataFromServerToClient).toBe("server proxy->client")
+    client.write("client->server proxy")
+    const dataFromClientToProxy = (await getData(fromClientToProxy)).toString()
+    expect(dataFromClientToProxy).toBe("client->server proxy")
+    expect(errors).toEqual(0)
+  })
+
+  it("should close", async () => {
+    close = true
+    client.end()
+    proxy.end()
+  })
+})