1import assert from "node:assert/strict";
2import http from "node:http";
3import net from "node:net";
4import test, { type TestContext } from "node:test";
5 
6import { createSocksClient } from "./wechat-socks-http.ts";
7 
8interface EchoServer {
9  baseUrl: string;
10  port: number;
11  received: Array<{ method: string; url: string; headers: http.IncomingHttpHeaders; body: Buffer }>;
12}
13 
14async function startEchoServer(t: TestContext): Promise<EchoServer> {
15  const received: EchoServer["received"] = [];
16  const server = http.createServer((req, res) => {
17    const chunks: Buffer[] = [];
18    req.on("data", (chunk: Buffer) => chunks.push(chunk));
19    req.on("end", () => {
20      received.push({
21        method: req.method ?? "",
22        url: req.url ?? "",
23        headers: req.headers,
24        body: Buffer.concat(chunks),
25      });
26      res.statusCode = 200;
27      res.setHeader("Content-Type", "application/json");
28      res.end(JSON.stringify({ ok: true, url: req.url }));
29    });
30  });
31  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
32  const address = server.address();
33  if (!address || typeof address === "string") throw new Error("echo server bind failed");
34  const port = address.port;
35  t.after(async () => {
36    await new Promise<void>((resolve) => server.close(() => resolve()));
37  });
38  return { baseUrl: `http://127.0.0.1:${port}`, port, received };
39}
40 
41interface FakeSocks5 {
42  port: number;
43  connectionCount: () => number;
44  destinations: () => Array<{ host: string; port: number }>;
45}
46 
47async function startFakeSocks5(t: TestContext): Promise<FakeSocks5> {
48  let connectionCount = 0;
49  const destinations: Array<{ host: string; port: number }> = [];
50 
51  const server = net.createServer((client) => {
52    connectionCount++;
53    let phase: "greeting" | "request" | "tunnel" = "greeting";
54    let buf = Buffer.alloc(0);
55    let upstream: net.Socket | undefined;
56 
57    const tryParse = () => {
58      if (phase === "greeting") {
59        if (buf.length < 2) return;
60        const nMethods = buf[1]!;
61        if (buf.length < 2 + nMethods) return;
62        buf = buf.subarray(2 + nMethods);
63        client.write(Buffer.from([0x05, 0x00]));
64        phase = "request";
65      }
66      if (phase === "request") {
67        if (buf.length < 5) return;
68        if (buf[0] !== 0x05 || buf[1] !== 0x01) {
69          client.destroy();
70          return;
71        }
72        const atyp = buf[3];
73        let addrEnd: number;
74        let host: string;
75        if (atyp === 0x01) {
76          if (buf.length < 4 + 4 + 2) return;
77          host = `${buf[4]}.${buf[5]}.${buf[6]}.${buf[7]}`;
78          addrEnd = 4 + 4;
79        } else if (atyp === 0x03) {
80          const dlen = buf[4]!;
81          if (buf.length < 4 + 1 + dlen + 2) return;
82          host = buf.subarray(5, 5 + dlen).toString("ascii");
83          addrEnd = 4 + 1 + dlen;
84        } else {
85          client.destroy();
86          return;
87        }
88        const port = (buf[addrEnd]! << 8) | buf[addrEnd + 1]!;
89        destinations.push({ host, port });
90        const totalLen = addrEnd + 2;
91        const remaining = buf.subarray(totalLen);
92        buf = Buffer.alloc(0);
93 
94        upstream = net.connect({ host, port }, () => {
95          client.write(Buffer.from([0x05, 0x00, 0x00, 0x01, 0, 0, 0, 0, 0, 0]));
96          phase = "tunnel";
97          if (remaining.length > 0) {
98            upstream!.write(remaining);
99          }
100        });
101        upstream.on("data", (data: Buffer) => {
102          client.write(data);
103        });
104        upstream.on("end", () => {
105          try { client.end(); } catch { /* noop */ }
106        });
107        upstream.on("error", () => {
108          try { client.destroy(); } catch { /* noop */ }
109        });
110      }
111    };
112 
113    client.on("data", (chunk: Buffer) => {
114      if (phase === "tunnel") {
115        upstream?.write(chunk);
116        return;
117      }
118      buf = Buffer.concat([buf, chunk]);
119      tryParse();
120    });
121    client.on("end", () => {
122      try { upstream?.end(); } catch { /* noop */ }
123    });
124    client.on("error", () => {
125      try { upstream?.destroy(); } catch { /* noop */ }
126    });
127  });
128 
129  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
130  const address = server.address();
131  if (!address || typeof address === "string") throw new Error("socks server bind failed");
132  const port = address.port;
133  t.after(async () => {
134    await new Promise<void>((resolve) => server.close(() => resolve()));
135  });
136  return {
137    port,
138    connectionCount: () => connectionCount,
139    destinations: () => destinations,
140  };
141}
142 
143test("createSocksClient routes plain HTTP through the SOCKS5 proxy", async (t) => {
144  const echo = await startEchoServer(t);
145  const socks = await startFakeSocks5(t);
146 
147  const client = createSocksClient({ host: "127.0.0.1", port: socks.port });
148 
149  const res = await client(`${echo.baseUrl}/cgi-bin/token?appid=AID`);
150 
151  assert.equal(res.status, 200);
152  const data = await res.json<{ ok: boolean; url: string }>();
153  assert.equal(data.ok, true);
154  assert.equal(data.url, "/cgi-bin/token?appid=AID");
155 
156  assert.equal(
157    socks.connectionCount(),
158    1,
159    "SOCKS5 proxy must have received exactly one connection (proves bytes were routed through it)",
160  );
161 
162  const dests = socks.destinations();
163  assert.equal(dests.length, 1);
164  assert.equal(dests[0]!.host, "127.0.0.1");
165  assert.equal(dests[0]!.port, echo.port);
166 
167  assert.equal(echo.received.length, 1);
168  assert.equal(echo.received[0]!.method, "GET");
169  assert.equal(echo.received[0]!.url, "/cgi-bin/token?appid=AID");
170});
171 
172test("createSocksClient sends POST body through the SOCKS5 proxy", async (t) => {
173  const echo = await startEchoServer(t);
174  const socks = await startFakeSocks5(t);
175 
176  const client = createSocksClient({ host: "127.0.0.1", port: socks.port });
177 
178  const body = JSON.stringify({ articles: [{ title: "hi" }] });
179  const res = await client(`${echo.baseUrl}/cgi-bin/draft/add?access_token=T`, {
180    method: "POST",
181    headers: { "Content-Type": "application/json" },
182    body,
183  });
184 
185  assert.equal(res.status, 200);
186  assert.equal(socks.connectionCount(), 1);
187  assert.equal(echo.received.length, 1);
188  assert.equal(echo.received[0]!.method, "POST");
189  assert.equal(echo.received[0]!.headers["content-type"], "application/json");
190  assert.equal(echo.received[0]!.headers["content-length"], String(Buffer.byteLength(body)));
191  assert.equal(echo.received[0]!.body.toString("utf-8"), body);
192});
193 
194test("createSocksClient rejects invalid proxy ports", () => {
195  assert.throws(
196    () => createSocksClient({ host: "127.0.0.1", port: 0 }),
197    /Invalid SOCKS proxy port/,
198  );
199  assert.throws(
200    () => createSocksClient({ host: "127.0.0.1", port: 70_000 }),
201    /Invalid SOCKS proxy port/,
202  );
203  assert.throws(
204    () => createSocksClient({ host: "", port: 1080 }),
205    /SOCKS proxy host required/,
206  );
207});
208