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

layer.test.ts

1,168 lines45.0 KB

1import {
2 AuthStandardClientScopes,
3 EnvironmentId,
4 ORCHESTRATION_PROTOCOL_VERSION,
5 type ExecutionEnvironmentDescriptor,
6} from "@t3tools/contracts";
7import { type RelayEnvironmentConnectResponse } from "@t3tools/contracts/relay";
8import { describe, expect, it } from "@effect/vitest";
9import * as Deferred from "effect/Deferred";
10import * as Effect from "effect/Effect";
11import * as Fiber from "effect/Fiber";
12import * as Layer from "effect/Layer";
13import * as Option from "effect/Option";
14import * as Queue from "effect/Queue";
15import * as Ref from "effect/Ref";
16import * as TestClock from "effect/testing/TestClock";
17​
18import * as ManagedRelay from "../relay/managedRelay.ts";
19import * as RpcHttp from "../rpc/http.ts";
20import * as ClientCapabilities from "../platform/capabilities.ts";
21import * as RemoteEnvironmentAuthorization from "./service.ts";
22import * as TokenStore from "./tokenStore.ts";
23import { BearerConnectionCredential, BearerConnectionProfile } from "../connection/catalog.ts";
24import * as ConnectionCredentialStore from "../connection/credentialStore.ts";
25import { BearerConnectionTarget } from "../connection/model.ts";
26import * as ConnectionProfileStore from "../connection/profileStore.ts";
27import * as ConnectionResolver from "../connection/resolver.ts";
28​
29const ENVIRONMENT_ID = EnvironmentId.make("environment-1");
30const ENDPOINT = {
31 httpBaseUrl: "https://environment.example.test",
32 wsBaseUrl: "wss://environment.example.test",
33 providerKind: "cloudflare_tunnel" as const,
34};
35const DESCRIPTOR = {
36 environmentId: ENVIRONMENT_ID,
37 label: "Remote environment",
38 platform: {
39 os: "linux",
40 arch: "x64",
41 },
42 serverVersion: "0.0.0-test",
43 capabilities: {
44 repositoryIdentity: true,
45 },
46};
47const BOOTSTRAP: RelayEnvironmentConnectResponse = {
48 environmentId: ENVIRONMENT_ID,
49 endpoint: ENDPOINT,
50 credential: "relay-bootstrap",
51 expiresAt: "2026-06-06T01:00:00.000Z",
52};
53​
54type RecordedResponse = Response | ((init: RequestInit) => Response);
55​
56function recordedFetch(responses: ReadonlyArray<RecordedResponse>) {
57 const calls: Array<readonly [RequestInfo | URL, RequestInit]> = [];
58 let responseIndex = 0;
59 const fetchFn = ((input, init) => {
60 calls.push([input, init ?? {}]);
61 const response = responses[responseIndex++];
62 return response === undefined
63 ? Promise.reject(new Error(`Unexpected fetch call to ${String(input)}`))
64 : Promise.resolve(typeof response === "function" ? response(init ?? {}) : response);
65 }) satisfies typeof fetch;
66 return { calls, fetchFn };
68​
69const websocketTicket = (ticket: string) =>
70 Response.json({
71 ticket,
72 expiresAt: "2026-06-06T01:00:00.000Z",
73 });
74​
75const accessToken = (token: string, scope = AuthStandardClientScopes.join(" ")) =>
76 Response.json({
77 access_token: token,
78 issued_token_type: "urn:ietf:params:oauth:token-type:access_token",
79 token_type: "DPoP",
80 expires_in: 3_600,
81 scope,
82 });
83​
84const authInvalid = () =>
85 Response.json(
86 {
87 _tag: "EnvironmentAuthInvalidError",
88 code: "auth_invalid",
89 reason: "invalid_credential",
90 traceId: "trace-auth-invalid",
91 },
92 { status: 401 },
93 );
94​
95const persistedToken = (
96 input: {
97 readonly environmentId?: EnvironmentId;
98 readonly accessToken?: string;
99 readonly expiresAtEpochMs?: number;
100 readonly dpopThumbprint?: string;
101 } = {},
102) =>
103 new TokenStore.RemoteDpopAccessToken({
104 environmentId: input.environmentId ?? ENVIRONMENT_ID,
105 accountId: "account-1",
106 label: DESCRIPTOR.label,
107 endpoint: ENDPOINT,
108 accessToken: input.accessToken ?? "cached-access-token",
109 expiresAtEpochMs: input.expiresAtEpochMs ?? Number.MAX_SAFE_INTEGER,
110 dpopThumbprint: input.dpopThumbprint ?? "thumbprint-1",
111 });
112​
113const makeHarness = Effect.fn("TestRemoteAuthorization.makeHarness")(function* (input: {
114 readonly initialToken?: TokenStore.RemoteDpopAccessToken;
115 readonly responses: ReadonlyArray<RecordedResponse>;
116 readonly bootstrap?: RelayEnvironmentConnectResponse;
117 readonly beforeBootstrap?: Effect.Effect<void, ManagedRelay.ManagedRelayClientError>;
118 readonly beforePut?: Effect.Effect<void>;
119 readonly clerkToken?: ClientCapabilities.CloudSession["Service"]["clerkToken"];
120}) {
121 const tokens = yield* Ref.make(
122 new Map(
123 input.initialToken === undefined
124 ? []
125 : [[input.initialToken.environmentId, input.initialToken]],
126 ),
127 );
128 const bootstrapCalls = yield* Ref.make(0);
129 const relayInputs = yield* Ref.make<
130 ReadonlyArray<Parameters<ManagedRelay.ManagedRelayClient["Service"]["connectEnvironment"]>[0]>
131 >([]);
132 const session = yield* Ref.make<Option.Option<ClientCapabilities.CloudSessionIdentity>>(
133 Option.some({ accountId: "account-1" }),
134 );
135 const thumbprint = yield* Ref.make("thumbprint-1");
136 const tokenReads = yield* Queue.unbounded<EnvironmentId>();
137 const proofInputs = yield* Ref.make<
138 ReadonlyArray<{
139 readonly method: string;
140 readonly url: string;
141 readonly accessToken?: string;
142 }>
143 >([]);
144 const fetch = recordedFetch(input.responses);
145​
146 const tokenStore = TokenStore.RemoteDpopAccessTokenStore.of({
147 get: (environmentId) =>
148 Ref.get(tokens).pipe(
149 Effect.map((current) => Option.fromUndefinedOr(current.get(environmentId))),
150 Effect.tap(() => Queue.offer(tokenReads, environmentId)),
151 ),
152 put: (token) =>
153 (input.beforePut ?? Effect.void).pipe(
154 Effect.andThen(
155 Ref.update(tokens, (current) => {
156 const next = new Map(current);
157 next.set(token.environmentId, token);
158 return next;
159 }),
160 ),
161 ),
162 remove: (environmentId) =>
163 Ref.update(tokens, (current) => {
164 const next = new Map(current);
165 next.delete(environmentId);
166 return next;
167 }),
168 });
169 const signer = ManagedRelay.ManagedRelayDpopSigner.of({
170 thumbprint: Ref.get(thumbprint),
171 createProof: (proofInput) =>
172 Ref.update(proofInputs, (current) => [...current, proofInput]).pipe(
173 Effect.as(`proof:${proofInput.url}`),
174 ),
175 });
176 const unexpected = () => Effect.die("Unexpected relay request");
177 const relay = ManagedRelay.ManagedRelayClient.of({
178 relayUrl: "https://relay.example.test",
179 listEnvironments: unexpected,
180 listDevices: unexpected,
181 createEnvironmentLinkChallenge: unexpected,
182 linkEnvironment: unexpected,
183 unlinkEnvironment: unexpected,
184 getT3ChatLink: unexpected,
185 createT3ChatLinkRequest: unexpected,
186 unlinkT3Chat: unexpected,
187 getEnvironmentStatus: unexpected,
188 connectEnvironment: (request) =>
189 Effect.gen(function* () {
190 yield* Ref.update(bootstrapCalls, (count) => count + 1);
191 yield* Ref.update(relayInputs, (current) => [...current, request]);
192 yield* input.beforeBootstrap ?? Effect.void;
193 return input.bootstrap ?? BOOTSTRAP;
194 }),
195 registerDevice: unexpected,
196 unregisterDevice: unexpected,
197 registerLiveActivity: unexpected,
198 getAgentActivitySnapshot: unexpected,
199 resetTokenCache: Effect.void,
200 });
201 const layer = RemoteEnvironmentAuthorization.layer.pipe(
202 Layer.provideMerge(
203 Layer.mergeAll(
204 RpcHttp.layerRemoteHttpClient(fetch.fetchFn),
205 Layer.succeed(ManagedRelay.ManagedRelayDpopSigner, signer),
206 Layer.succeed(ManagedRelay.ManagedRelayClient, relay),
207 Layer.succeed(ClientCapabilities.CloudSession, {
208 identity: Ref.get(session),
209 clerkToken: input.clerkToken ?? Effect.succeed("clerk-session"),
210 }),
211 Layer.succeed(ClientCapabilities.RelayDeviceIdentity, {
212 deviceId: Effect.succeedSome("device-1"),
213 }),
214 Layer.succeed(TokenStore.RemoteDpopAccessTokenStore, tokenStore),
215 Layer.succeed(
216 ClientCapabilities.ClientPresentation,
217 ClientCapabilities.ClientPresentation.of({
218 metadata: {
219 label: "T3 Code Test",
220 deviceType: "mobile",
221 os: "test",
222 },
223 }),
224 ),
225 ),
226 ),
227 );
228 return {
229 layer,
230 tokens,
231 bootstrapCalls,
232 proofInputs,
233 fetch,
234 relayInputs,
235 session,
236 thumbprint,
237 tokenReads,
238 };
239});
240​
241const prepareDirectBearer = Effect.fn("TestRemoteAuthorization.prepareDirectBearer")(function* (
242 harness: Effect.Success<ReturnType<typeof makeHarness>>,
243 times: number,
244) {
245 const target = new BearerConnectionTarget({
246 environmentId: ENVIRONMENT_ID,
247 label: DESCRIPTOR.label,
248 connectionId: "direct-1",
249 });
250 const entry = {
251 target,
252 profile: Option.some(
253 new BearerConnectionProfile({
254 connectionId: target.connectionId,
255 environmentId: ENVIRONMENT_ID,
256 label: target.label,
257 httpBaseUrl: ENDPOINT.httpBaseUrl,
258 wsBaseUrl: ENDPOINT.wsBaseUrl,
259 }),
260 ),
261 enabled: true,
262 };
263 const unused = () => Effect.die("unused");
264 const layer = ConnectionResolver.layer.pipe(
265 Layer.provide(
266 Layer.mergeAll(
267 harness.layer,
268 Layer.succeed(ConnectionProfileStore.ConnectionProfileStore, {
269 get: unused,
270 put: unused,
271 remove: unused,
272 }),
273 Layer.succeed(ConnectionCredentialStore.ConnectionCredentialStore, {
274 get: () => Effect.succeedSome(new BearerConnectionCredential({ token: "bearer-token" })),
275 put: unused,
276 remove: unused,
277 }),
278 Layer.succeed(ClientCapabilities.PrimaryEnvironmentAuth, {
279 bearerToken: Effect.succeedNone,
280 }),
281 Layer.succeed(ClientCapabilities.SshEnvironmentGateway, {
282 provision: unused,
283 prepare: unused,
284 disconnect: unused,
285 }),
286 ),
287 ),
288 );
289 const resolver = yield* ConnectionResolver.ConnectionResolver.pipe(Effect.provide(layer));
290 return yield* Effect.forEach(Array.from({ length: times }), () =>
291 resolver.prepare(entry).pipe(Effect.result),
292 );
293});
294​
295describe("RemoteEnvironmentAuthorization", () => {
296 it.effect("prepares a cold direct bearer connection with one descriptor request", () =>
297 Effect.gen(function* () {
298 const harness = yield* makeHarness({
299 responses: [
300 Response.json({
301 ...DESCRIPTOR,
302 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
303 }),
304 websocketTicket("cold-ticket"),
305 ],
306 });
307​
308 const [prepared] = yield* prepareDirectBearer(harness, 1);
309​
310 expect(prepared).toMatchObject({
311 _tag: "Success",
312 success: { socketUrl: expect.stringContaining("wsTicket=cold-ticket") },
313 });
314 expect(harness.fetch.calls.map(([url]) => new URL(String(url)).pathname)).toEqual([
315 "/.well-known/t3/environment",
316 "/api/auth/websocket-ticket/rpc",
317 ]);
318 }),
319 );
320​
321 it.effect("reuses a matching descriptor a check just read, once, while fresh, over HTTPS", () =>
322 Effect.gen(function* () {
323 const descriptor = {
324 ...DESCRIPTOR,
325 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
326 } as ExecutionEnvironmentDescriptor;
327 const harness = yield* makeHarness({
328 responses: [
329 websocketTicket("reused"),
330 ...Array.from({ length: 5 }, () => [
331 Response.json(descriptor),
332 websocketTicket("fresh"),
333 ]).flat(),
334 ],
335 });
336​
337 yield* Effect.gen(function* () {
338 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
339 const authorizeAt = (httpBaseUrl: string) =>
340 remote.authorizeBearer({
341 expectedEnvironmentId: ENVIRONMENT_ID,
342 httpBaseUrl,
343 wsBaseUrl: httpBaseUrl.replace(/^http/, "ws"),
344 bearerToken: "bearer-token",
345 connectionMethod: "direct",
346 });
347 const authorize = authorizeAt(ENDPOINT.httpBaseUrl);
348 const remember = (value: Option.Option<ExecutionEnvironmentDescriptor>) =>
349 remote.rememberCheckedDescriptor(ENDPOINT.httpBaseUrl, value);
350​
351 yield* remember(Option.some(descriptor));
352 yield* authorize;
353 // Used once.
354 yield* authorize;
355 // Stale.
356 yield* remember(Option.some(descriptor));
357 yield* TestClock.adjust("6 seconds");
358 yield* authorize;
359 // A mismatch reads again, so a host back on the right environment is not blocked.
360 yield* remember(Option.some({ ...descriptor, environmentId: "other" as never }));
361 yield* authorize;
362 // A failed check drops an older match.
363 yield* remember(Option.some(descriptor));
364 yield* remember(Option.none());
365 yield* authorize;
366 // After a network change, a plain LAN address can belong to another machine.
367 yield* remote.rememberCheckedDescriptor("http://192.168.1.2:3773", Option.some(descriptor));
368 yield* authorizeAt("http://192.168.1.2:3773");
369 }).pipe(Effect.provide(harness.layer));
370​
371 expect(harness.fetch.calls.map(([url]) => new URL(String(url)).pathname)).toEqual([
372 "/api/auth/websocket-ticket/rpc",
373 ...Array.from({ length: 5 }, () => [
374 "/.well-known/t3/environment",
375 "/api/auth/websocket-ticket/rpc",
376 ]).flat(),
377 ]);
378 }),
379 );
380​
381 it.effect("blocks a warm direct bearer prepare when the environment changes identity", () =>
382 Effect.gen(function* () {
383 const harness = yield* makeHarness({
384 responses: [
385 Response.json({
386 ...DESCRIPTOR,
387 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
388 }),
389 websocketTicket("first-ticket"),
390 Response.json({
391 ...DESCRIPTOR,
392 environmentId: "another-environment",
393 orchestrationProtocolVersion: ORCHESTRATION_PROTOCOL_VERSION,
394 }),
395 ],
396 });
397​
398 const [first, second] = yield* prepareDirectBearer(harness, 2);
399​
400 expect(first?._tag).toBe("Success");
401 expect(second).toMatchObject({
402 _tag: "Failure",
403 failure: { _tag: "ConnectionBlockedError", reason: "configuration" },
404 });
405 expect(
406 harness.fetch.calls.filter(([url]) =>
407 String(url).endsWith("/api/auth/websocket-ticket/rpc"),
408 ),
409 ).toHaveLength(1);
410 }),
411 );
412 it.effect("validates a fresh bearer descriptor while issuing fresh websocket tickets", () =>
413 Effect.gen(function* () {
414 const harness = yield* makeHarness({
415 responses: [
416 Response.json(DESCRIPTOR),
417 websocketTicket("first-ticket"),
418 Response.json(DESCRIPTOR),
419 websocketTicket("second-ticket"),
420 ],
421 });
422​
423 const [first, second] = yield* Effect.gen(function* () {
424 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
425 const authorize = () =>
426 remote.authorizeBearer({
427 expectedEnvironmentId: ENVIRONMENT_ID,
428 httpBaseUrl: ENDPOINT.httpBaseUrl,
429 wsBaseUrl: ENDPOINT.wsBaseUrl,
430 bearerToken: "bearer-token",
431 connectionMethod: "direct",
432 });
433 return [yield* authorize(), yield* authorize()] as const;
434 }).pipe(Effect.provide(harness.layer));
435​
436 expect(first.socketUrl).toContain("wsTicket=first-ticket");
437 expect(second.socketUrl).toContain("wsTicket=second-ticket");
438 expect(
439 harness.fetch.calls.filter(([url]) => String(url).endsWith("/.well-known/t3/environment")),
440 ).toHaveLength(2);
441 expect(
442 harness.fetch.calls.filter(([url]) =>
443 String(url).endsWith("/api/auth/websocket-ticket/rpc"),
444 ),
445 ).toHaveLength(2);
446 }),
447 );
448​
449 it.effect("reuses a same-account persisted environment token without contacting the relay", () =>
450 Effect.gen(function* () {
451 const cached = new TokenStore.RemoteDpopAccessToken({
452 environmentId: ENVIRONMENT_ID,
453 accountId: "account-1",
454 label: DESCRIPTOR.label,
455 endpoint: ENDPOINT,
456 accessToken: "cached-access-token",
457 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
458 dpopThumbprint: "thumbprint-1",
459 });
460 const harness = yield* makeHarness({
461 initialToken: cached,
462 responses: [websocketTicket("cached-ticket")],
463 });
464​
465 const authorized = yield* Effect.gen(function* () {
466 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
467 return yield* remote.authorizeDpop({
468 expectedEnvironmentId: ENVIRONMENT_ID,
469 });
470 }).pipe(Effect.provide(harness.layer));
471​
472 expect(authorized.socketUrl).toContain("wsTicket=cached-ticket");
473 expect(authorized.socketUrl).toContain("connectionMethod=relay");
474 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
475 expect(harness.fetch.calls).toHaveLength(1);
476 expect(String(harness.fetch.calls[0]?.[0])).toBe(
477 "https://environment.example.test/api/auth/websocket-ticket/rpc",
478 );
479 }),
480 );
481​
482 it.effect("uses the T3 Connect token on a learned direct address without the relay", () =>
483 Effect.gen(function* () {
484 const cached = new TokenStore.RemoteDpopAccessToken({
485 environmentId: ENVIRONMENT_ID,
486 accountId: "account-1",
487 label: DESCRIPTOR.label,
488 endpoint: ENDPOINT,
489 accessToken: "cached-access-token",
490 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
491 dpopThumbprint: "thumbprint-1",
492 });
493 const harness = yield* makeHarness({
494 initialToken: cached,
495 responses: [Response.json(DESCRIPTOR), websocketTicket("lan-ticket")],
496 });
497​
498 const authorized = yield* Effect.gen(function* () {
499 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
500 return yield* remote.authorizeDpop({
501 expectedEnvironmentId: ENVIRONMENT_ID,
502 directEndpoint: {
503 httpBaseUrl: "http://192.168.1.10:3773/",
504 wsBaseUrl: "ws://192.168.1.10:3773/",
505 },
506 });
507 }).pipe(Effect.provide(harness.layer));
508​
509 expect(authorized.httpBaseUrl).toBe("http://192.168.1.10:3773/");
510 expect(authorized.socketUrl).toMatch(/^ws:\/\/192\.168\.1\.10:3773\/ws\?/);
511 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
512 expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
513 "http://192.168.1.10:3773/.well-known/t3/environment",
514 "http://192.168.1.10:3773/api/auth/websocket-ticket/rpc",
515 ]);
516 }),
517 );
518​
519 it.effect("sends no token to a direct address that answers as another machine", () =>
520 Effect.gen(function* () {
521 const harness = yield* makeHarness({
522 initialToken: persistedToken({ accessToken: "cached-access-token" }),
523 responses: [
524 Response.json({ ...DESCRIPTOR, environmentId: EnvironmentId.make("someone-else") }),
525 ],
526 });
527​
528 const error = yield* Effect.gen(function* () {
529 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
530 return yield* remote
531 .authorizeDpop({
532 expectedEnvironmentId: ENVIRONMENT_ID,
533 directEndpoint: {
534 httpBaseUrl: "http://192.168.1.10:3773/",
535 wsBaseUrl: "ws://192.168.1.10:3773/",
536 },
537 })
538 .pipe(Effect.flip);
539 }).pipe(Effect.provide(harness.layer));
540​
541 expect(error).toMatchObject({ _tag: "ConnectionBlockedError", reason: "configuration" });
542 expect(harness.fetch.calls.map(([url]) => String(url))).toEqual([
543 "http://192.168.1.10:3773/.well-known/t3/environment",
544 ]);
545 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
546 "cached-access-token",
547 );
548 }),
549 );
550​
551 it.effect("refreshes and persists an expired environment token", () =>
552 Effect.gen(function* () {
553 const expired = new TokenStore.RemoteDpopAccessToken({
554 environmentId: ENVIRONMENT_ID,
555 accountId: "account-1",
556 label: DESCRIPTOR.label,
557 endpoint: ENDPOINT,
558 accessToken: "expired-access-token",
559 expiresAtEpochMs: 0,
560 dpopThumbprint: "thumbprint-1",
561 });
562 const harness = yield* makeHarness({
563 initialToken: expired,
564 responses: [
565 Response.json(DESCRIPTOR),
566 accessToken("fresh-access-token"),
567 websocketTicket("fresh-ticket"),
568 ],
569 });
570​
571 const authorized = yield* Effect.gen(function* () {
572 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
573 return yield* remote.authorizeDpop({
574 expectedEnvironmentId: ENVIRONMENT_ID,
575 });
576 }).pipe(Effect.provide(harness.layer));
577​
578 expect(authorized.socketUrl).toContain("wsTicket=fresh-ticket");
579 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
580 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
581 expect.objectContaining({
582 accessToken: "fresh-access-token",
583 dpopThumbprint: "thumbprint-1",
584 }),
585 );
586 expect(harness.fetch.calls).toHaveLength(3);
587 }),
588 );
589​
590 it.effect.each([
591 { name: "read-only", grantScopes: ["orchestration:read"] },
592 { name: "default", grantScopes: AuthStandardClientScopes },
593 ] as const)(
594 "inherits $name pairing grant scopes for websocket authorization and HTTP renewal",
595 ({ grantScopes }) =>
596 Effect.gen(function* () {
597 const grantedScope = grantScopes.join(" ");
598 let exchangeCount = 0;
599 const tokenFields = (init: RequestInit) =>
600 new URLSearchParams(
601 init.body instanceof Uint8Array
602 ? new TextDecoder().decode(init.body)
603 : String(init.body),
604 );
605 const exchangeGrant = (init: RequestInit) => {
606 const fields = tokenFields(init);
607 expect(fields.get("scope")).toBeNull();
608 const scope = fields.get("scope") ?? grantedScope;
609 const scopes = scope.split(" ");
610 if (scopes.some((requested) => !grantScopes.some((grant) => grant === requested))) {
611 return authInvalid();
612 }
613 return accessToken(`access-token:${++exchangeCount}:${scopes.join(",")}`, scope);
614 };
615 const harness = yield* makeHarness({
616 responses: [
617 Response.json(DESCRIPTOR),
618 exchangeGrant,
619 websocketTicket("granted-ticket"),
620 Response.json(DESCRIPTOR),
621 exchangeGrant,
622 ],
623 });
624​
625 const [authorized, refreshed] = yield* Effect.gen(function* () {
626 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
627 const first = yield* remote.authorizeDpop({
628 expectedEnvironmentId: ENVIRONMENT_ID,
629 });
630 yield* TestClock.adjust("1 hour");
631 const refreshed = yield* remote.authorizeDpopHttp({
632 expectedEnvironmentId: ENVIRONMENT_ID,
633 });
634 return [first, refreshed] as const;
635 }).pipe(Effect.provide(Layer.merge(harness.layer, TestClock.layer())));
636​
637 expect(authorized.socketUrl).toContain("wsTicket=granted-ticket");
638 expect(authorized.httpAuthorization).toMatchObject({
639 _tag: "Dpop",
640 accessToken: `access-token:1:${grantScopes.join(",")}`,
641 });
642 expect(refreshed.httpAuthorization).toMatchObject({
643 _tag: "Dpop",
644 accessToken: `access-token:2:${grantScopes.join(",")}`,
645 });
646 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toMatchObject({
647 accessToken: `access-token:2:${grantScopes.join(",")}`,
648 dpopThumbprint: "thumbprint-1",
649 });
650 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
651 const exchanges = harness.fetch.calls.filter(([url]) =>
652 String(url).endsWith("/oauth/token"),
653 );
654 expect(exchanges).toHaveLength(2);
655 for (const [, init] of exchanges) {
656 expect(Object.fromEntries(tokenFields(init))).toMatchObject({
657 subject_token: BOOTSTRAP.credential,
658 client_label: "T3 Code Test",
659 client_device_type: "mobile",
660 client_os: "test",
661 });
662 }
663 }),
664 );
665​
666 it.effect("renews a live socket's token in the minute before each expiry", () =>
667 Effect.gen(function* () {
668 const puts = yield* Queue.unbounded<void>();
669 const relayBlips = yield* Ref.make(1);
670 const harness = yield* makeHarness({
671 beforeBootstrap: Ref.getAndUpdate(relayBlips, (count) => count - 1).pipe(
672 Effect.flatMap((count) =>
673 count > 0
674 ? Effect.fail(
675 new ManagedRelay.ManagedRelayRequestTimeoutError({
676 activity: "Relay environment connection",
677 timeoutMs: 30_000,
678 traceId: null,
679 }),
680 )
681 : Effect.void,
682 ),
683 ),
684 initialToken: persistedToken({ expiresAtEpochMs: 3_600_000 }),
685 responses: [
686 Response.json(DESCRIPTOR),
687 accessToken("renewed-1"),
688 Response.json(DESCRIPTOR),
689 accessToken("renewed-2"),
690 ],
691 beforePut: Queue.offer(puts, undefined).pipe(Effect.asVoid),
692 });
693​
694 yield* Effect.gen(function* () {
695 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
696 yield* remote
697 .renewDpopBeforeExpiry({
698 expectedEnvironmentId: ENVIRONMENT_ID,
699 expiresAtEpochMs: 3_600_000,
700 })
701 .pipe(Effect.forkScoped);
702 yield* TestClock.adjust(3_540_000 - 1);
703 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(0);
704 // The first try hits a relay blip, and the retry 5 s later succeeds.
705 yield* TestClock.adjust(1);
706 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
707 yield* TestClock.adjust(5_000);
708 yield* Queue.take(puts);
709 // Renewed at 0:59:05, so the next renewal is at 1:58:05.
710 yield* TestClock.adjust(7_085_000 - 3_545_000 - 1);
711 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
712 yield* TestClock.adjust(1);
713 yield* Queue.take(puts);
714 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(3);
715 }).pipe(Effect.scoped, Effect.provide(Layer.merge(harness.layer, TestClock.layer())));
716 }),
717 );
718​
719 it.effect("evicts an auth-invalid cached token and obtains a fresh bootstrap", () =>
720 Effect.gen(function* () {
721 const cached = new TokenStore.RemoteDpopAccessToken({
722 environmentId: ENVIRONMENT_ID,
723 accountId: "account-1",
724 label: DESCRIPTOR.label,
725 endpoint: ENDPOINT,
726 accessToken: "invalid-access-token",
727 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
728 dpopThumbprint: "thumbprint-1",
729 });
730 const harness = yield* makeHarness({
731 initialToken: cached,
732 responses: [
733 authInvalid(),
734 Response.json(DESCRIPTOR),
735 accessToken("replacement-access-token"),
736 websocketTicket("replacement-ticket"),
737 ],
738 });
739​
740 const authorized = yield* Effect.gen(function* () {
741 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
742 return yield* remote.authorizeDpop({
743 expectedEnvironmentId: ENVIRONMENT_ID,
744 });
745 }).pipe(Effect.provide(harness.layer));
746​
747 expect(authorized.socketUrl).toContain("wsTicket=replacement-ticket");
748 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
749 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
750 expect.objectContaining({
751 accessToken: "replacement-access-token",
752 }),
753 );
754 expect(harness.fetch.calls).toHaveLength(4);
755 }),
756 );
757​
758 it.effect("refreshes a cached endpoint after its first transient failure", () =>
759 Effect.gen(function* () {
760 const cached = new TokenStore.RemoteDpopAccessToken({
761 environmentId: ENVIRONMENT_ID,
762 accountId: "account-1",
763 label: DESCRIPTOR.label,
764 endpoint: ENDPOINT,
765 accessToken: "cached-access-token",
766 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
767 dpopThumbprint: "thumbprint-1",
768 });
769 const harness = yield* makeHarness({
770 initialToken: cached,
771 responses: [
772 new Response("endpoint unavailable", { status: 503 }),
773 Response.json(DESCRIPTOR),
774 accessToken("replacement-access-token"),
775 websocketTicket("replacement-ticket"),
776 ],
777 });
778​
779 const authorized = yield* Effect.gen(function* () {
780 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
781 return yield* remote.authorizeDpop({
782 expectedEnvironmentId: ENVIRONMENT_ID,
783 });
784 }).pipe(Effect.provide(harness.layer));
785​
786 expect(authorized.socketUrl).toContain("wsTicket=replacement-ticket");
787 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
788 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)).toEqual(
789 expect.objectContaining({
790 accessToken: "replacement-access-token",
791 }),
792 );
793 expect(harness.fetch.calls).toHaveLength(4);
794 }),
795 );
796​
797 it.effect("removes a newly refreshed token when websocket ticket authorization fails", () =>
798 Effect.gen(function* () {
799 const harness = yield* makeHarness({
800 responses: [
801 Response.json(DESCRIPTOR),
802 accessToken("unusable-access-token"),
803 new Response("endpoint unavailable", { status: 503 }),
804 ],
805 });
806​
807 yield* Effect.gen(function* () {
808 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
809 return yield* remote.authorizeDpop({
810 expectedEnvironmentId: ENVIRONMENT_ID,
811 });
812 }).pipe(Effect.provide(harness.layer), Effect.flip);
813​
814 expect((yield* Ref.get(harness.tokens)).has(ENVIRONMENT_ID)).toBe(false);
815 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
816 expect(harness.fetch.calls).toHaveLength(3);
817 }),
818 );
819​
820 it.effect("does not evict a replacement token when a late request rejects the old one", () =>
821 Effect.gen(function* () {
822 const harness = yield* makeHarness({
823 initialToken: persistedToken(),
824 responses: [Response.json(DESCRIPTOR), accessToken("replacement-token")],
825 });
826 yield* Effect.gen(function* () {
827 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
828 const initial = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
829 const retry = {
830 expectedEnvironmentId: ENVIRONMENT_ID,
831 rejectedAccessToken: initial.httpAuthorization.accessToken,
832 };
833 const first = yield* remote.authorizeDpopHttp(retry);
834 const late = yield* remote.authorizeDpopHttp(retry);
835 expect(first.httpAuthorization.accessToken).toBe("replacement-token");
836 expect(late).toEqual(first);
837 }).pipe(Effect.provide(harness.layer));
838​
839 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
840 expect(harness.fetch.calls).toHaveLength(2);
841 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accessToken).toBe(
842 "replacement-token",
843 );
844 }),
845 );
846​
847 it.effect("shares one in-flight renewal between concurrent HTTP requests", () =>
848 Effect.gen(function* () {
849 const started = yield* Deferred.make<void>();
850 const release = yield* Deferred.make<void>();
851 const harness = yield* makeHarness({
852 initialToken: persistedToken({ expiresAtEpochMs: 0 }),
853 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
854 Effect.andThen(Deferred.await(release)),
855 ),
856 responses: [Response.json(DESCRIPTOR), accessToken("shared-token")],
857 });
858 yield* Effect.gen(function* () {
859 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
860 const requests = yield* Effect.all(
861 Array.from({ length: 6 }, () =>
862 remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID }),
863 ),
864 { concurrency: "unbounded" },
865 ).pipe(Effect.forkChild);
866 yield* Queue.takeN(harness.tokenReads, 6);
867 yield* Deferred.await(started);
868 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
869 yield* Deferred.succeed(release, undefined);
870 const results = yield* Fiber.join(requests);
871 expect(results.map((result) => result.httpAuthorization.accessToken)).toEqual(
872 Array(6).fill("shared-token"),
873 );
874 }).pipe(Effect.provide(harness.layer));
875​
876 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
877 expect(harness.fetch.calls).toHaveLength(2);
878 }),
879 );
880​
881 it.effect(
882 "shares a failed renewal and allows a later attempt instead of caching its failure",
883 () =>
884 Effect.gen(function* () {
885 const release = yield* Deferred.make<void, ManagedRelay.ManagedRelayClientError>();
886 const failure = new ManagedRelay.ManagedRelayRequestTimeoutError({
887 activity: "Relay environment connection",
888 timeoutMs: ManagedRelay.MANAGED_RELAY_REQUEST_TIMEOUT_MS,
889 traceId: null,
890 });
891 const harness = yield* makeHarness({
892 responses: [],
893 beforeBootstrap: Deferred.await(release),
894 });
895 yield* Effect.gen(function* () {
896 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
897 const requests = yield* Effect.all(
898 Array.from({ length: 6 }, () =>
899 remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID }).pipe(Effect.flip),
900 ),
901 { concurrency: "unbounded" },
902 ).pipe(Effect.forkChild);
903 yield* Queue.takeN(harness.tokenReads, 6);
904 yield* Deferred.fail(release, failure);
905 const failures = yield* Fiber.join(requests);
906 expect(failures).toEqual(
907 Array(6).fill(
908 expect.objectContaining({
909 _tag: "ConnectionTransientError",
910 reason: "timeout",
911 }),
912 ),
913 );
914 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
915 yield* remote
916 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
917 .pipe(Effect.flip);
918 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(2);
919 }).pipe(Effect.provide(harness.layer));
920 expect(harness.fetch.calls).toHaveLength(0);
921 }),
922 );
923​
924 it.effect("does not block another environment behind a pending renewal", () =>
925 Effect.gen(function* () {
926 const started = yield* Deferred.make<void>();
927 const release = yield* Deferred.make<void>();
928 const otherEnvironmentId = EnvironmentId.make("environment-2");
929 const harness = yield* makeHarness({
930 initialToken: persistedToken({
931 environmentId: otherEnvironmentId,
932 accessToken: "other-token",
933 }),
934 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
935 Effect.andThen(Deferred.await(release)),
936 ),
937 responses: [Response.json(DESCRIPTOR), accessToken("fresh-token")],
938 });
939 yield* Effect.gen(function* () {
940 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
941 const pending = yield* remote
942 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
943 .pipe(Effect.forkChild);
944 yield* Deferred.await(started);
945 const other = yield* remote.authorizeDpopHttp({
946 expectedEnvironmentId: otherEnvironmentId,
947 });
948 expect(other.httpAuthorization.accessToken).toBe("other-token");
949 yield* Deferred.succeed(release, undefined);
950 yield* Fiber.join(pending);
951 }).pipe(Effect.provide(harness.layer));
952 }),
953 );
954​
955 it.effect("retries instead of blocking while the cloud session has not loaded", () =>
956 Effect.gen(function* () {
957 const harness = yield* makeHarness({
958 responses: [Response.json(DESCRIPTOR), accessToken("loaded-token")],
959 });
960 yield* Ref.set(harness.session, Option.none());
961 yield* Effect.gen(function* () {
962 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
963 const pending = yield* remote
964 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
965 .pipe(Effect.flip);
966 expect(pending).toMatchObject({
967 _tag: "ConnectionTransientError",
968 reason: "session-pending",
969 });
970 yield* Ref.set(harness.session, Option.some({ accountId: "account-1" }));
971 const loaded = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
972 expect(loaded.httpAuthorization.accessToken).toBe("loaded-token");
973 }).pipe(Effect.provide(harness.layer));
974 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
975 }),
976 );
977​
978 it.effect("does not return or persist credentials after logout during renewal", () =>
979 Effect.gen(function* () {
980 const started = yield* Deferred.make<void>();
981 const release = yield* Deferred.make<void>();
982 const harness = yield* makeHarness({
983 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
984 Effect.andThen(Deferred.await(release)),
985 ),
986 responses: [],
987 });
988 yield* Effect.gen(function* () {
989 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
990 const pending = yield* remote
991 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
992 .pipe(Effect.flip, Effect.forkChild);
993 yield* Deferred.await(started);
994 yield* Ref.set(harness.session, Option.none());
995 yield* Deferred.succeed(release, undefined);
996 expect(yield* Fiber.join(pending)).toMatchObject({
997 _tag: "ConnectionBlockedError",
998 reason: "authentication",
999 });
1000 }).pipe(Effect.provide(harness.layer));
1001 expect((yield* Ref.get(harness.tokens)).size).toBe(0);
1002 expect(harness.fetch.calls).toHaveLength(0);
1003 }),
1004 );
1005​
1006 it.effect("removes an obsolete credential if logout overlaps the persistent write", () =>
1007 Effect.gen(function* () {
1008 const started = yield* Deferred.make<void>();
1009 const release = yield* Deferred.make<void>();
1010 const harness = yield* makeHarness({
1011 beforePut: Deferred.succeed(started, undefined).pipe(
1012 Effect.andThen(Deferred.await(release)),
1013 ),
1014 responses: [Response.json(DESCRIPTOR), accessToken("obsolete-token")],
1015 });
1016 yield* Effect.gen(function* () {
1017 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1018 const pending = yield* remote
1019 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1020 .pipe(Effect.flip, Effect.forkChild);
1021 yield* Deferred.await(started);
1022 yield* Ref.set(harness.session, Option.none());
1023 yield* Deferred.succeed(release, undefined);
1024 expect(yield* Fiber.join(pending)).toMatchObject({
1025 _tag: "ConnectionBlockedError",
1026 reason: "authentication",
1027 });
1028 }).pipe(Effect.provide(harness.layer));
1029 expect((yield* Ref.get(harness.tokens)).size).toBe(0);
1030 }),
1031 );
1032​
1033 it.effect(
1034 "renews another account's persisted token after the authorization service restarts",
1035 () =>
1036 Effect.gen(function* () {
1037 const harness = yield* makeHarness({
1038 initialToken: persistedToken(),
1039 responses: [Response.json(DESCRIPTOR), accessToken("account-2-token")],
1040 });
1041 const authorize = Effect.gen(function* () {
1042 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1043 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1044 }).pipe(Effect.provide(harness.layer));
1045​
1046 expect((yield* authorize).httpAuthorization.accessToken).toBe("cached-access-token");
1047 yield* Ref.set(harness.session, Option.some({ accountId: "account-2" }));
1048 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-2-token");
1049 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accountId).toBe("account-2");
1050​
1051 yield* Ref.set(harness.session, Option.some({ accountId: "account-2" }));
1052 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-2-token");
1053 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1054 expect(harness.fetch.calls).toHaveLength(2);
1055 }),
1056 );
1057​
1058 it.effect("renews a legacy unowned token once and reuses its account-bound replacement", () =>
1059 Effect.gen(function* () {
1060 const legacy = new TokenStore.RemoteDpopAccessToken({
1061 environmentId: ENVIRONMENT_ID,
1062 label: DESCRIPTOR.label,
1063 endpoint: ENDPOINT,
1064 accessToken: "legacy-access-token",
1065 expiresAtEpochMs: Number.MAX_SAFE_INTEGER,
1066 dpopThumbprint: "thumbprint-1",
1067 });
1068 const harness = yield* makeHarness({
1069 initialToken: legacy,
1070 responses: [Response.json(DESCRIPTOR), accessToken("account-bound-token")],
1071 });
1072 const authorize = Effect.gen(function* () {
1073 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1074 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1075 }).pipe(Effect.provide(harness.layer));
1076​
1077 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-bound-token");
1078 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.accountId).toBe("account-1");
1079 expect((yield* authorize).httpAuthorization.accessToken).toBe("account-bound-token");
1080 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1081 expect(harness.fetch.calls).toHaveLength(2);
1082 }),
1083 );
1084​
1085 it.effect("requires fresh credentials after signing back into the same account", () =>
1086 Effect.gen(function* () {
1087 const harness = yield* makeHarness({
1088 initialToken: persistedToken(),
1089 responses: [Response.json(DESCRIPTOR), accessToken("new-session-token")],
1090 });
1091 yield* Effect.gen(function* () {
1092 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1093 yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1094 yield* Ref.set(harness.session, Option.none());
1095 yield* Ref.set(harness.session, Option.some({ accountId: "account-1" }));
1096 const signedIn = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1097 expect(signedIn.httpAuthorization.accessToken).toBe("new-session-token");
1098 }).pipe(Effect.provide(harness.layer));
1099 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1100 }),
1101 );
1102​
1103 it.effect("renews a cached credential bound to a different signing key", () =>
1104 Effect.gen(function* () {
1105 const harness = yield* makeHarness({
1106 initialToken: persistedToken(),
1107 responses: [Response.json(DESCRIPTOR), accessToken("new-key-token")],
1108 });
1109 yield* Ref.set(harness.thumbprint, "thumbprint-2");
1110 yield* Effect.gen(function* () {
1111 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1112 const authorized = yield* remote.authorizeDpopHttp({
1113 expectedEnvironmentId: ENVIRONMENT_ID,
1114 });
1115 expect(authorized.httpAuthorization.accessToken).toBe("new-key-token");
1116 }).pipe(Effect.provide(harness.layer));
1117 expect((yield* Ref.get(harness.tokens)).get(ENVIRONMENT_ID)?.dpopThumbprint).toBe(
1118 "thumbprint-2",
1119 );
1120 }),
1121 );
1122​
1123 it.effect("rejects a relay bootstrap for a different environment before contacting it", () =>
1124 Effect.gen(function* () {
1125 const harness = yield* makeHarness({
1126 responses: [],
1127 bootstrap: { ...BOOTSTRAP, environmentId: EnvironmentId.make("wrong-environment") },
1128 });
1129 const failure = yield* Effect.gen(function* () {
1130 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1131 return yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1132 }).pipe(Effect.provide(harness.layer), Effect.flip);
1133 expect(failure).toMatchObject({ _tag: "ConnectionBlockedError", reason: "configuration" });
1134 expect(harness.fetch.calls).toHaveLength(0);
1135 }),
1136 );
1137​
1138 it.effect("keeps a shared renewal alive when one waiting request is interrupted", () =>
1139 Effect.gen(function* () {
1140 const started = yield* Deferred.make<void>();
1141 const release = yield* Deferred.make<void>();
1142 const harness = yield* makeHarness({
1143 beforeBootstrap: Deferred.succeed(started, undefined).pipe(
1144 Effect.andThen(Deferred.await(release)),
1145 ),
1146 responses: [Response.json(DESCRIPTOR), accessToken("fresh-token")],
1147 });
1148 yield* Effect.gen(function* () {
1149 const remote = yield* RemoteEnvironmentAuthorization.RemoteEnvironmentAuthorization;
1150 const pending = yield* remote
1151 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1152 .pipe(Effect.forkChild);
1153 yield* Deferred.await(started);
1154 const other = yield* remote
1155 .authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID })
1156 .pipe(Effect.forkChild);
1157 yield* Queue.takeN(harness.tokenReads, 2);
1158 yield* Fiber.interrupt(pending);
1159 yield* Deferred.succeed(release, undefined);
1160 const authorized = yield* Fiber.join(other);
1161 expect(authorized.httpAuthorization.accessToken).toBe("fresh-token");
1162 const cached = yield* remote.authorizeDpopHttp({ expectedEnvironmentId: ENVIRONMENT_ID });
1163 expect(cached).toEqual(authorized);
1164 }).pipe(Effect.provide(harness.layer));
1165 expect(yield* Ref.get(harness.bootstrapCalls)).toBe(1);
1166 }),
1167 );
1168});