automaticPort.test.ts

import { describe, expect, it } from "@effect/vitest";
import * as NetService from "@t3tools/shared/Net";
import * as Effect from "effect/Effect";
import * as CliError from "effect/cli/CliError";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as PlatformError from "effect/PlatformError";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";

import * as ProcessRunner from "../processRunner.ts";
import * as AutomaticPort from "./automaticPort.ts";

const WSL_KERNEL = "6.6.87.2-microsoft-standard-WSL2\n";
const NETSTAT_PATH = "/windows/c/Windows/System32/netstat.exe";

const output = (stdout: string, code: number | null = null): ProcessRunner.ProcessRunOutput => ({
  stdout,
  stderr: "",
  code: code === null ? null : ChildProcessSpawner.ExitCode(code),
  timedOut: false,
  stdoutTruncated: false,
  stderrTruncated: false,
  stdoutInvalidUtf8: false,
  stderrInvalidUtf8: false,
});

const listening = (ports: ReadonlyArray<number>, host = "127.0.0.1", foreign = "0.0.0.0:0") =>
  ports.map((port) => `  TCP    ${host}:${port}    ${foreign}    ABHÖREN    4242`).join("\r\n");

interface Scenario {
  readonly kernelRelease?: string;
  readonly windowsPorts?: ReadonlyArray<number>;
  readonly windowsPortsV6?: ReadonlyArray<number>;
  readonly tcpv6ExitCode?: number;
  readonly wslpathMissing?: boolean;
  readonly reservedPorts?: ReadonlyArray<number>;
}

const select = (scenario: Scenario) => {
  const commands: string[] = [];
  const reserved = [...(scenario.reservedPorts ?? [50_001])];
  const net: NetService.NetServiceShape = {
    canListenOnHost: () => Effect.succeed(true),
    hasListenerOnHost: () => Effect.succeed(false),
    isPortAvailableOnLoopback: () => Effect.succeed(true),
    reserveLoopbackPort: () => Effect.sync(() => reserved.shift() ?? 60_000),
    findAvailablePort: Effect.succeed,
  };
  const run: ProcessRunner.ProcessRunner["Service"]["run"] = (input) => {
    commands.push(input.command);
    if (input.command === "wslpath") {
      if (scenario.wslpathMissing) {
        return Effect.fail(
          new ProcessRunner.ProcessSpawnError({
            command: input.command,
            argumentCount: input.args.length,
            cause: PlatformError.systemError({
              _tag: "NotFound",
              module: "ChildProcess",
              method: "spawn",
            }),
          }),
        );
      }
      return Effect.succeed(output(`${NETSTAT_PATH}\n`));
    }
    if (input.args.includes("tcpv6")) {
      return Effect.succeed(
        output(
          listening(scenario.windowsPortsV6 ?? [], "[::1]", "[::]:0"),
          scenario.tcpv6ExitCode ?? null,
        ),
      );
    }
    return Effect.succeed(output(listening(scenario.windowsPorts ?? [])));
  };
  const layer = Layer.mergeAll(
    Layer.succeed(NetService.NetService, net),
    Layer.succeed(ProcessRunner.ProcessRunner, { run }),
    FileSystem.layerNoop({
      readFileString: (path) =>
        path === "/proc/sys/kernel/osrelease" && scenario.kernelRelease !== undefined
          ? Effect.succeed(scenario.kernelRelease)
          : Effect.fail(
              PlatformError.systemError({
                _tag: "NotFound",
                module: "FileSystem",
                method: "readFileString",
              }),
            ),
    }),
  );
  return Effect.gen(function* () {
    const selectAutomaticPort = yield* AutomaticPort.make;
    const port = yield* selectAutomaticPort(3773);
    return { port, commands };
  }).pipe(Effect.provide(layer));
};

describe("automatic port selection", () => {
  it.effect("moves off the default port only when Windows already listens on it", () =>
    Effect.gen(function* () {
      const free = yield* select({ kernelRelease: WSL_KERNEL, windowsPorts: [8080] });
      expect(free.port).toBe(3773);
      expect(free.commands).toEqual(["wslpath", NETSTAT_PATH, NETSTAT_PATH]);

      const owned = yield* select({ kernelRelease: WSL_KERNEL, windowsPorts: [3773] });
      expect(owned.port).toBe(50_001);
    }),
  );

  it.effect("retries a fallback port that Windows already listens on", () =>
    Effect.gen(function* () {
      const result = yield* select({
        kernelRelease: WSL_KERNEL,
        windowsPorts: [3773],
        windowsPortsV6: [50_001],
        reservedPorts: [50_001, 50_002],
      });
      expect(result.port).toBe(50_002);
    }),
  );

  it.effect("fails with an actionable error when every fallback belongs to Windows", () =>
    Effect.gen(function* () {
      const ports = Array.from({ length: 8 }, (_, index) => 50_001 + index);
      const error = yield* select({
        kernelRelease: WSL_KERNEL,
        windowsPorts: [3773],
        windowsPortsV6: ports,
        reservedPorts: ports,
      }).pipe(Effect.flip);
      expect(error).toBeInstanceOf(CliError.UserError);
      expect(error.cause).toContain("--port");
    }),
  );

  it.effect("keeps the local choice when the Windows snapshot is unavailable", () =>
    Effect.gen(function* () {
      const partial = yield* select({
        kernelRelease: WSL_KERNEL,
        windowsPorts: [3773],
        tcpv6ExitCode: 1,
      });
      expect(partial.port).toBe(3773);

      const noInterop = yield* select({ kernelRelease: WSL_KERNEL, wslpathMissing: true });
      expect(noInterop.port).toBe(3773);
    }),
  );

  it.effect("never queries Windows outside WSL", () =>
    Effect.gen(function* () {
      for (const scenario of [
        { kernelRelease: "6.8.0-45-generic\n" },
        // macOS and Windows have no kernel release file.
        {},
      ] satisfies ReadonlyArray<Scenario>) {
        const result = yield* select(scenario);
        expect(result.port).toBe(3773);
        expect(result.commands).toEqual([]);
      }
    }),
  );
});