The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 04:45 UTC
| 1 | import { describe, expect, it } from "@effect/vitest"; |
| 2 | import { |
| 3 | EnvironmentId, |
| 4 | ORCHESTRATION_PROTOCOL_HEADER, |
| 5 | ORCHESTRATION_PROTOCOL_VERSION_TEXT, |
| 6 | ProjectId, |
| 7 | ThreadId, |
| 8 | type AuthSessionState, |
| 9 | type OrchestrationV2ShellSnapshot, |
| 10 | OrchestrationV2ThreadDetailSnapshot, |
| 11 | OrchestrationV2ThreadBoundedSnapshot, |
| 12 | OrchestrationV2ThreadTranscript, |
| 13 | type OrchestrationV2ThreadHistoryPage, |
| 14 | } from "@t3tools/contracts"; |
| 15 | import * as Cause from "effect/Cause"; |
| 16 | import * as Effect from "effect/Effect"; |
| 17 | import * as Exit from "effect/Exit"; |
| 18 | import * as Fiber from "effect/Fiber"; |
| 19 | import * as Layer from "effect/Layer"; |
| 20 | import * as Option from "effect/Option"; |
| 21 | import * as Queue from "effect/Queue"; |
| 22 | import * as Schema from "effect/Schema"; |
| 23 | import * as TestClock from "effect/testing/TestClock"; |
| 24 | import type { HttpClient } from "effect/http"; |
| 25 | import { AsyncResult } from "effect/reactivity"; |
| 26 | |
| 27 | import * as RemoteEnvironmentAuthorization from "../authorization/service.ts"; |
| 28 | import { |
| 29 | ConnectionTransientError, |
| 30 | RelayConnectionTarget, |
| 31 | type PreparedConnection, |
| 32 | type PreparedHttpAuthorization, |
| 33 | } from "../connection/model.ts"; |
| 34 | import * as ManagedRelay from "../relay/managedRelay.ts"; |
| 35 | import { type RemoteEnvironmentRequestError } from "../rpc/http.ts"; |
| 36 | import * as RpcHttp from "../rpc/http.ts"; |
| 37 | import * as PullRequestDiffLoader from "./pullRequestDiffHttp.ts"; |
| 38 | import { fetchEnvironmentSessionState, sessionDeniesScope } from "./session.ts"; |
| 39 | import { fetchEnvironmentShellSnapshot } from "./shellSnapshotHttp.ts"; |
| 40 | import * as ThreadSnapshotLoader from "./threadSnapshotHttp.ts"; |
| 41 | import { fetchEnvironmentThreadTranscript } from "./threadTranscriptHttp.ts"; |
| 42 | import { fetchEnvironmentBoundedThreadSnapshot } from "./boundedThreadSnapshotHttp.ts"; |
| 43 | import * as BoundedThreadSnapshotHttp from "./boundedThreadSnapshotHttp.ts"; |
| 44 | import { fetchEnvironmentThreadHistoryPage } from "./threadHistoryHttp.ts"; |
| 45 | import { v2Projection } from "./orchestrationV2TestFixtures.ts"; |
| 46 | |
| 47 | const encodeBoundedSnapshot = Schema.encodeSync(OrchestrationV2ThreadBoundedSnapshot); |
| 48 | const encodeThreadTranscript = Schema.encodeSync(OrchestrationV2ThreadTranscript); |
| 49 | |
| 50 | const TARGET = new RelayConnectionTarget({ |
| 51 | environmentId: EnvironmentId.make("environment-1"), |
| 52 | label: "Remote environment", |
| 53 | }); |
| 54 | const PREPARED: PreparedConnection = { |
| 55 | environmentId: TARGET.environmentId, |
| 56 | label: TARGET.label, |
| 57 | httpBaseUrl: "https://previous.example.test", |
| 58 | socketUrl: "wss://previous.example.test/ws", |
| 59 | httpAuthorization: { _tag: "Dpop", accessToken: "expired-token", expiresAtEpochMs: 0 }, |
| 60 | target: TARGET, |
| 61 | }; |
| 62 | const CURRENT_ORIGIN = "https://current.example.test"; |
| 63 | const RENEWED_ORIGIN = "https://renewed.example.test"; |
| 64 | const DIFF = { |
| 65 | projectId: ProjectId.make("project-1"), |
| 66 | repository: "owner/repository", |
| 67 | number: 42, |
| 68 | }; |
| 69 | const DIFF_RESULT = { patch: "diff --git a/file.ts b/file.ts", truncated: false, nextCursor: null }; |
| 70 | const AUTH = { |
| 71 | policy: "remote-reachable", |
| 72 | bootstrapMethods: ["one-time-token"], |
| 73 | sessionMethods: ["dpop-access-token"], |
| 74 | sessionCookieName: "t3_session", |
| 75 | } satisfies AuthSessionState["auth"]; |
| 76 | const SESSION = { |
| 77 | authenticated: true, |
| 78 | auth: AUTH, |
| 79 | scopes: ["orchestration:read", "orchestration:operate"], |
| 80 | sessionMethod: "dpop-access-token", |
| 81 | } satisfies AuthSessionState; |
| 82 | const UNAUTHENTICATED_SESSION = { authenticated: false, auth: AUTH } satisfies AuthSessionState; |
| 83 | const SHELL = { |
| 84 | schemaVersion: 1, |
| 85 | snapshotSequence: 1, |
| 86 | projects: [], |
| 87 | threads: [], |
| 88 | archivedThreads: [], |
| 89 | } satisfies OrchestrationV2ShellSnapshot; |
| 90 | const THREAD = { |
| 91 | snapshotSequence: 2, |
| 92 | projection: v2Projection, |
| 93 | } satisfies OrchestrationV2ThreadDetailSnapshot; |
| 94 | const TRANSCRIPT = { |
| 95 | threadId: v2Projection.thread.id, |
| 96 | title: v2Projection.thread.title, |
| 97 | updatedAt: v2Projection.updatedAt, |
| 98 | items: v2Projection.visibleTurnItems, |
| 99 | } satisfies OrchestrationV2ThreadTranscript; |
| 100 | const BOUNDED_THREAD = { |
| 101 | ...THREAD, |
| 102 | historyCursor: "older-page", |
| 103 | hasMoreHistory: true, |
| 104 | latestLocalTurnOrdinal: 3, |
| 105 | } satisfies OrchestrationV2ThreadBoundedSnapshot; |
| 106 | const THREAD_HISTORY = { |
| 107 | snapshotSequence: 2, |
| 108 | items: [], |
| 109 | nextCursor: null, |
| 110 | hasMoreHistory: false, |
| 111 | } satisfies OrchestrationV2ThreadHistoryPage; |
| 112 | |
| 113 | function credentialRejectedResponse(reason = "invalid_credential") { |
| 114 | return Response.json( |
| 115 | { |
| 116 | _tag: "EnvironmentAuthInvalidError", |
| 117 | code: "auth_invalid", |
| 118 | reason, |
| 119 | traceId: "trace-rejected", |
| 120 | }, |
| 121 | { status: 401 }, |
| 122 | ); |
| 123 | } |
| 124 | |
| 125 | function makeHarness(reply: (requestNumber: number) => Response | Promise<Response>) { |
| 126 | const calls: Array<{ readonly url: string; readonly init: RequestInit }> = []; |
| 127 | const authorizations: Array< |
| 128 | Parameters< |
| 129 | RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization["Service"]["authorizeDpopHttp"] |
| 130 | >[0] |
| 131 | > = []; |
| 132 | const proofs: Array<ManagedRelay.ManagedRelayDpopProofInput> = []; |
| 133 | const remoteAuthorization = RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization.of({ |
| 134 | authorizeBearer: () => Effect.die("Unexpected bearer connection preparation."), |
| 135 | authorizeDpop: () => Effect.die("HTTP requests must not prepare a WebSocket connection."), |
| 136 | authorizeDirectDpop: () => Effect.die("HTTP requests must not prepare a WebSocket connection."), |
| 137 | authorizeDirectDpopHttp: () => Effect.die("Unexpected direct DPoP authorization."), |
| 138 | authorizeDpopHttp: (input) => |
| 139 | Effect.sync(() => { |
| 140 | authorizations.push(input); |
| 141 | const rejected = input.rejectedAccessToken !== undefined; |
| 142 | return { |
| 143 | environmentId: TARGET.environmentId, |
| 144 | label: TARGET.label, |
| 145 | httpBaseUrl: rejected ? RENEWED_ORIGIN : CURRENT_ORIGIN, |
| 146 | httpAuthorization: { |
| 147 | _tag: "Dpop" as const, |
| 148 | accessToken: rejected ? "renewed-token" : "current-token", |
| 149 | expiresAtEpochMs: 3_600_000, |
| 150 | }, |
| 151 | }; |
| 152 | }), |
| 153 | rememberCheckedDescriptor: () => Effect.void, |
| 154 | renewDpopBeforeExpiry: () => Effect.die("HTTP requests must not renew a socket's token."), |
| 155 | }); |
| 156 | const signer = ManagedRelay.ManagedRelayDpopSigner.of({ |
| 157 | thumbprint: Effect.succeed("test-thumbprint"), |
| 158 | createProof: (input) => |
| 159 | Effect.sync(() => { |
| 160 | proofs.push(input); |
| 161 | return `proof-${proofs.length}`; |
| 162 | }), |
| 163 | }); |
| 164 | const fetchFn: typeof fetch = async (request, init) => { |
| 165 | calls.push({ url: String(request), init: init ?? {} }); |
| 166 | return reply(calls.length); |
| 167 | }; |
| 168 | return { |
| 169 | calls, |
| 170 | authorizations, |
| 171 | proofs, |
| 172 | remoteAuthorization, |
| 173 | input: { |
| 174 | prepared: PREPARED, |
| 175 | signer: Option.some(signer), |
| 176 | remoteAuthorization: Option.some(remoteAuthorization), |
| 177 | }, |
| 178 | httpLayer: RpcHttp.layerRemoteHttpClient(fetchFn), |
| 179 | }; |
| 180 | } |
| 181 | |
| 182 | // Resolves "settled" instead of hanging when the load finishes without sending another request. |
| 183 | function nextRequestOrSettled(requests: Queue.Queue<number>, load: Fiber.Fiber<unknown, unknown>) { |
| 184 | return Effect.raceFirst( |
| 185 | Queue.take(requests).pipe(Effect.as("sent" as const)), |
| 186 | Fiber.await(load).pipe(Effect.as("settled" as const)), |
| 187 | ); |
| 188 | } |
| 189 | |
| 190 | type HttpInput = ReturnType<typeof makeHarness>["input"]; |
| 191 | const LOADERS: ReadonlyArray<{ |
| 192 | readonly name: string; |
| 193 | readonly method: string; |
| 194 | readonly path: string; |
| 195 | readonly response: unknown; |
| 196 | readonly expected: unknown; |
| 197 | readonly load: ( |
| 198 | input: HttpInput, |
| 199 | ) => Effect.Effect< |
| 200 | unknown, |
| 201 | RemoteEnvironmentRequestError | PullRequestDiffLoader.PullRequestDiffCredentialRejectedError, |
| 202 | HttpClient.HttpClient |
| 203 | >; |
| 204 | }> = [ |
| 205 | { |
| 206 | name: "PR diff", |
| 207 | method: "POST", |
| 208 | path: "/api/pull-requests/diff", |
| 209 | response: DIFF_RESULT, |
| 210 | expected: DIFF_RESULT, |
| 211 | load: (input: HttpInput) => |
| 212 | PullRequestDiffLoader.fetchEnvironmentPullRequestDiff({ ...input, diff: DIFF }), |
| 213 | }, |
| 214 | { |
| 215 | name: "session permissions", |
| 216 | method: "GET", |
| 217 | path: "/api/auth/session", |
| 218 | response: SESSION, |
| 219 | expected: SESSION, |
| 220 | load: fetchEnvironmentSessionState, |
| 221 | }, |
| 222 | { |
| 223 | name: "shell snapshot", |
| 224 | method: "GET", |
| 225 | path: "/api/orchestration/shell", |
| 226 | response: SHELL, |
| 227 | expected: SHELL, |
| 228 | load: (input: HttpInput) => |
| 229 | fetchEnvironmentShellSnapshot(input).pipe( |
| 230 | Effect.map((answer) => { |
| 231 | if ("resumable" in answer) return answer; |
| 232 | const { loadPullRequests: _links, ...snapshot } = answer; |
| 233 | return snapshot; |
| 234 | }), |
| 235 | ), |
| 236 | }, |
| 237 | { |
| 238 | name: "thread transcript", |
| 239 | method: "GET", |
| 240 | path: `/api/orchestration/threads/${TRANSCRIPT.threadId}/transcript`, |
| 241 | response: encodeThreadTranscript(TRANSCRIPT), |
| 242 | expected: TRANSCRIPT, |
| 243 | load: (input: HttpInput) => |
| 244 | fetchEnvironmentThreadTranscript({ ...input, threadId: TRANSCRIPT.threadId }), |
| 245 | }, |
| 246 | { |
| 247 | name: "bounded thread snapshot", |
| 248 | method: "GET", |
| 249 | path: `/api/orchestration/threads/${THREAD.projection.thread.id}/bounded`, |
| 250 | response: encodeBoundedSnapshot(BOUNDED_THREAD), |
| 251 | expected: BOUNDED_THREAD, |
| 252 | load: (input: HttpInput) => |
| 253 | fetchEnvironmentBoundedThreadSnapshot({ ...input, threadId: THREAD.projection.thread.id }), |
| 254 | }, |
| 255 | { |
| 256 | name: "older thread history", |
| 257 | method: "GET", |
| 258 | path: `/api/orchestration/threads/${THREAD.projection.thread.id}/history`, |
| 259 | response: THREAD_HISTORY, |
| 260 | expected: THREAD_HISTORY, |
| 261 | load: (input: HttpInput) => |
| 262 | fetchEnvironmentThreadHistoryPage({ |
| 263 | ...input, |
| 264 | threadId: THREAD.projection.thread.id, |
| 265 | cursor: "older-page", |
| 266 | }), |
| 267 | }, |
| 268 | ]; |
| 269 | |
| 270 | describe("authenticated environment HTTP requests", () => { |
| 271 | it.effect.each(LOADERS)("rejects an invalid $name response", (loader) => |
| 272 | Effect.gen(function* () { |
| 273 | const harness = makeHarness(() => Response.json({})); |
| 274 | const result = yield* loader |
| 275 | .load(harness.input) |
| 276 | .pipe(Effect.provide(harness.httpLayer), Effect.asVoid, Effect.flip); |
| 277 | expect(result._tag).toBe("RemoteEnvironmentAuthInvalidJsonError"); |
| 278 | expect(harness.calls).toHaveLength(1); |
| 279 | }), |
| 280 | ); |
| 281 | |
| 282 | it.effect("keeps the status of a shell snapshot error that is not a declared error", () => |
| 283 | Effect.gen(function* () { |
| 284 | const harness = makeHarness(() => Response.json({ error: "bad_gateway" }, { status: 502 })); |
| 285 | const error = yield* fetchEnvironmentShellSnapshot(harness.input).pipe( |
| 286 | Effect.provide(harness.httpLayer), |
| 287 | Effect.flip, |
| 288 | ); |
| 289 | expect(error).toMatchObject({ |
| 290 | _tag: "RemoteEnvironmentAuthUndeclaredStatusError", |
| 291 | status: 502, |
| 292 | }); |
| 293 | }), |
| 294 | ); |
| 295 | |
| 296 | it.effect.each(LOADERS)("uses current relay authorization and endpoint for $name", (loader) => |
| 297 | Effect.gen(function* () { |
| 298 | const harness = makeHarness(() => Response.json(loader.response)); |
| 299 | const result = yield* loader.load(harness.input).pipe(Effect.provide(harness.httpLayer)); |
| 300 | |
| 301 | expect(result).toEqual(loader.expected); |
| 302 | expect(harness.calls).toHaveLength(1); |
| 303 | const call = harness.calls[0]!; |
| 304 | const url = new URL(call.url); |
| 305 | expect(url.origin).toBe(CURRENT_ORIGIN); |
| 306 | expect(url.pathname).toBe(loader.path); |
| 307 | expect(call.init.method).toBe(loader.method); |
| 308 | expect(new Headers(call.init.headers).get("authorization")).toBe("DPoP current-token"); |
| 309 | expect(new Headers(call.init.headers).get("dpop")).toBe("proof-1"); |
| 310 | expect(call.init.credentials).toBeUndefined(); |
| 311 | if (loader.path.startsWith("/api/orchestration/")) { |
| 312 | expect(new Headers(call.init.headers).get(ORCHESTRATION_PROTOCOL_HEADER)).toBe( |
| 313 | ORCHESTRATION_PROTOCOL_VERSION_TEXT, |
| 314 | ); |
| 315 | } |
| 316 | expect(harness.authorizations).toEqual([{ expectedEnvironmentId: TARGET.environmentId }]); |
| 317 | // The proof signs exactly the URL sent; signers drop the query for `htu`. |
| 318 | expect(harness.proofs).toEqual([ |
| 319 | { method: loader.method, url: call.url, accessToken: "current-token" }, |
| 320 | ]); |
| 321 | if (loader.name === "older thread history") { |
| 322 | expect(url.searchParams.get("cursor")).toBe("older-page"); |
| 323 | } |
| 324 | expect(PREPARED.httpAuthorization).toMatchObject({ accessToken: "expired-token" }); |
| 325 | }), |
| 326 | ); |
| 327 | |
| 328 | // MCP-created thread ids contain ":", which the request path percent-encodes. |
| 329 | // The DPoP proof must sign the URL that is actually sent, or the environment |
| 330 | // rejects it as a URL mismatch. |
| 331 | const MCP_THREAD_ID = ThreadId.make("mcp:3534bc83-1c17-4a1e-9118-601c2766d355"); |
| 332 | const MCP_THREAD_LOADERS: ReadonlyArray< |
| 333 | Pick<(typeof LOADERS)[number], "name" | "response" | "load"> |
| 334 | > = [ |
| 335 | { |
| 336 | name: "thread transcript", |
| 337 | response: encodeThreadTranscript(TRANSCRIPT), |
| 338 | load: (input: HttpInput) => |
| 339 | fetchEnvironmentThreadTranscript({ ...input, threadId: MCP_THREAD_ID }), |
| 340 | }, |
| 341 | { |
| 342 | name: "bounded thread snapshot", |
| 343 | response: encodeBoundedSnapshot(BOUNDED_THREAD), |
| 344 | load: (input: HttpInput) => |
| 345 | fetchEnvironmentBoundedThreadSnapshot({ ...input, threadId: MCP_THREAD_ID }), |
| 346 | }, |
| 347 | { |
| 348 | name: "older thread history", |
| 349 | response: THREAD_HISTORY, |
| 350 | load: (input: HttpInput) => |
| 351 | fetchEnvironmentThreadHistoryPage({ |
| 352 | ...input, |
| 353 | threadId: MCP_THREAD_ID, |
| 354 | cursor: "older-page", |
| 355 | }), |
| 356 | }, |
| 357 | ]; |
| 358 | it.effect.each(MCP_THREAD_LOADERS)( |
| 359 | "signs the sent URL for a $name of a thread id that needs encoding", |
| 360 | (loader) => |
| 361 | Effect.gen(function* () { |
| 362 | const harness = makeHarness(() => Response.json(loader.response)); |
| 363 | yield* loader.load(harness.input).pipe(Effect.provide(harness.httpLayer)); |
| 364 | |
| 365 | const sent = harness.calls[0]!.url; |
| 366 | expect(new URL(sent).pathname).toContain("/mcp%3A3534bc83-"); |
| 367 | expect(harness.proofs.map((proof) => proof.url)).toEqual([sent]); |
| 368 | }), |
| 369 | ); |
| 370 | |
| 371 | it.effect("retries a rejected diff once with a new token, endpoint, and proof", () => |
| 372 | Effect.gen(function* () { |
| 373 | const harness = makeHarness((requestNumber) => |
| 374 | requestNumber === 1 ? credentialRejectedResponse() : Response.json(DIFF_RESULT), |
| 375 | ); |
| 376 | const result = yield* PullRequestDiffLoader.fetchEnvironmentPullRequestDiff({ |
| 377 | ...harness.input, |
| 378 | diff: DIFF, |
| 379 | }).pipe(Effect.provide(harness.httpLayer)); |
| 380 | |
| 381 | expect(result).toEqual(DIFF_RESULT); |
| 382 | expect(harness.authorizations).toEqual([ |
| 383 | { expectedEnvironmentId: TARGET.environmentId }, |
| 384 | { expectedEnvironmentId: TARGET.environmentId, rejectedAccessToken: "current-token" }, |
| 385 | ]); |
| 386 | expect(harness.calls.map((call) => call.url)).toEqual([ |
| 387 | `${CURRENT_ORIGIN}/api/pull-requests/diff`, |
| 388 | `${RENEWED_ORIGIN}/api/pull-requests/diff`, |
| 389 | ]); |
| 390 | expect( |
| 391 | harness.calls.map((call) => new Headers(call.init.headers).get("authorization")), |
| 392 | ).toEqual(["DPoP current-token", "DPoP renewed-token"]); |
| 393 | expect(harness.calls.map((call) => new Headers(call.init.headers).get("dpop"))).toEqual([ |
| 394 | "proof-1", |
| 395 | "proof-2", |
| 396 | ]); |
| 397 | expect(harness.proofs[1]).toEqual({ |
| 398 | method: "POST", |
| 399 | url: `${RENEWED_ORIGIN}/api/pull-requests/diff`, |
| 400 | accessToken: "renewed-token", |
| 401 | }); |
| 402 | expect(harness.calls[1]!.init.body).toEqual(harness.calls[0]!.init.body); |
| 403 | }), |
| 404 | ); |
| 405 | |
| 406 | it.effect("renews credentials captured by the bounded snapshot loader", () => |
| 407 | Effect.gen(function* () { |
| 408 | const harness = makeHarness((requestNumber) => |
| 409 | requestNumber === 1 |
| 410 | ? credentialRejectedResponse() |
| 411 | : Response.json(encodeBoundedSnapshot(BOUNDED_THREAD)), |
| 412 | ); |
| 413 | const layerLoader = BoundedThreadSnapshotHttp.layer.pipe( |
| 414 | Layer.provide( |
| 415 | Layer.mergeAll( |
| 416 | harness.httpLayer, |
| 417 | Layer.succeed( |
| 418 | ManagedRelay.ManagedRelayDpopSigner, |
| 419 | Option.getOrThrow(harness.input.signer), |
| 420 | ), |
| 421 | Layer.succeed( |
| 422 | RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization, |
| 423 | harness.remoteAuthorization, |
| 424 | ), |
| 425 | ), |
| 426 | ), |
| 427 | ); |
| 428 | const loader = yield* ThreadSnapshotLoader.ThreadSnapshotLoader.pipe( |
| 429 | Effect.provide(layerLoader), |
| 430 | ); |
| 431 | const result = yield* loader.load(PREPARED, THREAD.projection.thread.id); |
| 432 | expect(result).toEqual({ |
| 433 | _tag: "present", |
| 434 | snapshot: { ...THREAD, latestLocalTurnOrdinal: BOUNDED_THREAD.latestLocalTurnOrdinal }, |
| 435 | history: { |
| 436 | historyCursor: BOUNDED_THREAD.historyCursor, |
| 437 | hasMoreHistory: true, |
| 438 | latestLocalTurnOrdinal: BOUNDED_THREAD.latestLocalTurnOrdinal, |
| 439 | }, |
| 440 | }); |
| 441 | expect(harness.calls).toHaveLength(2); |
| 442 | expect(new Headers(harness.calls[1]!.init.headers).get("authorization")).toBe( |
| 443 | "DPoP renewed-token", |
| 444 | ); |
| 445 | }), |
| 446 | ); |
| 447 | |
| 448 | it.effect("preserves the credential rejection after the one recovery attempt fails", () => |
| 449 | Effect.gen(function* () { |
| 450 | const harness = makeHarness(() => credentialRejectedResponse()); |
| 451 | const error = yield* PullRequestDiffLoader.fetchEnvironmentPullRequestDiff({ |
| 452 | ...harness.input, |
| 453 | diff: DIFF, |
| 454 | }).pipe(Effect.provide(harness.httpLayer), Effect.flip); |
| 455 | |
| 456 | expect(error).toMatchObject({ |
| 457 | _tag: "PullRequestDiffCredentialRejectedError", |
| 458 | traceId: "trace-rejected", |
| 459 | }); |
| 460 | expect(harness.calls).toHaveLength(2); |
| 461 | expect(harness.authorizations).toHaveLength(2); |
| 462 | }), |
| 463 | ); |
| 464 | |
| 465 | it.effect.each([ |
| 466 | { |
| 467 | name: "insufficient scope", |
| 468 | reply: () => |
| 469 | Response.json( |
| 470 | { |
| 471 | _tag: "EnvironmentScopeRequiredError", |
| 472 | code: "insufficient_scope", |
| 473 | requiredScope: "orchestration:read", |
| 474 | traceId: "trace-scope", |
| 475 | }, |
| 476 | { status: 403 }, |
| 477 | ), |
| 478 | errorTag: "EnvironmentScopeRequiredError", |
| 479 | }, |
| 480 | { |
| 481 | name: "missing credential", |
| 482 | reply: () => credentialRejectedResponse("missing_credential"), |
| 483 | errorTag: "EnvironmentAuthInvalidError", |
| 484 | }, |
| 485 | { |
| 486 | name: "Cloudflare 530", |
| 487 | reply: () => new Response("error code: 1033", { status: 530 }), |
| 488 | errorTag: "RemoteEnvironmentAuthUndeclaredStatusError", |
| 489 | }, |
| 490 | { |
| 491 | name: "network failure", |
| 492 | reply: () => Promise.reject(new Error("Network unreachable")), |
| 493 | errorTag: "RemoteEnvironmentAuthFetchError", |
| 494 | }, |
| 495 | ])("does not renew or retry on $name", ({ reply, errorTag }) => |
| 496 | Effect.gen(function* () { |
| 497 | const harness = makeHarness(reply); |
| 498 | const error = yield* PullRequestDiffLoader.fetchEnvironmentPullRequestDiff({ |
| 499 | ...harness.input, |
| 500 | diff: DIFF, |
| 501 | }).pipe(Effect.provide(harness.httpLayer), Effect.flip); |
| 502 | |
| 503 | expect(error._tag).toBe(errorTag); |
| 504 | expect(harness.calls).toHaveLength(1); |
| 505 | expect(harness.authorizations).toEqual([{ expectedEnvironmentId: TARGET.environmentId }]); |
| 506 | }), |
| 507 | ); |
| 508 | |
| 509 | it.effect("recovers a session's unauthenticated 200 response before checking permissions", () => |
| 510 | Effect.gen(function* () { |
| 511 | const harness = makeHarness((requestNumber) => |
| 512 | Response.json(requestNumber === 1 ? UNAUTHENTICATED_SESSION : SESSION), |
| 513 | ); |
| 514 | const result = yield* fetchEnvironmentSessionState(harness.input).pipe( |
| 515 | Effect.provide(harness.httpLayer), |
| 516 | ); |
| 517 | |
| 518 | expect(result).toEqual(SESSION); |
| 519 | expect(harness.authorizations[1]).toEqual({ |
| 520 | expectedEnvironmentId: TARGET.environmentId, |
| 521 | rejectedAccessToken: "current-token", |
| 522 | }); |
| 523 | expect(harness.calls).toHaveLength(2); |
| 524 | }), |
| 525 | ); |
| 526 | |
| 527 | it.effect( |
| 528 | "waits longer for session permissions after the environment is too slow to answer", |
| 529 | () => |
| 530 | Effect.gen(function* () { |
| 531 | const requests = yield* Queue.unbounded<number>(); |
| 532 | let answer: () => void = () => {}; |
| 533 | const answered = new Promise<void>((resolve) => { |
| 534 | answer = resolve; |
| 535 | }); |
| 536 | const harness = makeHarness((requestNumber) => { |
| 537 | Queue.offerUnsafe(requests, requestNumber); |
| 538 | return requestNumber === 1 |
| 539 | ? new Promise<Response>(() => {}) |
| 540 | : answered.then(() => Response.json(SESSION)); |
| 541 | }); |
| 542 | const load = yield* fetchEnvironmentSessionState({ |
| 543 | prepared: { ...PREPARED, httpAuthorization: { _tag: "Bearer", token: "bearer-token" } }, |
| 544 | signer: Option.none(), |
| 545 | timeoutMs: 1_000, |
| 546 | }).pipe(Effect.provide(harness.httpLayer), Effect.forkChild({ startImmediately: true })); |
| 547 | |
| 548 | yield* Queue.take(requests); |
| 549 | yield* TestClock.adjust("1 second"); |
| 550 | expect(yield* nextRequestOrSettled(requests, load)).toBe("sent"); |
| 551 | yield* TestClock.adjust("1500 millis"); |
| 552 | answer(); |
| 553 | |
| 554 | expect(yield* Fiber.await(load)).toStrictEqual(Exit.succeed(SESSION)); |
| 555 | expect(harness.calls).toHaveLength(2); |
| 556 | }), |
| 557 | ); |
| 558 | |
| 559 | it.effect("gives up on session permissions once a 60 second wait also times out", () => |
| 560 | Effect.gen(function* () { |
| 561 | const requests = yield* Queue.unbounded<number>(); |
| 562 | const harness = makeHarness((requestNumber) => { |
| 563 | Queue.offerUnsafe(requests, requestNumber); |
| 564 | return new Promise<Response>(() => {}); |
| 565 | }); |
| 566 | const load = yield* fetchEnvironmentSessionState({ |
| 567 | prepared: { ...PREPARED, httpAuthorization: { _tag: "Bearer", token: "bearer-token" } }, |
| 568 | signer: Option.none(), |
| 569 | timeoutMs: 15_000, |
| 570 | }).pipe(Effect.provide(harness.httpLayer), Effect.forkChild({ startImmediately: true })); |
| 571 | |
| 572 | yield* Queue.take(requests); |
| 573 | yield* TestClock.adjust("15 seconds"); |
| 574 | expect(yield* nextRequestOrSettled(requests, load)).toBe("sent"); |
| 575 | yield* TestClock.adjust("30 seconds"); |
| 576 | expect(yield* nextRequestOrSettled(requests, load)).toBe("sent"); |
| 577 | yield* TestClock.adjust("60 seconds"); |
| 578 | const exit = yield* Fiber.await(load); |
| 579 | |
| 580 | expect(exit).toMatchObject({ |
| 581 | _tag: "Failure", |
| 582 | cause: { |
| 583 | reasons: [{ error: { _tag: "RemoteEnvironmentAuthTimeoutError", timeoutMs: 60_000 } }], |
| 584 | }, |
| 585 | }); |
| 586 | expect(harness.calls).toHaveLength(3); |
| 587 | }), |
| 588 | ); |
| 589 | |
| 590 | it.effect("reports persistent session rejection instead of showing missing permissions", () => |
| 591 | Effect.gen(function* () { |
| 592 | const harness = makeHarness(() => Response.json(UNAUTHENTICATED_SESSION)); |
| 593 | const error = yield* fetchEnvironmentSessionState(harness.input).pipe( |
| 594 | Effect.provide(harness.httpLayer), |
| 595 | Effect.flip, |
| 596 | ); |
| 597 | |
| 598 | expect(error).toMatchObject({ |
| 599 | _tag: "RemoteEnvironmentAuthFetchError", |
| 600 | message: "The environment rejected the renewed session authorization.", |
| 601 | }); |
| 602 | expect(harness.calls).toHaveLength(2); |
| 603 | const rejectedLookup = AsyncResult.failure<AuthSessionState, typeof error>(Cause.fail(error)); |
| 604 | expect(sessionDeniesScope(rejectedLookup, "orchestration:read")).toBe(true); |
| 605 | }), |
| 606 | ); |
| 607 | |
| 608 | it.effect.each([ |
| 609 | { name: "cookie", authorization: null }, |
| 610 | { name: "bearer", authorization: { _tag: "Bearer", token: "bearer-token" } }, |
| 611 | ] satisfies ReadonlyArray<{ name: string; authorization: PreparedHttpAuthorization | null }>)( |
| 612 | "leaves $name sessions unchanged without relay services", |
| 613 | ({ authorization }) => |
| 614 | Effect.gen(function* () { |
| 615 | const harness = makeHarness(() => Response.json(UNAUTHENTICATED_SESSION)); |
| 616 | const result = yield* fetchEnvironmentSessionState({ |
| 617 | prepared: { ...PREPARED, httpAuthorization: authorization }, |
| 618 | signer: Option.none(), |
| 619 | }).pipe(Effect.provide(harness.httpLayer)); |
| 620 | |
| 621 | expect(result).toEqual(UNAUTHENTICATED_SESSION); |
| 622 | expect(harness.calls).toHaveLength(1); |
| 623 | expect(harness.authorizations).toEqual([]); |
| 624 | expect(new Headers(harness.calls[0]!.init.headers).get("authorization")).toBe( |
| 625 | authorization === null ? null : "Bearer bearer-token", |
| 626 | ); |
| 627 | expect(harness.calls[0]!.init.credentials).toBe( |
| 628 | authorization === null ? "include" : undefined, |
| 629 | ); |
| 630 | }), |
| 631 | ); |
| 632 | |
| 633 | it.effect("reports renewal failure without sending the expired prepared token", () => |
| 634 | Effect.gen(function* () { |
| 635 | const harness = makeHarness(() => Response.json(SESSION)); |
| 636 | const failure = new ConnectionTransientError({ |
| 637 | reason: "transport", |
| 638 | detail: "Relay unavailable", |
| 639 | }); |
| 640 | const remoteAuthorization = RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization.of({ |
| 641 | ...harness.remoteAuthorization, |
| 642 | authorizeDpopHttp: () => Effect.fail(failure), |
| 643 | }); |
| 644 | const error = yield* fetchEnvironmentSessionState({ |
| 645 | ...harness.input, |
| 646 | remoteAuthorization: Option.some(remoteAuthorization), |
| 647 | }).pipe(Effect.provide(harness.httpLayer), Effect.flip); |
| 648 | |
| 649 | expect(error).toMatchObject({ |
| 650 | _tag: "RemoteEnvironmentAuthFetchError", |
| 651 | message: "Could not authorize the environment request.", |
| 652 | cause: failure, |
| 653 | }); |
| 654 | expect(harness.calls).toEqual([]); |
| 655 | expect(harness.proofs).toEqual([]); |
| 656 | }), |
| 657 | ); |
| 658 | |
| 659 | it.effect("does not fall back to a captured DPoP token when authorization is unavailable", () => |
| 660 | Effect.gen(function* () { |
| 661 | const harness = makeHarness(() => Response.json(SESSION)); |
| 662 | const error = yield* fetchEnvironmentSessionState({ |
| 663 | prepared: PREPARED, |
| 664 | signer: harness.input.signer, |
| 665 | }).pipe(Effect.provide(harness.httpLayer), Effect.flip); |
| 666 | |
| 667 | expect(error).toMatchObject({ |
| 668 | _tag: "RemoteEnvironmentAuthFetchError", |
| 669 | message: "No relay authorization service is available for the environment request.", |
| 670 | }); |
| 671 | expect(harness.calls).toEqual([]); |
| 672 | }), |
| 673 | ); |
| 674 | }); |