package fun import ( "os" "os/exec" "path/filepath" "strings" "testing" ) func TestTypeScriptClientBehavior(t *testing.T) { node, err := exec.LookPath("node") if err != nil { t.Skip("node is not installed") } probe := exec.Command(node, "--experimental-strip-types", "--input-type=module", "-e", `if (typeof fetch !== "function" || typeof ReadableStream !== "function") process.exit(1)`) if err := probe.Run(); err != nil { t.Skip("node does not support TypeScript stripping and web streams") } dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "client.ts"), []byte(templateTs{}.genClientTemplate()), 0o644); err != nil { t.Fatal(err) } const script = ` import assert from "node:assert/strict"; import { Client } from "./client.ts"; const json = (value, status = 200) => new Response(JSON.stringify(value), { status, headers: { "Content-Type": "application/json" }, }); const ndjson = body => new Response(body, { headers: { "Content-Type": "application/x-ndjson; charset=utf-8" }, }); const client = new Client("http://example.test///"); const seen = []; let cleanupCheck; client.addResponseInterceptor((_service, _method, result) => { if (cleanupCheck) { assert.equal(cleanupCheck(), true); cleanupCheck = undefined; } seen.push(result.status); }); const expectSeen = status => assert.deepEqual(seen.splice(0), [status]); let fetchInit; globalThis.fetch = async (url, init) => { fetchInit = { url, init }; return json({ status: 0, data: "ok" }); }; let result = await client.request("Svc", "fetchShape", undefined, { signal: new AbortController().signal }); assert.equal(result.status, 0); assert.equal(fetchInit.url, "http://example.test/cell"); assert.equal(fetchInit.init.method, "POST"); assert.equal(fetchInit.init.headers["Content-Type"], "application/json"); assert.ok(fetchInit.init.signal); assert.deepEqual(JSON.parse(fetchInit.init.body), { serviceName: "Svc", methodName: "fetchShape" }); expectSeen(0); globalThis.fetch = async () => json({ status: 2, code: 4001, msg: "business" }, 503); result = await client.request("Svc", "business"); assert.deepEqual(result, { status: 2, code: 4001, msg: "business" }); expectSeen(2); globalThis.fetch = async () => json({ status: 1, msg: "framework" }, 500); result = await client.request("Svc", "framework"); assert.deepEqual(result, { status: 1, msg: "framework" }); expectSeen(1); globalThis.fetch = async () => new Response("gateway timeout", { status: 504 }); result = await client.request("Svc", "gatewayTimeout"); assert.equal(result.status, 5); assert.match(result.msg, /504/); expectSeen(5); globalThis.fetch = async () => new Response("request timeout", { status: 408 }); result = await client.request("Svc", "gateway408"); assert.equal(result.status, 5); expectSeen(5); globalThis.fetch = async () => json({ status: 5, msg: "server timeout" }); result = await client.request("Svc", "serverTimeout"); assert.equal(result.status, 5); assert.equal(result.msg, "server timeout"); expectSeen(5); globalThis.fetch = async () => new Response("bad gateway", { status: 502 }); result = await client.request("Svc", "gateway"); assert.equal(result.status, 4); expectSeen(4); globalThis.fetch = async () => new Response("", { status: 200 }); result = await client.request("Svc", "empty"); assert.equal(result.status, 1); assert.match(result.msg, /Empty/); expectSeen(1); globalThis.fetch = async () => new Response("not-json", { status: 200 }); result = await client.request("Svc", "invalidJson"); assert.equal(result.status, 1); assert.match(result.msg, /Invalid JSON/); expectSeen(1); globalThis.fetch = async () => new Response("login", { status: 200, headers: { "Content-Type": "text/html" }, }); result = await client.request("Svc", "html"); assert.equal(result.status, 1); assert.match(result.msg, /HTML/); expectSeen(1); globalThis.fetch = async () => json({ data: 1 }); result = await client.request("Svc", "invalidResult"); assert.equal(result.status, 1); expectSeen(1); globalThis.fetch = async () => { throw new TypeError("DNS failed"); }; result = await client.request("Svc", "network"); assert.equal(result.status, 4); assert.match(result.msg, /DNS failed/); expectSeen(4); globalThis.fetch = async () => new Response(new ReadableStream({ pull(controller) { controller.error(new Error("body read failed")); }, })); result = await client.request("Svc", "bodyRead"); assert.equal(result.status, 4); assert.match(result.msg, /body read failed/); expectSeen(4); const manualAbort = new AbortController(); manualAbort.abort(); globalThis.fetch = async () => { throw new DOMException("aborted", "AbortError"); }; result = await client.request("Svc", "abort", undefined, { signal: manualAbort.signal }); assert.equal(result.status, 4); assert.match(result.msg, /aborted/i); expectSeen(4); const timeoutAbort = new AbortController(); timeoutAbort.abort(new DOMException("timed out", "TimeoutError")); result = await client.request("Svc", "timeoutSignal", undefined, { signal: timeoutAbort.signal }); assert.equal(result.status, 5); expectSeen(5); globalThis.fetch = async () => { throw new DOMException("timed out", "TimeoutError"); }; result = await client.request("Svc", "timeoutError"); assert.equal(result.status, 5); expectSeen(5); const requestInterceptorClient = new Client("http://example.test"); let requestInterceptorSeen; requestInterceptorClient.addRequestInterceptor((_service, _method, state, dto) => { state.token = "abc"; requestInterceptorSeen = dto; }); requestInterceptorClient.addResponseInterceptor((_service, _method, value) => ({ ...value, msg: "intercepted" })); globalThis.fetch = async (_url, init) => { const payload = JSON.parse(init.body); assert.deepEqual(payload.state, { token: "abc" }); return json({ status: 0 }); }; result = await requestInterceptorClient.request("Svc", "interceptors", { value: 1 }); assert.deepEqual(requestInterceptorSeen, { value: 1 }); assert.equal(result.msg, "intercepted"); const failingRequestInterceptor = new Client("http://example.test"); let normalized = []; failingRequestInterceptor.addRequestInterceptor(() => { throw new Error("request hook"); }); failingRequestInterceptor.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); }); result = await failingRequestInterceptor.request("Svc", "hook"); assert.equal(result.status, 1); assert.match(result.msg, /request hook/); assert.deepEqual(normalized, [1]); const failingResponseInterceptor = new Client("http://example.test"); normalized = []; failingResponseInterceptor.addResponseInterceptor(() => { throw new Error("response hook"); }); failingResponseInterceptor.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); }); globalThis.fetch = async () => json({ status: 2, code: 4003, msg: "original" }); result = await failingResponseInterceptor.request("Svc", "responseHook"); assert.equal(result.status, 1); assert.match(result.msg, /response hook/); assert.deepEqual(normalized, [1]); const cyclic = {}; cyclic.self = cyclic; globalThis.fetch = async () => assert.fail("fetch must not run for serialization failure"); result = await client.request("Svc", "serialize", cyclic); assert.equal(result.status, 1); assert.match(result.msg, /serialize/i); expectSeen(1); globalThis.fetch = async () => json({ status: 2, code: 4002, msg: "stream business" }, 422); result = await client.stream("Svc", "streamBusiness", undefined, () => {}); assert.deepEqual(result, { status: 2, code: 4002, msg: "stream business" }); expectSeen(2); globalThis.fetch = async () => json({ status: 0 }); result = await client.stream("Svc", "wrongMedia", undefined, () => {}); assert.equal(result.status, 1); assert.match(result.msg, /x-ndjson/); expectSeen(1); const bytes = new TextEncoder().encode('{"text":"你好"}\r\n\n{"n":2}'); const split = bytes.indexOf(0xe5) + 1; globalThis.fetch = async () => new Response(new ReadableStream({ start(controller) { controller.enqueue(bytes.slice(0, split)); controller.enqueue(bytes.slice(split)); controller.close(); }, }), { headers: { "Content-Type": "application/x-ndjson; charset=utf-8" } }); const messages = []; result = await client.stream("Svc", "valid", undefined, value => messages.push(value)); assert.equal(result.status, 0); assert.deepEqual(messages, [{ text: "你好" }, { n: 2 }]); expectSeen(0); let malformedCancelled = false; globalThis.fetch = async () => new Response(new ReadableStream({ start(controller) { controller.enqueue(new TextEncoder().encode("bad\n")); }, cancel() { malformedCancelled = true; }, }), { headers: { "Content-Type": "application/x-ndjson" } }); cleanupCheck = () => malformedCancelled; result = await client.stream("Svc", "malformed", undefined, () => {}); assert.equal(result.status, 1); assert.match(result.msg, /line 1/); assert.equal(malformedCancelled, true); expectSeen(1); globalThis.fetch = async () => ndjson('{"n":1}\n'); result = await client.stream("Svc", "callback", undefined, () => { throw new Error("callback boom"); }); assert.equal(result.status, 1); assert.match(result.msg, /callback boom/); expectSeen(1); globalThis.fetch = async () => new Response(new ReadableStream({ pull(controller) { controller.error(new Error("read boom")); }, }), { headers: { "Content-Type": "application/x-ndjson" } }); result = await client.stream("Svc", "read", undefined, () => {}); assert.equal(result.status, 4); assert.match(result.msg, /read boom/); expectSeen(4); globalThis.fetch = async () => ndjson(new Uint8Array([0xff, 0x0a])); result = await client.stream("Svc", "utf8", undefined, () => {}); assert.equal(result.status, 1); assert.match(result.msg, /UTF-8/); expectSeen(1); globalThis.fetch = async () => ndjson(""); result = await client.stream("Svc", "emptyStream", undefined, () => assert.fail("empty stream callback")); assert.deepEqual(result, { status: 0 }); expectSeen(0); globalThis.fetch = async () => new Response(null, { headers: { "Content-Type": "application/x-ndjson" }, }); result = await client.stream("Svc", "nullBody", undefined, () => assert.fail("null stream callback")); assert.deepEqual(result, { status: 0 }); expectSeen(0); const streamAbort = new AbortController(); streamAbort.abort(); globalThis.fetch = async () => { throw new DOMException("aborted", "AbortError"); }; result = await client.stream("Svc", "abortStream", undefined, () => {}, { signal: streamAbort.signal }); assert.equal(result.status, 4); expectSeen(4); const readAbort = new AbortController(); globalThis.fetch = async () => new Response(new ReadableStream({ start(controller) { readAbort.signal.addEventListener("abort", () => controller.error(new DOMException("aborted", "AbortError")), { once: true }); readAbort.abort(); }, }), { headers: { "Content-Type": "application/x-ndjson" } }); result = await client.stream("Svc", "readAbort", undefined, () => {}, { signal: readAbort.signal }); assert.equal(result.status, 4); assert.match(result.msg, /aborted/i); expectSeen(4); const readTimeout = new AbortController(); readTimeout.abort(new DOMException("timed out", "TimeoutError")); globalThis.fetch = async () => new Response(new ReadableStream({ pull(controller) { controller.error(new DOMException("aborted", "AbortError")); }, }), { headers: { "Content-Type": "application/x-ndjson" } }); result = await client.stream("Svc", "timeoutStream", undefined, () => {}, { signal: readTimeout.signal }); assert.equal(result.status, 5); expectSeen(5); const streamHookClient = new Client("http://example.test"); normalized = []; streamHookClient.addRequestInterceptor(() => { throw new Error("stream hook"); }); streamHookClient.addResponseInterceptor((_s, _m, value) => { normalized.push(value.status); }); result = await streamHookClient.stream("Svc", "hook", undefined, () => {}); assert.equal(result.status, 1); assert.deepEqual(normalized, [1]); ` scriptPath := filepath.Join(dir, "behavior.mjs") if err := os.WriteFile(scriptPath, []byte(script), 0o644); err != nil { t.Fatal(err) } command := exec.Command(node, "--experimental-strip-types", scriptPath) if output, err := command.CombinedOutput(); err != nil { t.Fatalf("TypeScript client behavior failed: %v\n%s", err, output) } } func TestTypeScriptClientStrictTypecheck(t *testing.T) { tsc, err := exec.LookPath("tsc") if err != nil { t.Skip("tsc is not installed") } dir := t.TempDir() path := filepath.Join(dir, "client.ts") if err := os.WriteFile(path, []byte(templateTs{}.genClientTemplate()), 0o644); err != nil { t.Fatal(err) } command := exec.Command(tsc, "--strict", "--noEmit", "--target", "ES2022", "--module", "ESNext", "--lib", "ES2022,DOM", path) if output, err := command.CombinedOutput(); err != nil { t.Fatalf("strict TypeScript check failed: %v\n%s", err, output) } } func TestTypeScriptClientSimplicityGate(t *testing.T) { source := templateTs{}.genClientTemplate() + templateTs{}.genServiceTemplate() for _, forbidden := range []string{"RpcError", "httpStatus", "result.aborted", "ClientErrorCode", "setTimeout"} { if strings.Contains(source, forbidden) { t.Errorf("generated TypeScript templates contain forbidden %q", forbidden) } } if !strings.Contains(source, "Promise>") { t.Fatal("stream methods must resolve result") } }