1import assert from "node:assert/strict";
2import net from "node:net";
3import test from "node:test";
4 
5import {
6  buildSshArgs,
7  findFreePort,
8  normalizeRemoteConfig,
9} from "./wechat-remote-publish.ts";
10 
11test("normalizeRemoteConfig requires a host", () => {
12  assert.throws(
13    () => normalizeRemoteConfig({ host: "" }),
14    /Remote publish host is required/,
15  );
16  assert.throws(
17    () => normalizeRemoteConfig({ host: "   " }),
18    /Remote publish host is required/,
19  );
20});
21 
22test("normalizeRemoteConfig applies user/port defaults and trims host", () => {
23  const result = normalizeRemoteConfig({ host: "  example.com  " });
24  assert.equal(result.host, "example.com");
25  assert.equal(result.user, "root");
26  assert.equal(result.port, 22);
27  assert.equal(result.identityFile, undefined);
28  assert.equal(result.knownHostsFile, undefined);
29  assert.equal(result.strictHostKeyChecking, undefined);
30  assert.equal(result.connectTimeout, undefined);
31  assert.equal(result.proxyJump, undefined);
32});
33 
34test("normalizeRemoteConfig preserves explicit user, port, and SSH options", () => {
35  const result = normalizeRemoteConfig({
36    host: "example.com",
37    user: "deploy",
38    port: 2222,
39    identityFile: "/home/me/.ssh/id_ed25519",
40    knownHostsFile: "/home/me/.ssh/known_hosts",
41    strictHostKeyChecking: "accept-new",
42    connectTimeout: 15,
43    proxyJump: "bastion.example.com",
44  });
45  assert.equal(result.user, "deploy");
46  assert.equal(result.port, 2222);
47  assert.equal(result.identityFile, "/home/me/.ssh/id_ed25519");
48  assert.equal(result.knownHostsFile, "/home/me/.ssh/known_hosts");
49  assert.equal(result.strictHostKeyChecking, "accept-new");
50  assert.equal(result.connectTimeout, 15);
51  assert.equal(result.proxyJump, "bastion.example.com");
52});
53 
54test("normalizeRemoteConfig rejects invalid port", () => {
55  assert.throws(
56    () => normalizeRemoteConfig({ host: "example.com", port: 0 }),
57    /Invalid remote publish port/,
58  );
59  assert.throws(
60    () => normalizeRemoteConfig({ host: "example.com", port: 65536 }),
61    /Invalid remote publish port/,
62  );
63  assert.throws(
64    () => normalizeRemoteConfig({ host: "example.com", port: 1.5 }),
65    /Invalid remote publish port/,
66  );
67});
68 
69test("normalizeRemoteConfig rejects invalid connect timeout", () => {
70  assert.throws(
71    () => normalizeRemoteConfig({ host: "example.com", connectTimeout: 0 }),
72    /Invalid remote_publish_connect_timeout/,
73  );
74  assert.throws(
75    () => normalizeRemoteConfig({ host: "example.com", connectTimeout: -3 }),
76    /Invalid remote_publish_connect_timeout/,
77  );
78});
79 
80test("normalizeRemoteConfig rejects invalid strict host key checking", () => {
81  assert.throws(
82    () =>
83      normalizeRemoteConfig({
84        host: "example.com",
85        // eslint-disable-next-line @typescript-eslint/no-explicit-any
86        strictHostKeyChecking: "maybe" as any,
87      }),
88    /Invalid remote_publish_strict_host_key_checking/,
89  );
90});
91 
92test("normalizeRemoteConfig falls back to default user when blank string provided", () => {
93  const result = normalizeRemoteConfig({ host: "example.com", user: "   " });
94  assert.equal(result.user, "root");
95});
96 
97test("buildSshArgs emits the whitelisted minimum set", () => {
98  const args = buildSshArgs(
99    { host: "example.com", user: "root", port: 22 },
100    1080,
101  );
102  assert.deepEqual(args, [
103    "-N",
104    "-T",
105    "-D", "127.0.0.1:1080",
106    "-o", "ExitOnForwardFailure=yes",
107    "-o", "ServerAliveInterval=30",
108    "-o", "ServerAliveCountMax=3",
109    "-p", "22",
110    "[email protected]",
111  ]);
112});
113 
114test("buildSshArgs threads optional ssh options in stable order", () => {
115  const args = buildSshArgs(
116    {
117      host: "example.com",
118      user: "deploy",
119      port: 2222,
120      identityFile: "/p/id_ed25519",
121      knownHostsFile: "/p/known_hosts",
122      strictHostKeyChecking: "accept-new",
123      connectTimeout: 12,
124      proxyJump: "bastion.example.com",
125    },
126    1080,
127  );
128  assert.deepEqual(args, [
129    "-N",
130    "-T",
131    "-D", "127.0.0.1:1080",
132    "-o", "ExitOnForwardFailure=yes",
133    "-o", "ServerAliveInterval=30",
134    "-o", "ServerAliveCountMax=3",
135    "-p", "2222",
136    "-i", "/p/id_ed25519",
137    "-o", "UserKnownHostsFile=/p/known_hosts",
138    "-o", "StrictHostKeyChecking=accept-new",
139    "-o", "ConnectTimeout=12",
140    "-J", "bastion.example.com",
141    "[email protected]",
142  ]);
143});
144 
145test("buildSshArgs does not emit raw ssh options for unknown fields", () => {
146  const args = buildSshArgs(
147    {
148      host: "example.com",
149      user: "root",
150      port: 22,
151      // No extra unknown keys are accepted — typed config is the whitelist.
152    },
153    1080,
154  );
155  assert.equal(
156    args.filter((a) => a === "-o" || a.startsWith("--")).length,
157    3, // ExitOnForwardFailure, ServerAliveInterval, ServerAliveCountMax (and only those)
158    "buildSshArgs must only emit the three baseline -o options when no extras given",
159  );
160});
161 
162test("buildSshArgs rejects invalid SOCKS port", () => {
163  assert.throws(
164    () => buildSshArgs({ host: "example.com", user: "root", port: 22 }, 0),
165    /Invalid SOCKS port/,
166  );
167  assert.throws(
168    () => buildSshArgs({ host: "example.com", user: "root", port: 22 }, 70_000),
169    /Invalid SOCKS port/,
170  );
171});
172 
173test("findFreePort returns a usable loopback port", async () => {
174  const port = await findFreePort();
175  assert.ok(port > 0 && port < 65536, `expected valid port, got ${port}`);
176 
177  await new Promise<void>((resolve, reject) => {
178    const server = net.createServer();
179    server.unref();
180    server.once("error", reject);
181    server.listen(port, "127.0.0.1", () => {
182      server.close((err) => (err ? reject(err) : resolve()));
183    });
184  });
185});
186