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 { EnvironmentId } from "@t3tools/contracts"; |
| 2 | import type { |
| 3 | RelayClientEnvironmentRecord, |
| 4 | RelayEnvironmentStatusResponse, |
| 5 | } from "@t3tools/contracts/relay"; |
| 6 | import { describe, expect, it } from "@effect/vitest"; |
| 7 | import * as Deferred from "effect/Deferred"; |
| 8 | import * as Effect from "effect/Effect"; |
| 9 | import * as Fiber from "effect/Fiber"; |
| 10 | import * as Layer from "effect/Layer"; |
| 11 | import * as Option from "effect/Option"; |
| 12 | import * as Ref from "effect/Ref"; |
| 13 | import * as Stream from "effect/Stream"; |
| 14 | import * as SubscriptionRef from "effect/SubscriptionRef"; |
| 15 | import { Atom, AtomRegistry } from "effect/reactivity"; |
| 16 | |
| 17 | import * as ManagedRelay from "./managedRelay.ts"; |
| 18 | import * as ClientCapabilities from "../platform/capabilities.ts"; |
| 19 | import * as Connectivity from "../connection/connectivity.ts"; |
| 20 | import { ConnectionBlockedError, type NetworkStatus } from "../connection/model.ts"; |
| 21 | import * as ConnectionWakeups from "../connection/wakeups.ts"; |
| 22 | import * as RelayEnvironmentDiscovery from "./discovery.ts"; |
| 23 | import { NETWORK_BLOCKING_HINT } from "../errors/network.ts"; |
| 24 | import { createRelayEnvironmentDiscoveryAtoms } from "../state/relayDiscovery.ts"; |
| 25 | |
| 26 | const environments = [ |
| 27 | { |
| 28 | environmentId: EnvironmentId.make("environment-1"), |
| 29 | label: "Environment One", |
| 30 | endpoint: { |
| 31 | httpBaseUrl: "https://one.example.test", |
| 32 | wsBaseUrl: "wss://one.example.test", |
| 33 | providerKind: "cloudflare_tunnel", |
| 34 | }, |
| 35 | linkedAt: "2026-06-01T00:00:00.000Z", |
| 36 | }, |
| 37 | { |
| 38 | environmentId: EnvironmentId.make("environment-2"), |
| 39 | label: "Environment Two", |
| 40 | endpoint: { |
| 41 | httpBaseUrl: "https://two.example.test", |
| 42 | wsBaseUrl: "wss://two.example.test", |
| 43 | providerKind: "cloudflare_tunnel", |
| 44 | }, |
| 45 | linkedAt: "2026-06-01T00:00:00.000Z", |
| 46 | }, |
| 47 | ] satisfies ReadonlyArray<RelayClientEnvironmentRecord>; |
| 48 | |
| 49 | function status( |
| 50 | environment: RelayClientEnvironmentRecord, |
| 51 | value: "online" | "offline", |
| 52 | ): RelayEnvironmentStatusResponse { |
| 53 | return { |
| 54 | environmentId: environment.environmentId, |
| 55 | endpoint: environment.endpoint, |
| 56 | status: value, |
| 57 | checkedAt: "2026-06-01T00:00:00.000Z", |
| 58 | }; |
| 59 | } |
| 60 | |
| 61 | const makeHarness = Effect.fn("RelayDiscoveryTest.makeHarness")(function* () { |
| 62 | const networkStatus = yield* SubscriptionRef.make<NetworkStatus>("online"); |
| 63 | const listCalls = yield* Ref.make(0); |
| 64 | const statusCalls = yield* Ref.make(0); |
| 65 | const listedEnvironments = |
| 66 | yield* Ref.make<ReadonlyArray<RelayClientEnvironmentRecord>>(environments); |
| 67 | const listFailure = yield* Ref.make<ManagedRelay.ManagedRelayClientError | null>(null); |
| 68 | const secondListCall = yield* Deferred.make<void>(); |
| 69 | const clerkToken = yield* Ref.make<string | null>("clerk-token"); |
| 70 | const sessionIdentity = { accountId: "account-1" }; |
| 71 | const wakeups = yield* SubscriptionRef.make<{ |
| 72 | readonly sequence: number; |
| 73 | readonly reason: ConnectionWakeups.ConnectionWakeup; |
| 74 | }>({ |
| 75 | sequence: 0, |
| 76 | reason: "application-active", |
| 77 | }); |
| 78 | const statusRequests = yield* Ref.make( |
| 79 | new Map< |
| 80 | string, |
| 81 | Deferred.Deferred<RelayEnvironmentStatusResponse, ManagedRelay.ManagedRelayClientError> |
| 82 | >(), |
| 83 | ); |
| 84 | for (const environment of environments) { |
| 85 | const request = yield* Deferred.make< |
| 86 | RelayEnvironmentStatusResponse, |
| 87 | ManagedRelay.ManagedRelayClientError |
| 88 | >(); |
| 89 | yield* Ref.update(statusRequests, (current) => { |
| 90 | const next = new Map(current); |
| 91 | next.set(environment.environmentId, request); |
| 92 | return next; |
| 93 | }); |
| 94 | } |
| 95 | |
| 96 | const client = ManagedRelay.ManagedRelayClient.of({ |
| 97 | relayUrl: "https://relay.example.test", |
| 98 | listEnvironments: () => |
| 99 | Effect.gen(function* () { |
| 100 | const count = yield* Ref.updateAndGet(listCalls, (current) => current + 1); |
| 101 | if (count >= 2) { |
| 102 | yield* Deferred.succeed(secondListCall, undefined); |
| 103 | } |
| 104 | const failure = yield* Ref.get(listFailure); |
| 105 | if (failure) { |
| 106 | return yield* failure; |
| 107 | } |
| 108 | return yield* Ref.get(listedEnvironments); |
| 109 | }), |
| 110 | getEnvironmentStatus: ({ environmentId }) => |
| 111 | Ref.update(statusCalls, (current) => current + 1).pipe( |
| 112 | Effect.andThen(Ref.get(statusRequests)), |
| 113 | Effect.flatMap((requests) => Deferred.await(requests.get(environmentId)!)), |
| 114 | ), |
| 115 | listDevices: () => Effect.die("unused"), |
| 116 | createEnvironmentLinkChallenge: () => Effect.die("unused"), |
| 117 | linkEnvironment: () => Effect.die("unused"), |
| 118 | unlinkEnvironment: () => Effect.die("unused"), |
| 119 | getT3ChatLink: () => Effect.die("unused"), |
| 120 | createT3ChatLinkRequest: () => Effect.die("unused"), |
| 121 | unlinkT3Chat: () => Effect.die("unused"), |
| 122 | connectEnvironment: () => Effect.die("unused"), |
| 123 | registerDevice: () => Effect.die("unused"), |
| 124 | unregisterDevice: () => Effect.die("unused"), |
| 125 | registerLiveActivity: () => Effect.die("unused"), |
| 126 | getAgentActivitySnapshot: () => Effect.die("unused"), |
| 127 | resetTokenCache: Effect.void, |
| 128 | } satisfies ManagedRelay.ManagedRelayClient["Service"]); |
| 129 | const connectivity = Connectivity.Connectivity.of({ |
| 130 | status: SubscriptionRef.get(networkStatus), |
| 131 | changes: SubscriptionRef.changes(networkStatus), |
| 132 | }); |
| 133 | const layer = RelayEnvironmentDiscovery.layer.pipe( |
| 134 | Layer.provide( |
| 135 | Layer.mergeAll( |
| 136 | Layer.succeed(ManagedRelay.ManagedRelayClient, client), |
| 137 | Layer.succeed( |
| 138 | ClientCapabilities.CloudSession, |
| 139 | ClientCapabilities.CloudSession.of({ |
| 140 | identity: Ref.get(clerkToken).pipe( |
| 141 | Effect.map((token) => |
| 142 | token === null ? Option.none() : Option.some(sessionIdentity), |
| 143 | ), |
| 144 | ), |
| 145 | clerkToken: Ref.get(clerkToken).pipe( |
| 146 | Effect.filterOrFail( |
| 147 | (token) => token !== null, |
| 148 | () => |
| 149 | new ConnectionBlockedError({ |
| 150 | reason: "authentication", |
| 151 | detail: "Signed out.", |
| 152 | }), |
| 153 | ), |
| 154 | ), |
| 155 | }), |
| 156 | ), |
| 157 | Layer.succeed(Connectivity.Connectivity, connectivity), |
| 158 | Layer.succeed( |
| 159 | ConnectionWakeups.ConnectionWakeups, |
| 160 | ConnectionWakeups.ConnectionWakeups.of({ |
| 161 | changes: SubscriptionRef.changes(wakeups).pipe( |
| 162 | Stream.drop(1), |
| 163 | Stream.map((event) => event.reason), |
| 164 | ), |
| 165 | }), |
| 166 | ), |
| 167 | ), |
| 168 | ), |
| 169 | ); |
| 170 | |
| 171 | return { |
| 172 | layer, |
| 173 | listCalls, |
| 174 | listedEnvironments, |
| 175 | listFailure, |
| 176 | clerkToken, |
| 177 | networkStatus, |
| 178 | secondListCall, |
| 179 | statusCalls, |
| 180 | statusRequests, |
| 181 | wake: (reason: ConnectionWakeups.ConnectionWakeup) => |
| 182 | SubscriptionRef.update(wakeups, (event) => ({ |
| 183 | sequence: event.sequence + 1, |
| 184 | reason, |
| 185 | })), |
| 186 | }; |
| 187 | }); |
| 188 | |
| 189 | describe("RelayEnvironmentDiscovery", () => { |
| 190 | it.effect("fetches a fresh list after removal while an older refresh is checking statuses", () => |
| 191 | Effect.gen(function* () { |
| 192 | const harness = yield* makeHarness(); |
| 193 | yield* Effect.gen(function* () { |
| 194 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 195 | const atoms = createRelayEnvironmentDiscoveryAtoms( |
| 196 | Atom.runtime( |
| 197 | Layer.succeed(RelayEnvironmentDiscovery.RelayEnvironmentDiscovery, discovery), |
| 198 | ), |
| 199 | ); |
| 200 | const registry = AtomRegistry.make(); |
| 201 | yield* Effect.addFinalizer(() => Effect.sync(() => registry.dispose())); |
| 202 | |
| 203 | const refresh = yield* Effect.forkChild( |
| 204 | Effect.exit(atoms.refresh.run(registry, undefined)), |
| 205 | { startImmediately: true }, |
| 206 | ); |
| 207 | yield* SubscriptionRef.changes(discovery.state).pipe( |
| 208 | Stream.filter((state) => state.environments.size === environments.length), |
| 209 | Stream.runHead, |
| 210 | ); |
| 211 | const coalescedRefresh = yield* Effect.forkChild( |
| 212 | Effect.exit(atoms.refresh.run(registry, undefined)), |
| 213 | { startImmediately: true }, |
| 214 | ); |
| 215 | yield* Ref.set(harness.listedEnvironments, [environments[1]!]); |
| 216 | const mutationRefresh = yield* Effect.forkChild( |
| 217 | Effect.exit(atoms.refreshAfterMutation.run(registry, undefined)), |
| 218 | { startImmediately: true }, |
| 219 | ); |
| 220 | |
| 221 | const requests = yield* Ref.get(harness.statusRequests); |
| 222 | for (const environment of environments) { |
| 223 | yield* Deferred.succeed( |
| 224 | requests.get(environment.environmentId)!, |
| 225 | status(environment, "online"), |
| 226 | ); |
| 227 | } |
| 228 | const results = yield* Fiber.joinAll([refresh, coalescedRefresh, mutationRefresh]); |
| 229 | for (const result of results) { |
| 230 | expect(result._tag).toBe("Success"); |
| 231 | } |
| 232 | expect(yield* Ref.get(harness.listCalls)).toBe(2); |
| 233 | const complete = yield* SubscriptionRef.get(discovery.state); |
| 234 | expect([...complete.environments.keys()]).toEqual([environments[1]!.environmentId]); |
| 235 | expect(complete.refreshing).toBe(false); |
| 236 | }).pipe(Effect.provide(harness.layer)); |
| 237 | }), |
| 238 | ); |
| 239 | |
| 240 | it.effect("publishes each environment status as soon as that lookup completes", () => |
| 241 | Effect.gen(function* () { |
| 242 | const harness = yield* makeHarness(); |
| 243 | yield* Effect.gen(function* () { |
| 244 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 245 | const refreshFiber = yield* Effect.forkChild(discovery.refresh); |
| 246 | |
| 247 | const checking = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 248 | Stream.filter((state) => state.environments.size === 2), |
| 249 | Stream.runHead, |
| 250 | Effect.map(Option.getOrThrow), |
| 251 | ); |
| 252 | expect( |
| 253 | [...checking.environments.values()].every((entry) => entry.availability === "checking"), |
| 254 | ).toBe(true); |
| 255 | |
| 256 | const requests = yield* Ref.get(harness.statusRequests); |
| 257 | yield* Deferred.succeed( |
| 258 | requests.get(environments[1]!.environmentId)!, |
| 259 | status(environments[1]!, "online"), |
| 260 | ); |
| 261 | |
| 262 | const partiallyResolved = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 263 | Stream.filter( |
| 264 | (state) => |
| 265 | state.environments.get(environments[1]!.environmentId)?.availability === "online", |
| 266 | ), |
| 267 | Stream.runHead, |
| 268 | Effect.map(Option.getOrThrow), |
| 269 | ); |
| 270 | expect( |
| 271 | partiallyResolved.environments.get(environments[0]!.environmentId)?.availability, |
| 272 | ).toBe("checking"); |
| 273 | |
| 274 | yield* Deferred.succeed( |
| 275 | requests.get(environments[0]!.environmentId)!, |
| 276 | status(environments[0]!, "offline"), |
| 277 | ); |
| 278 | yield* Fiber.join(refreshFiber); |
| 279 | |
| 280 | const complete = yield* SubscriptionRef.get(discovery.state); |
| 281 | expect(complete.environments.get(environments[0]!.environmentId)?.availability).toBe( |
| 282 | "offline", |
| 283 | ); |
| 284 | expect(complete.refreshing).toBe(false); |
| 285 | }).pipe(Effect.provide(harness.layer)); |
| 286 | }), |
| 287 | ); |
| 288 | |
| 289 | it.effect("reports an environment as unregistered only once the relay list has loaded", () => |
| 290 | Effect.gen(function* () { |
| 291 | const harness = yield* makeHarness(); |
| 292 | yield* Effect.gen(function* () { |
| 293 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 294 | const listed = environments[0]!.environmentId; |
| 295 | const deregistered = "deregistered-environment"; |
| 296 | const before = yield* SubscriptionRef.get(discovery.state); |
| 297 | expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(before, deregistered)).toBe( |
| 298 | "unknown", |
| 299 | ); |
| 300 | |
| 301 | const requests = yield* Ref.get(harness.statusRequests); |
| 302 | for (const environment of environments) { |
| 303 | yield* Deferred.succeed( |
| 304 | requests.get(environment.environmentId)!, |
| 305 | status(environment, "online"), |
| 306 | ); |
| 307 | } |
| 308 | yield* discovery.refresh; |
| 309 | |
| 310 | const after = yield* SubscriptionRef.get(discovery.state); |
| 311 | expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(after, listed)).toBe( |
| 312 | "registered", |
| 313 | ); |
| 314 | expect(RelayEnvironmentDiscovery.relayEnvironmentRegistration(after, deregistered)).toBe( |
| 315 | "unregistered", |
| 316 | ); |
| 317 | }).pipe(Effect.provide(harness.layer)); |
| 318 | }), |
| 319 | ); |
| 320 | |
| 321 | it.effect( |
| 322 | "preserves discovered rows while offline and refreshes after connectivity returns", |
| 323 | () => |
| 324 | Effect.gen(function* () { |
| 325 | const harness = yield* makeHarness(); |
| 326 | yield* Effect.gen(function* () { |
| 327 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 328 | const requests = yield* Ref.get(harness.statusRequests); |
| 329 | for (const environment of environments) { |
| 330 | yield* Deferred.succeed( |
| 331 | requests.get(environment.environmentId)!, |
| 332 | status(environment, "online"), |
| 333 | ); |
| 334 | } |
| 335 | yield* discovery.refresh; |
| 336 | |
| 337 | const offlineFiber = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 338 | Stream.filter((state) => state.offline), |
| 339 | Stream.runHead, |
| 340 | Effect.forkChild, |
| 341 | ); |
| 342 | yield* SubscriptionRef.set(harness.networkStatus, "offline"); |
| 343 | yield* Fiber.join(offlineFiber); |
| 344 | expect((yield* SubscriptionRef.get(discovery.state)).environments.size).toBe(2); |
| 345 | |
| 346 | yield* SubscriptionRef.set(harness.networkStatus, "online"); |
| 347 | yield* Deferred.await(harness.secondListCall); |
| 348 | expect(yield* Ref.get(harness.listCalls)).toBe(2); |
| 349 | }).pipe(Effect.provide(harness.layer)); |
| 350 | }), |
| 351 | ); |
| 352 | |
| 353 | it.effect("publishes listing failures without rejecting the refresh command", () => |
| 354 | Effect.gen(function* () { |
| 355 | const networkStatus = yield* SubscriptionRef.make<NetworkStatus>("online"); |
| 356 | const client = ManagedRelay.ManagedRelayClient.of({ |
| 357 | relayUrl: "https://relay.example.test", |
| 358 | listEnvironments: () => |
| 359 | Effect.fail( |
| 360 | new ManagedRelay.ManagedRelayRequestTimeoutError({ |
| 361 | activity: "Relay environment listing", |
| 362 | timeoutMs: ManagedRelay.MANAGED_RELAY_REQUEST_TIMEOUT_MS, |
| 363 | traceId: null, |
| 364 | }), |
| 365 | ), |
| 366 | getEnvironmentStatus: () => Effect.die("unused"), |
| 367 | listDevices: () => Effect.die("unused"), |
| 368 | createEnvironmentLinkChallenge: () => Effect.die("unused"), |
| 369 | linkEnvironment: () => Effect.die("unused"), |
| 370 | unlinkEnvironment: () => Effect.die("unused"), |
| 371 | getT3ChatLink: () => Effect.die("unused"), |
| 372 | createT3ChatLinkRequest: () => Effect.die("unused"), |
| 373 | unlinkT3Chat: () => Effect.die("unused"), |
| 374 | connectEnvironment: () => Effect.die("unused"), |
| 375 | registerDevice: () => Effect.die("unused"), |
| 376 | unregisterDevice: () => Effect.die("unused"), |
| 377 | registerLiveActivity: () => Effect.die("unused"), |
| 378 | getAgentActivitySnapshot: () => Effect.die("unused"), |
| 379 | resetTokenCache: Effect.void, |
| 380 | } satisfies ManagedRelay.ManagedRelayClient["Service"]); |
| 381 | const layer = RelayEnvironmentDiscovery.layer.pipe( |
| 382 | Layer.provide( |
| 383 | Layer.mergeAll( |
| 384 | Layer.succeed(ManagedRelay.ManagedRelayClient, client), |
| 385 | Layer.succeed(ClientCapabilities.CloudSession, { |
| 386 | identity: Effect.succeedSome({ accountId: "account-1" }), |
| 387 | clerkToken: Effect.succeed("clerk-token"), |
| 388 | }), |
| 389 | Layer.succeed(Connectivity.Connectivity, { |
| 390 | status: SubscriptionRef.get(networkStatus), |
| 391 | changes: SubscriptionRef.changes(networkStatus), |
| 392 | }), |
| 393 | Layer.succeed( |
| 394 | ConnectionWakeups.ConnectionWakeups, |
| 395 | ConnectionWakeups.ConnectionWakeups.of({ changes: Stream.never }), |
| 396 | ), |
| 397 | ), |
| 398 | ), |
| 399 | ); |
| 400 | |
| 401 | yield* Effect.gen(function* () { |
| 402 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 403 | yield* discovery.refresh; |
| 404 | |
| 405 | const state = yield* SubscriptionRef.get(discovery.state); |
| 406 | expect(state.refreshing).toBe(false); |
| 407 | expect(Option.getOrThrow(state.error)).toMatchObject({ |
| 408 | _tag: "ConnectionTransientError", |
| 409 | reason: "timeout", |
| 410 | message: `Relay environment listing timed out. ${NETWORK_BLOCKING_HINT}`, |
| 411 | }); |
| 412 | }).pipe(Effect.provide(layer)); |
| 413 | }), |
| 414 | ); |
| 415 | |
| 416 | it.effect("clears previously discovered rows when a refresh fails", () => |
| 417 | Effect.gen(function* () { |
| 418 | const harness = yield* makeHarness(); |
| 419 | yield* Effect.gen(function* () { |
| 420 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 421 | const requests = yield* Ref.get(harness.statusRequests); |
| 422 | for (const environment of environments) { |
| 423 | yield* Deferred.succeed( |
| 424 | requests.get(environment.environmentId)!, |
| 425 | status(environment, "online"), |
| 426 | ); |
| 427 | } |
| 428 | yield* discovery.refresh; |
| 429 | expect((yield* SubscriptionRef.get(discovery.state)).environments.size).toBe(2); |
| 430 | |
| 431 | yield* Ref.set( |
| 432 | harness.listFailure, |
| 433 | new ManagedRelay.ManagedRelayRequestFailedError({ |
| 434 | action: "list relay-managed environments", |
| 435 | cause: new Error("Relay request failed."), |
| 436 | }), |
| 437 | ); |
| 438 | yield* discovery.refresh; |
| 439 | |
| 440 | const failed = yield* SubscriptionRef.get(discovery.state); |
| 441 | expect(failed.environments.size).toBe(0); |
| 442 | expect(Option.isSome(failed.error)).toBe(true); |
| 443 | expect( |
| 444 | RelayEnvironmentDiscovery.relayEnvironmentRegistration( |
| 445 | failed, |
| 446 | environments[0]!.environmentId, |
| 447 | ), |
| 448 | ).toBe("unknown"); |
| 449 | }).pipe(Effect.provide(harness.layer)); |
| 450 | }), |
| 451 | ); |
| 452 | |
| 453 | it.effect("refreshes proactively when credentials change before any manual refresh", () => |
| 454 | Effect.gen(function* () { |
| 455 | const harness = yield* makeHarness(); |
| 456 | yield* Effect.gen(function* () { |
| 457 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 458 | const requests = yield* Ref.get(harness.statusRequests); |
| 459 | for (const environment of environments) { |
| 460 | yield* Deferred.succeed( |
| 461 | requests.get(environment.environmentId)!, |
| 462 | status(environment, "online"), |
| 463 | ); |
| 464 | } |
| 465 | |
| 466 | // Let the scoped wakeup subscription start before emitting, mirroring |
| 467 | // a real sign-in which always happens long after service start. |
| 468 | yield* Effect.yieldNow; |
| 469 | |
| 470 | yield* harness.wake("credentials-changed"); |
| 471 | const populated = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 472 | Stream.filter( |
| 473 | (state) => state.environments.size === environments.length && !state.refreshing, |
| 474 | ), |
| 475 | Stream.runHead, |
| 476 | Effect.map(Option.getOrThrow), |
| 477 | ); |
| 478 | expect(Option.isNone(populated.error)).toBe(true); |
| 479 | expect(yield* Ref.get(harness.listCalls)).toBe(1); |
| 480 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 481 | }), |
| 482 | ); |
| 483 | |
| 484 | it.effect.each(["application-active", "application-active-long", "application-focused"] as const)( |
| 485 | "lists the account again when the app returns to the foreground (%s)", |
| 486 | (reason) => |
| 487 | Effect.gen(function* () { |
| 488 | const harness = yield* makeHarness(); |
| 489 | yield* Ref.set(harness.listedEnvironments, [environments[0]!]); |
| 490 | yield* Effect.gen(function* () { |
| 491 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 492 | const requests = yield* Ref.get(harness.statusRequests); |
| 493 | for (const environment of environments) { |
| 494 | yield* Deferred.succeed( |
| 495 | requests.get(environment.environmentId)!, |
| 496 | status(environment, "online"), |
| 497 | ); |
| 498 | } |
| 499 | // Let the scoped connectivity and wakeup subscriptions start before signing in. |
| 500 | yield* Effect.yieldNow; |
| 501 | yield* harness.wake("credentials-changed"); |
| 502 | const signedIn = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 503 | Stream.filter((state) => state.listed && !state.refreshing), |
| 504 | Stream.runHead, |
| 505 | Effect.map(Option.getOrThrow), |
| 506 | ); |
| 507 | expect([...signedIn.environments.keys()]).toEqual([environments[0]!.environmentId]); |
| 508 | |
| 509 | yield* Ref.set(harness.listedEnvironments, environments); |
| 510 | yield* harness.wake(reason); |
| 511 | const relisted = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 512 | Stream.filter( |
| 513 | (state) => state.environments.size === environments.length && !state.refreshing, |
| 514 | ), |
| 515 | Stream.runHead, |
| 516 | Effect.map(Option.getOrThrow), |
| 517 | ); |
| 518 | expect([...relisted.environments.keys()]).toEqual( |
| 519 | environments.map((environment) => environment.environmentId), |
| 520 | ); |
| 521 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 522 | }), |
| 523 | ); |
| 524 | |
| 525 | it.effect("lists a registration that lands while an earlier refresh checks statuses", () => |
| 526 | Effect.gen(function* () { |
| 527 | const harness = yield* makeHarness(); |
| 528 | yield* Ref.set(harness.listedEnvironments, [environments[0]!]); |
| 529 | yield* Effect.gen(function* () { |
| 530 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 531 | yield* Effect.yieldNow; |
| 532 | const refreshFiber = yield* Effect.forkChild(discovery.refresh); |
| 533 | yield* SubscriptionRef.changes(discovery.state).pipe( |
| 534 | Stream.filter((state) => state.listed), |
| 535 | Stream.runHead, |
| 536 | ); |
| 537 | |
| 538 | yield* Ref.set(harness.listedEnvironments, environments); |
| 539 | yield* harness.wake("application-active"); |
| 540 | // Let the wakeup reach discovery while the first refresh still holds the lock. |
| 541 | yield* Effect.yieldNow; |
| 542 | const requests = yield* Ref.get(harness.statusRequests); |
| 543 | for (const environment of environments) { |
| 544 | yield* Deferred.succeed( |
| 545 | requests.get(environment.environmentId)!, |
| 546 | status(environment, "online"), |
| 547 | ); |
| 548 | } |
| 549 | yield* Fiber.join(refreshFiber); |
| 550 | |
| 551 | const relisted = yield* SubscriptionRef.changes(discovery.state).pipe( |
| 552 | Stream.filter( |
| 553 | (state) => state.environments.size === environments.length && !state.refreshing, |
| 554 | ), |
| 555 | Stream.runHead, |
| 556 | Effect.map(Option.getOrThrow), |
| 557 | ); |
| 558 | expect([...relisted.environments.keys()]).toEqual( |
| 559 | environments.map((environment) => environment.environmentId), |
| 560 | ); |
| 561 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 562 | }), |
| 563 | ); |
| 564 | |
| 565 | it.effect("coalesces foreground checks that arrive during an in-flight refresh", () => |
| 566 | Effect.gen(function* () { |
| 567 | const harness = yield* makeHarness(); |
| 568 | yield* Effect.gen(function* () { |
| 569 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 570 | yield* Effect.yieldNow; |
| 571 | const refreshFiber = yield* Effect.forkChild(discovery.refresh); |
| 572 | yield* SubscriptionRef.changes(discovery.state).pipe( |
| 573 | Stream.filter((state) => state.listed), |
| 574 | Stream.runHead, |
| 575 | ); |
| 576 | |
| 577 | for (const reason of [ |
| 578 | "application-active", |
| 579 | "application-focused", |
| 580 | "application-active", |
| 581 | "application-focused", |
| 582 | "application-active-long", |
| 583 | ] as const) { |
| 584 | yield* harness.wake(reason); |
| 585 | yield* Effect.yieldNow; |
| 586 | } |
| 587 | // Waits on the lock behind every refresh the wakeups queued. |
| 588 | const lastRefresh = yield* Effect.forkChild(discovery.refresh); |
| 589 | yield* Effect.yieldNow; |
| 590 | const requests = yield* Ref.get(harness.statusRequests); |
| 591 | for (const environment of environments) { |
| 592 | yield* Deferred.succeed( |
| 593 | requests.get(environment.environmentId)!, |
| 594 | status(environment, "online"), |
| 595 | ); |
| 596 | } |
| 597 | yield* Fiber.join(refreshFiber); |
| 598 | yield* Fiber.join(lastRefresh); |
| 599 | |
| 600 | // The first refresh, one queued refresh, one trailing check's listing, and the last refresh. |
| 601 | expect(yield* Ref.get(harness.listCalls)).toBe(4); |
| 602 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 603 | }), |
| 604 | ); |
| 605 | |
| 606 | it.effect("keeps listed rows when the foreground check cannot list the account", () => |
| 607 | Effect.gen(function* () { |
| 608 | const harness = yield* makeHarness(); |
| 609 | yield* Effect.gen(function* () { |
| 610 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 611 | const requests = yield* Ref.get(harness.statusRequests); |
| 612 | for (const environment of environments) { |
| 613 | yield* Deferred.succeed( |
| 614 | requests.get(environment.environmentId)!, |
| 615 | status(environment, "online"), |
| 616 | ); |
| 617 | } |
| 618 | yield* Effect.yieldNow; |
| 619 | yield* discovery.refresh; |
| 620 | const settled = yield* SubscriptionRef.get(discovery.state); |
| 621 | |
| 622 | yield* Ref.set( |
| 623 | harness.listFailure, |
| 624 | new ManagedRelay.ManagedRelayRequestFailedError({ |
| 625 | action: "list relay-managed environments", |
| 626 | cause: new Error("Relay request failed."), |
| 627 | }), |
| 628 | ); |
| 629 | yield* harness.wake("application-active"); |
| 630 | yield* Deferred.await(harness.secondListCall); |
| 631 | |
| 632 | const after = yield* SubscriptionRef.get(discovery.state); |
| 633 | expect(after).toBe(settled); |
| 634 | expect(after.environments.size).toBe(environments.length); |
| 635 | expect(Option.isNone(after.error)).toBe(true); |
| 636 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 637 | }), |
| 638 | ); |
| 639 | |
| 640 | it.effect("leaves an unchanged account list untouched when the app returns", () => |
| 641 | Effect.gen(function* () { |
| 642 | const harness = yield* makeHarness(); |
| 643 | yield* Effect.gen(function* () { |
| 644 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 645 | const requests = yield* Ref.get(harness.statusRequests); |
| 646 | for (const environment of environments) { |
| 647 | yield* Deferred.succeed( |
| 648 | requests.get(environment.environmentId)!, |
| 649 | status(environment, "online"), |
| 650 | ); |
| 651 | } |
| 652 | yield* Effect.yieldNow; |
| 653 | yield* discovery.refresh; |
| 654 | const settled = yield* SubscriptionRef.get(discovery.state); |
| 655 | |
| 656 | yield* harness.wake("application-active"); |
| 657 | yield* Deferred.await(harness.secondListCall); |
| 658 | |
| 659 | expect(yield* SubscriptionRef.get(discovery.state)).toBe(settled); |
| 660 | expect(yield* Ref.get(harness.listCalls)).toBe(2); |
| 661 | expect(yield* Ref.get(harness.statusCalls)).toBe(environments.length); |
| 662 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 663 | }), |
| 664 | ); |
| 665 | |
| 666 | it.effect("settles to a clean empty state when refreshed while signed out", () => |
| 667 | Effect.gen(function* () { |
| 668 | const harness = yield* makeHarness(); |
| 669 | yield* Effect.gen(function* () { |
| 670 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 671 | yield* Ref.set(harness.clerkToken, null); |
| 672 | yield* discovery.refresh; |
| 673 | |
| 674 | const state = yield* SubscriptionRef.get(discovery.state); |
| 675 | expect(state.environments.size).toBe(0); |
| 676 | expect(state.refreshing).toBe(false); |
| 677 | expect(Option.isNone(state.error)).toBe(true); |
| 678 | expect( |
| 679 | RelayEnvironmentDiscovery.relayEnvironmentRegistration( |
| 680 | state, |
| 681 | environments[0]!.environmentId, |
| 682 | ), |
| 683 | ).toBe("unknown"); |
| 684 | }).pipe(Effect.provide(harness.layer)); |
| 685 | }), |
| 686 | ); |
| 687 | |
| 688 | it.effect("does not republish stale rows after sign-out invalidates an in-flight refresh", () => |
| 689 | Effect.gen(function* () { |
| 690 | const harness = yield* makeHarness(); |
| 691 | yield* Effect.gen(function* () { |
| 692 | const discovery = yield* RelayEnvironmentDiscovery.RelayEnvironmentDiscovery; |
| 693 | const refreshFiber = yield* Effect.forkChild(discovery.refresh); |
| 694 | yield* SubscriptionRef.changes(discovery.state).pipe( |
| 695 | Stream.filter((state) => state.environments.size === environments.length), |
| 696 | Stream.runHead, |
| 697 | ); |
| 698 | |
| 699 | yield* Ref.set(harness.clerkToken, null); |
| 700 | yield* harness.wake("credentials-changed"); |
| 701 | yield* SubscriptionRef.changes(discovery.state).pipe( |
| 702 | Stream.filter((state) => state.environments.size === 0), |
| 703 | Stream.runHead, |
| 704 | ); |
| 705 | |
| 706 | const requests = yield* Ref.get(harness.statusRequests); |
| 707 | for (const environment of environments) { |
| 708 | yield* Deferred.succeed( |
| 709 | requests.get(environment.environmentId)!, |
| 710 | status(environment, "online"), |
| 711 | ); |
| 712 | } |
| 713 | yield* Fiber.join(refreshFiber); |
| 714 | yield* Effect.yieldNow; |
| 715 | |
| 716 | const signedOut = yield* SubscriptionRef.get(discovery.state); |
| 717 | expect(signedOut.environments.size).toBe(0); |
| 718 | expect( |
| 719 | RelayEnvironmentDiscovery.relayEnvironmentRegistration( |
| 720 | signedOut, |
| 721 | environments[0]!.environmentId, |
| 722 | ), |
| 723 | ).toBe("unknown"); |
| 724 | }).pipe(Effect.provide(harness.layer), Effect.scoped); |
| 725 | }), |
| 726 | ); |
| 727 | }); |