Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

versionProbe.test.ts

198 lines7.4 KB

1import { assert, describe, it } from "@effect/vitest";
2import * as Effect from "effect/Effect";
3import * as HttpClient from "effect/http/HttpClient";
4import * as HttpClientError from "effect/http/HttpClientError";
5import * as HttpClientRequest from "effect/http/HttpClientRequest";
6​
7import * as OpenCodeRuntime from "./OpenCodeRuntime.ts";
8import {
9 classifyOpenCodeCliVersion,
10 makeOpenCodeRuntimeProbe,
11 probeOpenCodeRuntime,
12} from "./versionProbe.ts";
13import {
14 OPENCODE_1_RESPONSES,
15 OPENCODE_2_RESPONSES,
16 replayOpenCodeServer,
17} from "./probeResponses.fixture.ts";
18​
19const noBinary = {
20 runOpenCodeCommand: () => Effect.die("A configured server must not run the local binary"),
21} as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
22​
23const probeServer = (serverUrl: string, serverPassword: string, http: HttpClient.HttpClient) =>
24 probeOpenCodeRuntime({ binaryPath: "opencode", serverUrl, serverPassword }).pipe(
25 Effect.provideService(HttpClient.HttpClient, http),
26 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, noBinary),
27 );
28const SERVER_URL = "http://127.0.0.1:4096/";
29​
30describe("OpenCode version probe", () => {
31 it("classifies the recorded `opencode --version` output of both versions", () => {
32 assert.deepStrictEqual(classifyOpenCodeCliVersion("1.18.32\n"), {
33 generation: "v1",
34 version: "1.18.32",
35 });
36 assert.deepStrictEqual(classifyOpenCodeCliVersion("opencode v2.0.18\n"), {
37 generation: "v2",
38 version: "2.0.18",
39 });
40 assert.isUndefined(classifyOpenCodeCliVersion("opencode dev build\n"));
41 });
42​
43 it.effect("finds 2.x at /api/info without falling through to its HTML /global/health", () =>
44 Effect.gen(function* () {
45 const paths: Array<string> = [];
46 const probed = yield* probeServer(
47 SERVER_URL,
48 "pw",
49 replayOpenCodeServer(OPENCODE_2_RESPONSES, "pw", paths),
50 );
51 assert.deepStrictEqual(probed, { generation: "v2", version: "2.0.18" });
52 assert.deepStrictEqual(paths, ["/api/info"]);
53 }),
54 );
55​
56 it.effect("skips the HTML 1.x serves at /api/info and finds it at /global/health", () =>
57 Effect.gen(function* () {
58 const paths: Array<string> = [];
59 const probed = yield* probeServer(
60 SERVER_URL,
61 "pw",
62 replayOpenCodeServer(OPENCODE_1_RESPONSES, "pw", paths),
63 );
64 assert.deepStrictEqual(probed, { generation: "v1", version: "1.18.32" });
65 assert.deepStrictEqual(paths, ["/api/info", "/global/health"]);
66 }),
67 );
68​
69 it.effect("keeps a server URL's path prefix and query when probing", () =>
70 Effect.gen(function* () {
71 const urls: Array<string> = [];
72 const replay = replayOpenCodeServer(OPENCODE_1_RESPONSES, "pw");
73 const proxied = HttpClient.make((request, url) => {
74 urls.push(url.href);
75 return replay.execute(
76 HttpClientRequest.setUrl(
77 request,
78 `http://127.0.0.1:4096${url.pathname.replace(/^\/opencode/, "")}`,
79 ),
80 );
81 });
82 const probed = yield* probeServer("http://proxy:8080/opencode/?route=oc", "pw", proxied);
83 assert.strictEqual(probed.generation, "v1");
84 assert.deepStrictEqual(urls, [
85 "http://proxy:8080/opencode/api/info?route=oc",
86 "http://proxy:8080/opencode/global/health?route=oc",
87 ]);
88 }),
89 );
90​
91 it.effect("reports a rejected password instead of guessing a version", () =>
92 Effect.gen(function* () {
93 for (const responses of [OPENCODE_1_RESPONSES, OPENCODE_2_RESPONSES]) {
94 const paths: Array<string> = [];
95 const error = yield* Effect.flip(
96 probeServer(SERVER_URL, "wrong", replayOpenCodeServer(responses, "pw", paths)),
97 );
98 assert.match(error.detail, /401 Unauthorized/);
99 assert.deepStrictEqual(paths, ["/api/info"]);
100 }
101 }),
102 );
103​
104 it.effect("sends a non-ASCII password as UTF-8, as both versions expect", () =>
105 Effect.gen(function* () {
106 for (const [responses, password, generation] of [
107 [OPENCODE_1_RESPONSES, "pässwörd", "v1"],
108 [OPENCODE_2_RESPONSES, "pass€word", "v2"],
109 ] as const) {
110 const probed = yield* probeServer(
111 SERVER_URL,
112 password,
113 replayOpenCodeServer(responses, password),
114 );
115 assert.strictEqual(probed.generation, generation);
116 }
117 }),
118 );
119​
120 it.effect("does not take other JSON at /api/info for OpenCode 2", () =>
121 Effect.gen(function* () {
122 const impostor = {
123 ...OPENCODE_1_RESPONSES,
124 "/api/info": { status: 200, contentType: "application/json", body: '{"version":"3.4.1"}' },
125 "/global/health": OPENCODE_1_RESPONSES["/api/info"],
126 };
127 const error = yield* Effect.flip(
128 probeServer(SERVER_URL, "pw", replayOpenCodeServer(impostor, "pw")),
129 );
130 assert.match(error.detail, /did not identify itself as OpenCode/);
131 }),
132 );
133​
134 it.effect("never puts the configured URL or its credentials in an error detail", () =>
135 Effect.gen(function* () {
136 const secret = "userinfo-secret";
137 const unreachable = HttpClient.make((request) =>
138 Effect.die(`should not be reached for ${request.url}`),
139 );
140 // A fetch failure that echoes the full request URL, as Node's does.
141 const refused = HttpClient.make((request) =>
142 Effect.fail(
143 new HttpClientError.HttpClientError({
144 reason: new HttpClientError.TransportError({
145 request,
146 description: `connect ECONNREFUSED ${request.url}`,
147 }),
148 }),
149 ),
150 );
151 for (const [serverUrl, http] of [
152 [`127.0.0.1:4096?token=${secret}`, unreachable],
153 [`localhost:4096/${secret}`, unreachable],
154 [`http://user:${secret}@10.0.0.1:4096/?token=${secret}`, refused],
155 ] as const) {
156 const error = yield* Effect.flip(probeServer(serverUrl, secret, http));
157 assert.notInclude(error.detail, secret, serverUrl);
158 assert.notInclude(error.detail, "10.0.0.1", serverUrl);
159 }
160 }),
161 );
162​
163 it.effect("remembers a probed 2.x runtime but re-probes 1.x and failures", () =>
164 Effect.gen(function* () {
165 const outputs = ["", "opencode v2.0.18\n", "1.18.32\n", "1.18.32\n"];
166 let calls = 0;
167 const runtime = {
168 runOpenCodeCommand: () => {
169 const stdout = outputs[calls++];
170 return stdout
171 ? Effect.succeed({ stdout, stderr: "", code: 0 })
172 : Effect.fail(
173 new OpenCodeRuntime.OpenCodeRuntimeError({ operation: "spawn", detail: "ENOENT" }),
174 );
175 },
176 } as unknown as OpenCodeRuntime.OpenCodeRuntime["Service"];
177 const probe = yield* makeOpenCodeRuntimeProbe(
178 probeOpenCodeRuntime({ binaryPath: "opencode", serverUrl: "", serverPassword: "" }).pipe(
179 Effect.provideService(OpenCodeRuntime.OpenCodeRuntime, runtime),
180 Effect.provideService(
181 HttpClient.HttpClient,
182 HttpClient.make(() => Effect.die("A local binary must not be probed over HTTP")),
183 ),
184 ),
185 );
186​
187 yield* Effect.flip(probe.get);
188 assert.isTrue((yield* probe.lastSuccess)._tag === "None");
189 assert.strictEqual((yield* probe.get).generation, "v2");
190 assert.strictEqual((yield* probe.get).generation, "v2");
191 assert.strictEqual(calls, 2);
192 assert.strictEqual((yield* probe.refresh).generation, "v1");
193 assert.strictEqual(calls, 3);
194 assert.strictEqual((yield* probe.get).generation, "v1");
195 assert.strictEqual(calls, 4);
196 }),
197 );
198});