1import assert from "node:assert/strict";
2import http from "node:http";
3import test, { type TestContext } from "node:test";
4 
5import { buildMultipart, wechatHttp } from "./wechat-http.ts";
6 
7interface ReceivedRequest {
8  method: string;
9  url: string;
10  headers: http.IncomingHttpHeaders;
11  body: Buffer;
12}
13 
14async function startEchoServer(t: TestContext): Promise<{ baseUrl: string; received: ReceivedRequest[] }> {
15  const received: ReceivedRequest[] = [];
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, echo: { url: req.url, method: req.method } }));
29    });
30  });
31 
32  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
33  const address = server.address();
34  if (!address || typeof address === "string") {
35    throw new Error("Failed to start echo server");
36  }
37  const baseUrl = `http://127.0.0.1:${address.port}`;
38 
39  t.after(async () => {
40    await new Promise<void>((resolve) => server.close(() => resolve()));
41  });
42 
43  return { baseUrl, received };
44}
45 
46test("wechatHttp performs a GET and passes through query string", async (t) => {
47  const { baseUrl, received } = await startEchoServer(t);
48  const res = await wechatHttp(`${baseUrl}/cgi-bin/token?grant_type=client_credential&appid=AID`);
49  assert.equal(res.status, 200);
50  const data = await res.json<{ ok: boolean; echo: { url: string; method: string } }>();
51  assert.equal(data.ok, true);
52  assert.equal(received.length, 1);
53  assert.equal(received[0]!.method, "GET");
54  assert.equal(received[0]!.url, "/cgi-bin/token?grant_type=client_credential&appid=AID");
55  assert.equal(received[0]!.body.length, 0);
56});
57 
58test("wechatHttp POST sends JSON body with content-length header", async (t) => {
59  const { baseUrl, received } = await startEchoServer(t);
60  const body = JSON.stringify({ articles: [{ title: "hi" }] });
61  const res = await wechatHttp(`${baseUrl}/cgi-bin/draft/add?access_token=T`, {
62    method: "POST",
63    headers: { "Content-Type": "application/json" },
64    body,
65  });
66  assert.equal(res.status, 200);
67  assert.equal(received.length, 1);
68  assert.equal(received[0]!.method, "POST");
69  assert.equal(received[0]!.headers["content-type"], "application/json");
70  assert.equal(received[0]!.headers["content-length"], String(Buffer.byteLength(body)));
71  assert.equal(received[0]!.body.toString("utf-8"), body);
72});
73 
74test("wechatHttp .text() returns the raw response body", async (t) => {
75  const { baseUrl } = await startEchoServer(t);
76  const res = await wechatHttp(`${baseUrl}/hello`);
77  const text = await res.text();
78  assert.match(text, /"ok":true/);
79});
80 
81test("wechatHttp .buffer() returns a Buffer of the response body", async (t) => {
82  const { baseUrl } = await startEchoServer(t);
83  const res = await wechatHttp(`${baseUrl}/`);
84  const buf = await res.buffer();
85  assert.ok(Buffer.isBuffer(buf));
86  assert.ok(buf.length > 0);
87});
88 
89test("buildMultipart produces a parsable multipart payload", () => {
90  const fileData = Buffer.from("ZZZ");
91  const { contentType, body } = buildMultipart([
92    {
93      name: "media",
94      filename: "image.png",
95      contentType: "image/png",
96      data: fileData,
97    },
98  ]);
99 
100  const boundaryMatch = contentType.match(/^multipart\/form-data; boundary=(.+)$/);
101  assert.ok(boundaryMatch, `expected boundary in Content-Type, got ${contentType}`);
102  const boundary = boundaryMatch![1]!;
103  const text = body.toString("binary");
104  assert.ok(text.startsWith(`--${boundary}\r\n`), "body must start with opening boundary");
105  assert.ok(
106    text.endsWith(`--${boundary}--\r\n`),
107    "body must end with closing boundary",
108  );
109  assert.match(
110    text,
111    /Content-Disposition: form-data; name="media"; filename="image\.png"\r\n/,
112  );
113  assert.match(text, /Content-Type: image\/png\r\n/);
114  // The raw file bytes must appear verbatim after a blank line.
115  assert.ok(
116    text.includes("\r\n\r\nZZZ\r\n"),
117    "body must contain the raw file bytes after the part headers",
118  );
119});
120 
121test("wechatHttp accepts a multipart body produced by buildMultipart", async (t) => {
122  const { baseUrl, received } = await startEchoServer(t);
123  const fileData = Buffer.from("HELLO");
124  const multipart = buildMultipart([
125    { name: "media", filename: "x.png", contentType: "image/png", data: fileData },
126  ]);
127  const res = await wechatHttp(`${baseUrl}/cgi-bin/media/uploadimg?access_token=T`, {
128    method: "POST",
129    headers: { "Content-Type": multipart.contentType },
130    body: multipart.body,
131  });
132  assert.equal(res.status, 200);
133  assert.equal(received.length, 1);
134  assert.equal(received[0]!.method, "POST");
135  assert.match(received[0]!.headers["content-type"]!, /^multipart\/form-data; boundary=/);
136  assert.ok(received[0]!.body.includes(Buffer.from("HELLO")));
137});
138 
139