test: split tests by source module

🤖 Generated with [OpenCode](https://opencode.ai) (Smart-router)

Author: daquinoaldo

package.json

@@ -62,7 +62,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc --project tsconfig.build.esm.json && tsc --project tsconfig.build.cjs.json && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
     "lint": "oxfmt && oxlint --fix && tsc --noEmit",
-    "test": "node --test test/*.ts",
+    "test": "node --test-concurrency=1 --test test/*.test.ts",
     "prepack": "pnpm build",
     "preuninstall": "node dist/esm/certs-cli.js -u",
     "start": "node src/cli.ts"

test/app-data-path.test.ts

@@ -0,0 +1,53 @@
+import assert from "node:assert"
+import os from "node:os"
+import path from "node:path"
+import { afterEach, describe, it } from "node:test"
+
+import { getAppDataPath } from "../src/app-data-path.ts"
+
+describe("app-data-path", () => {
+  const originalAppData = process.env["APPDATA"]
+
+  afterEach(() => {
+    if (originalAppData === undefined) {
+      delete process.env["APPDATA"]
+    } else {
+      process.env["APPDATA"] = originalAppData
+    }
+  })
+
+  it("returns base directory when no app name is supplied", () => {
+    delete process.env["APPDATA"]
+    const basePath = getAppDataPath()
+    assert.ok(typeof basePath === "string" && basePath.length > 0)
+  })
+
+  it("resolves app directory under platform base path", () => {
+    delete process.env["APPDATA"]
+    const appPath = getAppDataPath("https-localhost")
+    const home = os.homedir()
+
+    switch (os.platform()) {
+      case "darwin":
+        assert.strictEqual(
+          appPath,
+          path.join(home, "Library", "Application Support", "https-localhost"),
+        )
+        break
+      case "win32":
+        assert.strictEqual(appPath, path.join(home, "AppData", "Roaming", "https-localhost"))
+        break
+      default:
+        assert.strictEqual(appPath, path.join(home, ".config", "https-localhost"))
+    }
+  })
+
+  it("prefers APPDATA environment variable when defined", () => {
+    process.env["APPDATA"] = "/tmp/custom-app-data"
+    assert.strictEqual(getAppDataPath(), "/tmp/custom-app-data")
+    assert.strictEqual(
+      getAppDataPath("https-localhost"),
+      path.join("/tmp/custom-app-data", "https-localhost"),
+    )
+  })
+})

test/certs.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert"
+import fs from "node:fs"
+import net from "node:net"
+import { afterEach, describe, it } from "node:test"
+import tls from "node:tls"
+
+import { generate, getCerts, remove } from "../src/certs.ts"
+import { getEnv } from "../src/env.ts"
+
+describe("certs", { timeout: 300000 }, () => {
+  afterEach(() => {
+    remove("test/custom-folder")
+    remove("test/custom folder")
+    delete process.env["CERT_PATH"]
+    delete process.env["HOST"]
+  })
+
+  it("can be uninstalled", () => {
+    remove()
+  })
+
+  it("uninstall is idempotent (doesn't fail if called twice)", () => {
+    remove()
+  })
+
+  it("can be installed", async () => {
+    await generate()
+  })
+
+  it("provides the certificate", async () => {
+    const env = getEnv()
+    const appCerts = await getCerts({
+      domain: env.HOST,
+      certPath: env.CERT_PATH,
+      reinstall: env.REINSTALL,
+    })
+    const realCerts = await getCerts({
+      domain: env.HOST,
+      certPath: env.CERT_PATH,
+      reinstall: env.REINSTALL,
+    })
+    assert.deepStrictEqual(appCerts, realCerts)
+  })
+
+  it("works with environment domain", async () => {
+    const appCerts = await getCerts({ domain: "192.168.0.1" })
+    const secureContext = tls.createSecureContext({
+      cert: appCerts.cert,
+    })
+    const secureSocket = new tls.TLSSocket(new net.Socket(), {
+      secureContext,
+    })
+    const cert = secureSocket.getCertificate()
+    assert(cert && "subjectaltname" in cert)
+    const certDomain = cert.subjectaltname?.split(":")[1]
+
+    assert.strictEqual(certDomain, "192.168.0.1")
+  })
+
+  it("crashes if certs do not exist in custom folder", async () => {
+    const customCertPath = "test/custom-folder"
+    await generate({ appDataPath: customCertPath })
+    fs.unlinkSync("test/custom-folder/localhost.crt")
+    fs.unlinkSync("test/custom-folder/localhost.key")
+
+    await assert.rejects(getCerts({ certPath: customCertPath }), /Certificates are missing/)
+    remove(customCertPath)
+  })
+})

test/cli.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert"
+import { spawn } from "node:child_process"
+import path from "node:path"
+import { describe, it } from "node:test"
+
+describe("cli", () => {
+  const cliPath = path.resolve("src/cli.ts")
+
+  it("CLI flags override environment", async () => {
+    const testDir = path.resolve("test")
+    const proc = spawn("node", [cliPath, "--port", "4448", testDir], {
+      env: { ...process.env, PORT: "4447" },
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+
+    try {
+      await new Promise<void>((resolve, reject) => {
+        proc.stdout.on("data", (data: Buffer) => {
+          if (data.toString().includes("Server running on port 4448")) resolve()
+        })
+        proc.stderr.on("data", (data: Buffer) => {
+          if (data.toString().includes("Server running on port 4448")) resolve()
+        })
+        proc.on("error", reject)
+        setTimeout(() => reject(new Error("Timeout waiting for server")), 5000)
+      })
+    } finally {
+      proc.kill("SIGTERM")
+    }
+  })
+
+  it("prints help when --help is passed", async () => {
+    const proc = spawn("node", [cliPath, "--help"], {
+      env: { ...process.env },
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+
+    let stdout = ""
+    await new Promise<void>((resolve, reject) => {
+      proc.stdout.on("data", (data: Buffer) => {
+        stdout += data.toString()
+      })
+      proc.on("close", () => resolve())
+      proc.on("error", reject)
+    })
+
+    assert.ok(stdout.includes("Usage: serve [options] [path]"))
+    assert.ok(stdout.includes("-p, --port"))
+  })
+})

test/env.test.ts

@@ -0,0 +1,50 @@
+import assert from "node:assert"
+import { afterEach, describe, it } from "node:test"
+
+import { envSchema, getEnv } from "../src/env.ts"
+
+describe("env", () => {
+  const originalEnv = { ...process.env }
+
+  afterEach(() => {
+    process.env = { ...originalEnv }
+  })
+
+  it("applies defaults when environment is empty", () => {
+    delete process.env["PORT"]
+    delete process.env["HOST"]
+    delete process.env["CERT_PATH"]
+    delete process.env["REINSTALL"]
+
+    const env = getEnv()
+    assert.strictEqual(env.PORT, 443)
+    assert.strictEqual(env.HOST, "localhost")
+    assert.strictEqual(env.CERT_PATH, undefined)
+    assert.strictEqual(env.REINSTALL, false)
+  })
+
+  it("reads values from process.env", () => {
+    process.env["PORT"] = "8443"
+    process.env["HOST"] = "test.local"
+    process.env["CERT_PATH"] = "/custom/path"
+    process.env["REINSTALL"] = "true"
+
+    const env = getEnv()
+    assert.strictEqual(env.PORT, 8443)
+    assert.strictEqual(env.HOST, "test.local")
+    assert.strictEqual(env.CERT_PATH, "/custom/path")
+    assert.strictEqual(env.REINSTALL, true)
+  })
+
+  it("allows explicit overrides to take precedence", () => {
+    process.env["PORT"] = "8443"
+    const env = getEnv({ PORT: 9443 })
+    assert.strictEqual(env.PORT, 9443)
+  })
+
+  it("rejects invalid ports", () => {
+    assert.throws(() => envSchema.parse({ PORT: "invalid" }))
+    assert.throws(() => envSchema.parse({ PORT: 0 }))
+    assert.throws(() => envSchema.parse({ PORT: 70000 }))
+  })
+})

test/helpers.ts

@@ -0,0 +1,76 @@
+import { execFileSync } from "node:child_process"
+import fs from "node:fs"
+import http from "node:http"
+import type { IncomingMessage, Server } from "node:http"
+import https from "node:https"
+import path from "node:path"
+
+import { getAppDataPath } from "../src/app-data-path.ts"
+
+const HTTPS_PORT = 4443
+const HTTP_PORT = 8080
+
+function getRootCA(): Buffer | undefined {
+  try {
+    const certDir = getAppDataPath("https-localhost")
+    const files = fs.readdirSync(certDir)
+    const exe = files.find(file => file.startsWith("mkcert"))
+    if (!exe) return undefined
+    const caRoot = execFileSync(path.join(certDir, exe), ["-CAROOT"]).toString().trim()
+    const rootCAPath = path.join(caRoot, "rootCA.pem")
+    if (fs.existsSync(rootCAPath)) {
+      return fs.readFileSync(rootCAPath)
+    }
+  } catch {
+    // Ignore error if CA root cannot be found yet
+  }
+  return undefined
+}
+
+async function closeServer(server: Server | undefined): Promise<void> {
+  if (!server || !server.listening) return
+  server.closeAllConnections()
+  server.closeIdleConnections()
+  await new Promise(resolve => server.close(resolve))
+}
+
+async function makeRequest(
+  requestPath = "/",
+  secure = true,
+  port: number | string = HTTPS_PORT,
+): Promise<{
+  data: string
+  statusCode?: number
+  headers: Record<string, string | string[] | undefined>
+}> {
+  const rootCA = secure ? getRootCA() : undefined
+  const options: https.RequestOptions = {
+    host: "localhost",
+    port: port,
+    path: requestPath,
+    method: "GET",
+    ca: rootCA ? [rootCA] : undefined,
+    agent: false,
+  }
+  const protocol = secure ? https : http
+  return new Promise((resolve, reject) => {
+    protocol
+      .request(options, (resp: IncomingMessage) => {
+        let data = ""
+        resp.on("data", (chunk: Buffer | string) => {
+          data += chunk
+        })
+        resp.on("end", () =>
+          resolve({
+            data: data,
+            statusCode: resp.statusCode,
+            headers: resp.headers,
+          }),
+        )
+      })
+      .on("error", (err: Error) => reject(err))
+      .end()
+  })
+}
+
+export { closeServer, HTTP_PORT, HTTPS_PORT, makeRequest }