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, 06:00 UTC
| 1 | import * as Cloudflare from "@alchemy.run/cloudflare"; |
| 2 | import * as RpcWebSocketClient from "@alchemy.run/cloudflare/Workers/RpcWebSocketClient"; |
| 3 | import { describe, expect } from "@alchemy.run/test"; |
| 4 | import * as Test from "@alchemy.run/test/Alchemy"; |
| 5 | import * as Alchemy from "alchemy"; |
| 6 | import type { Done, TimeoutError } from "effect/Cause"; |
| 7 | import * as Context from "effect/Context"; |
| 8 | import * as Data from "effect/Data"; |
| 9 | import * as Deferred from "effect/Deferred"; |
| 10 | import * as Effect from "effect/Effect"; |
| 11 | import * as Exit from "effect/Exit"; |
| 12 | import * as Fiber from "effect/Fiber"; |
| 13 | import * as HttpClientRequest from "effect/http/HttpClientRequest"; |
| 14 | import * as Layer from "effect/Layer"; |
| 15 | import * as ManagedRuntime from "effect/ManagedRuntime"; |
| 16 | import * as Queue from "effect/Queue"; |
| 17 | import { RpcClient, RpcSerialization } from "effect/rpc"; |
| 18 | import type { RpcClientError } from "effect/rpc/RpcClientError"; |
| 19 | import * as Schedule from "effect/Schedule"; |
| 20 | import * as Schema from "effect/Schema"; |
| 21 | import * as Scope from "effect/Scope"; |
| 22 | import * as Socket from "effect/socket/Socket"; |
| 23 | import * as Stream from "effect/Stream"; |
| 24 | import { requestWorker, waitUntilStable } from "../Utils/WorkerRequest.ts"; |
| 25 | import { Greeting, Rejected, SocketRpcs, SocketStats } from "./fixtures/rpc-websocket/rpcs.ts"; |
| 26 | import SocketWorker from "./fixtures/rpc-websocket/worker.ts"; |
| 27 | |
| 28 | class SocketClient extends Context.Service<SocketClient>()("SocketClient", { |
| 29 | make: RpcClient.make(SocketRpcs), |
| 30 | }) {} |
| 31 | |
| 32 | const observeSockets = Effect.sync(() => { |
| 33 | const sockets: { |
| 34 | socket: WebSocket; |
| 35 | closeCodes: (number | undefined)[]; |
| 36 | closed: Deferred.Deferred<{ code: number; reason: string }>; |
| 37 | }[] = []; |
| 38 | const constructor = (url: string) => |
| 39 | Layer.effect( |
| 40 | Socket.WebSocketConstructor, |
| 41 | Effect.gen(function* () { |
| 42 | // Retry only the native handshake, before constructing the RPC client. |
| 43 | const { socket: ready } = yield* rawConnect(url); |
| 44 | let consumed = false; |
| 45 | return (url: string) => { |
| 46 | const socket = consumed ? new WebSocket(url) : ready; |
| 47 | consumed = true; |
| 48 | const closeCodes: (number | undefined)[] = []; |
| 49 | const close = socket.close.bind(socket); |
| 50 | socket.close = (code, reason) => { |
| 51 | closeCodes.push(code); |
| 52 | close(code, reason); |
| 53 | }; |
| 54 | const closed = Deferred.makeUnsafe<{ code: number; reason: string }>(); |
| 55 | socket.addEventListener("close", (event) => |
| 56 | Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })), |
| 57 | ); |
| 58 | sockets.push({ socket, closeCodes, closed }); |
| 59 | return socket; |
| 60 | }; |
| 61 | }), |
| 62 | ); |
| 63 | return { |
| 64 | sockets, |
| 65 | layer: (url: string) => |
| 66 | RpcWebSocketClient.layer(SocketClient, SocketRpcs, url.replace(/^http/, "ws"), { |
| 67 | protocol: { retryTransientErrors: false }, |
| 68 | }).pipe(Layer.provide(constructor(url))), |
| 69 | assertClosed: Effect.gen(function* () { |
| 70 | expect(sockets).toHaveLength(1); |
| 71 | const { socket, closeCodes, closed } = sockets[0]!; |
| 72 | // The RPC Layer must close before rawConnect's fallback finalizer. |
| 73 | expect(closeCodes[0]).toBe(1000); |
| 74 | expect((yield* Deferred.await(closed).pipe(Effect.timeout("10 seconds"))).code).toBe(1000); |
| 75 | expect(socket.readyState).toBe(WebSocket.CLOSED); |
| 76 | expect(sockets).toHaveLength(1); |
| 77 | }), |
| 78 | }; |
| 79 | }); |
| 80 | |
| 81 | const connect = Effect.fn(function* (url: string) { |
| 82 | const { socket: raw } = yield* rawConnect(url); |
| 83 | const protocol = RpcClient.layerProtocolSocket().pipe( |
| 84 | Layer.provide( |
| 85 | Layer.mergeAll( |
| 86 | Layer.effect(Socket.Socket, Socket.fromWebSocket(Effect.succeed(raw))), |
| 87 | RpcSerialization.layerJson, |
| 88 | ), |
| 89 | ), |
| 90 | ); |
| 91 | const context = yield* Layer.build(protocol); |
| 92 | const client = yield* RpcClient.make(SocketRpcs).pipe(Effect.provide(context)); |
| 93 | return { client, raw }; |
| 94 | }); |
| 95 | |
| 96 | class WebSocketHandshakeFailed extends Data.TaggedError("WebSocketHandshakeFailed")<{ |
| 97 | readonly message: string; |
| 98 | }> {} |
| 99 | |
| 100 | type ClientLayerError = RpcClientError | WebSocketHandshakeFailed | TimeoutError; |
| 101 | |
| 102 | const rawConnect = Effect.fn( |
| 103 | function* (url: string) { |
| 104 | const opened = yield* Deferred.make<void, WebSocketHandshakeFailed>(); |
| 105 | const closed = yield* Deferred.make<{ code: number; reason: string }>(); |
| 106 | const messages = yield* Queue.unbounded<string>(); |
| 107 | const socket = yield* Effect.acquireRelease( |
| 108 | Effect.sync(() => { |
| 109 | const socket = new WebSocket(url.replace(/^http/, "ws")); |
| 110 | socket.addEventListener("open", () => Deferred.doneUnsafe(opened, Exit.void)); |
| 111 | socket.addEventListener("error", (event) => |
| 112 | Deferred.doneUnsafe( |
| 113 | opened, |
| 114 | Exit.fail( |
| 115 | new WebSocketHandshakeFailed({ |
| 116 | message: `WebSocket handshake failed: ${"message" in event ? event.message : event.type}`, |
| 117 | }), |
| 118 | ), |
| 119 | ), |
| 120 | ); |
| 121 | socket.addEventListener("message", (event) => |
| 122 | Queue.offerUnsafe(messages, String(event.data)), |
| 123 | ); |
| 124 | socket.addEventListener("close", (event) => |
| 125 | Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })), |
| 126 | ); |
| 127 | return socket; |
| 128 | }), |
| 129 | (socket) => Effect.sync(() => socket.close()), |
| 130 | ); |
| 131 | yield* Deferred.await(opened).pipe( |
| 132 | Effect.timeout("10 seconds"), |
| 133 | Effect.onError(() => Effect.sync(() => socket.close())), |
| 134 | ); |
| 135 | const send = (value: unknown) => Effect.sync(() => socket.send(JSON.stringify(value))); |
| 136 | const receive = Queue.take(messages).pipe( |
| 137 | Effect.flatMap((value) => Effect.try(() => JSON.parse(value))), |
| 138 | Effect.timeout("10 seconds"), |
| 139 | ); |
| 140 | return { |
| 141 | socket, |
| 142 | send, |
| 143 | receive, |
| 144 | buffered: Queue.size(messages), |
| 145 | closed: Deferred.await(closed).pipe(Effect.timeout("10 seconds")), |
| 146 | }; |
| 147 | }, |
| 148 | Effect.retry({ |
| 149 | // Bun hides rejected upgrade responses; retry only before any RPC is sent. |
| 150 | while: (error) => error._tag === "WebSocketHandshakeFailed", |
| 151 | schedule: Schedule.spaced("1 second"), |
| 152 | times: 8, |
| 153 | }), |
| 154 | ); |
| 155 | |
| 156 | /** |
| 157 | * Name Durable Objects per test attempt. The deployed Worker is shared across |
| 158 | * runner retries, so a fixed name would reuse an activation whose in-memory |
| 159 | * `opened`/`closed`/`cleanupStarted` state an earlier attempt already filled. |
| 160 | */ |
| 161 | const freshObjects = Effect.sync(() => { |
| 162 | const suffix = crypto.randomUUID(); |
| 163 | return (name: string) => `${name}-${suffix}`; |
| 164 | }); |
| 165 | |
| 166 | const readStats = Effect.fn(function* (url: string) { |
| 167 | const response = yield* requestWorker(HttpClientRequest.get(url)); |
| 168 | if (response.status !== 200) { |
| 169 | return yield* Effect.fail(new Error(`GET ${url}: ${response.status}: ${yield* response.text}`)); |
| 170 | } |
| 171 | return yield* response.json.pipe(Effect.flatMap(Schema.decodeUnknownEffect(SocketStats))); |
| 172 | }, Effect.timeout("15 seconds")); |
| 173 | |
| 174 | describe.concurrent.each([ |
| 175 | { dev: true, stage: `${Test.defaultStage()}-rpc-websocket-local` }, |
| 176 | { dev: false, stage: `${Test.defaultStage()}-rpc-websocket-live` }, |
| 177 | ])( |
| 178 | "WebSocket RPC (dev: $dev)", |
| 179 | ({ dev, stage }) => { |
| 180 | const state = dev ? Alchemy.inMemoryState() : Cloudflare.state(); |
| 181 | const Stack = Alchemy.Stack( |
| 182 | "RpcWebSocketStack", |
| 183 | { providers: Cloudflare.providers(), state }, |
| 184 | Effect.gen(function* () { |
| 185 | const worker = yield* SocketWorker; |
| 186 | return { url: worker.url.as<string>() }; |
| 187 | }), |
| 188 | ); |
| 189 | const { test, beforeAll, afterAll, deploy, destroy } = Test.make({ |
| 190 | providers: Cloudflare.providers(), |
| 191 | state, |
| 192 | dev, |
| 193 | stage, |
| 194 | }); |
| 195 | const stack = beforeAll( |
| 196 | Effect.gen(function* () { |
| 197 | yield* destroy(Stack); |
| 198 | const output = yield* deploy(Stack); |
| 199 | // A new version reaches Cloudflare's hosts one at a time; hosts still |
| 200 | // on the old version reject the upgrade ("Expected 101"). Require the |
| 201 | // HTTP route and a handshake to succeed several times in a row. |
| 202 | yield* waitUntilStable( |
| 203 | `RPC WebSocket worker at ${output.url}`, |
| 204 | requestWorker(HttpClientRequest.get(`${output.url}/ready`)).pipe( |
| 205 | Effect.flatMap((response) => |
| 206 | response.text.pipe( |
| 207 | Effect.flatMap((body) => |
| 208 | response.status === 200 && body === "ready" |
| 209 | ? Effect.void |
| 210 | : Effect.fail(new Test.WorkerNotReady({ status: response.status })), |
| 211 | ), |
| 212 | ), |
| 213 | ), |
| 214 | Effect.andThen(rawConnect(`${output.url}/rpc/ready`).pipe(Effect.scoped)), |
| 215 | Effect.as(true), |
| 216 | Effect.catchTag(["WorkerNotPropagated", "WebSocketHandshakeFailed"], () => |
| 217 | Effect.succeed(false), |
| 218 | ), |
| 219 | ), |
| 220 | ); |
| 221 | return output; |
| 222 | }), |
| 223 | { timeout: 180_000 }, |
| 224 | ); |
| 225 | afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), { timeout: 30_000 }); |
| 226 | |
| 227 | test( |
| 228 | "readiness handling preserves application HTTP errors", |
| 229 | Effect.gen(function* () { |
| 230 | const { url } = yield* stack; |
| 231 | for (const [path, status] of [ |
| 232 | ["not-found", 404], |
| 233 | ["server-error", 500], |
| 234 | ] as const) { |
| 235 | const response = yield* requestWorker(HttpClientRequest.get(`${url}/${path}`)); |
| 236 | expect(response.status).toBe(status); |
| 237 | expect(yield* response.text).toBe("application error"); |
| 238 | } |
| 239 | }).pipe(Effect.scoped), |
| 240 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 241 | ); |
| 242 | |
| 243 | test( |
| 244 | "typed unary, failure, streaming, and HTTP clients share one object", |
| 245 | Effect.gen(function* () { |
| 246 | const { url } = yield* stack; |
| 247 | const object = yield* freshObjects; |
| 248 | const { client } = yield* connect(`${url}/rpc/${object("roundtrip")}`); |
| 249 | const greeting = yield* client.greet({ name: "Sam" }); |
| 250 | expect(greeting).toBeInstanceOf(Greeting); |
| 251 | expect(greeting.message).toBe("Hello, Sam!"); |
| 252 | expect(yield* client.increment()).toBe(1); |
| 253 | expect(yield* client.reject().pipe(Effect.flip)).toBeInstanceOf(Rejected); |
| 254 | expect(yield* client.numbers({ count: 40 }).pipe(Stream.runCollect)).toEqual( |
| 255 | Array.from({ length: 40 }, (_, i) => i + 1), |
| 256 | ); |
| 257 | const response = yield* requestWorker( |
| 258 | HttpClientRequest.get(`${url}/stats/${object("roundtrip")}`), |
| 259 | ); |
| 260 | expect(response.status).toBe(200); |
| 261 | expect(yield* response.json).toMatchObject({ count: 1 }); |
| 262 | }).pipe(Effect.scoped), |
| 263 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 264 | ); |
| 265 | |
| 266 | test( |
| 267 | "a Layer shares one actual socket for concurrent callers without a caller scope and closes normally", |
| 268 | Effect.gen(function* () { |
| 269 | const { url } = yield* stack; |
| 270 | const object = yield* freshObjects; |
| 271 | const endpoint = `${url}/rpc/${object("layer-client")}`; |
| 272 | const observed = yield* observeSockets; |
| 273 | const program: Effect.Effect<readonly number[], ClientLayerError> = Effect.gen( |
| 274 | function* () { |
| 275 | const results = yield* Effect.all( |
| 276 | Array.from({ length: 40 }, () => |
| 277 | Effect.gen(function* () { |
| 278 | const client = yield* SocketClient; |
| 279 | return yield* client.increment(); |
| 280 | }), |
| 281 | ), |
| 282 | { concurrency: "unbounded" }, |
| 283 | ); |
| 284 | const client = yield* SocketClient; |
| 285 | expect(yield* client.numbers({ count: 3 }).pipe(Stream.runCollect)).toEqual([1, 2, 3]); |
| 286 | expect(observed.sockets).toHaveLength(1); |
| 287 | expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN); |
| 288 | return results; |
| 289 | }, |
| 290 | ).pipe(Effect.provide(observed.layer(endpoint))); |
| 291 | expect((yield* program).toSorted((a, b) => a - b)).toEqual( |
| 292 | Array.from({ length: 40 }, (_, i) => i + 1), |
| 293 | ); |
| 294 | yield* observed.assertClosed; |
| 295 | expect((yield* readStats(`${url}/stats/${object("layer-client")}`)).count).toBe(40); |
| 296 | }), |
| 297 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 298 | ); |
| 299 | |
| 300 | test( |
| 301 | "a Layer closes its actual socket with code 1000 on application failure", |
| 302 | Effect.gen(function* () { |
| 303 | const { url } = yield* stack; |
| 304 | const object = yield* freshObjects; |
| 305 | const endpoint = `${url}/rpc/${object("layer-failure")}`; |
| 306 | const observed = yield* observeSockets; |
| 307 | const program: Effect.Effect<never, Rejected | ClientLayerError> = Effect.gen(function* () { |
| 308 | const client = yield* SocketClient; |
| 309 | yield* client.increment(); |
| 310 | return yield* client.reject(); |
| 311 | }).pipe(Effect.provide(observed.layer(endpoint))); |
| 312 | expect(yield* program.pipe(Effect.flip)).toBeInstanceOf(Rejected); |
| 313 | yield* observed.assertClosed; |
| 314 | expect((yield* readStats(`${url}/stats/${object("layer-failure")}`)).count).toBe(1); |
| 315 | }), |
| 316 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 317 | ); |
| 318 | |
| 319 | test( |
| 320 | "interrupting a Layer closes its actual socket with code 1000 and releases the handler", |
| 321 | Effect.gen(function* () { |
| 322 | const { url } = yield* stack; |
| 323 | const object = yield* freshObjects; |
| 324 | const endpoint = `${url}/rpc/${object("layer-interruption")}`; |
| 325 | const observed = yield* observeSockets; |
| 326 | const started = yield* Deferred.make<void>(); |
| 327 | const program: Effect.Effect<void, ClientLayerError> = Effect.gen(function* () { |
| 328 | const client = yield* SocketClient; |
| 329 | yield* client |
| 330 | .watch({ key: "layer-interruption" }) |
| 331 | .pipe(Stream.runForEach(() => Deferred.succeed(started, undefined))); |
| 332 | }).pipe(Effect.provide(observed.layer(endpoint))); |
| 333 | const fiber = yield* program.pipe(Effect.forkScoped); |
| 334 | yield* Deferred.await(started).pipe(Effect.timeout("10 seconds")); |
| 335 | expect(observed.sockets).toHaveLength(1); |
| 336 | yield* Fiber.interrupt(fiber); |
| 337 | expect(Exit.hasInterrupts(yield* Fiber.await(fiber))).toBe(true); |
| 338 | yield* observed.assertClosed; |
| 339 | const status = yield* readStats(`${url}/stats/${object("layer-interruption")}`).pipe( |
| 340 | Effect.repeat({ |
| 341 | schedule: Schedule.spaced("250 millis"), |
| 342 | times: 40, |
| 343 | until: (state) => state.closed.includes("layer-interruption"), |
| 344 | }), |
| 345 | ); |
| 346 | expect(status.closed).toEqual(["layer-interruption"]); |
| 347 | expect(status.invocations).toEqual({ "layer-interruption": 1 }); |
| 348 | }).pipe(Effect.scoped), |
| 349 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 350 | ); |
| 351 | |
| 352 | test( |
| 353 | "ManagedRuntime.dispose closes the shared actual socket with code 1000", |
| 354 | Effect.gen(function* () { |
| 355 | const { url } = yield* stack; |
| 356 | const object = yield* freshObjects; |
| 357 | const endpoint = `${url}/rpc/${object("layer-managed")}`; |
| 358 | const observed = yield* observeSockets; |
| 359 | const runtime = yield* Effect.acquireRelease( |
| 360 | Effect.sync(() => ManagedRuntime.make(observed.layer(endpoint))), |
| 361 | (runtime) => Effect.promise(() => runtime.dispose()), |
| 362 | ); |
| 363 | const call: Effect.Effect<number, RpcClientError, SocketClient> = Effect.gen(function* () { |
| 364 | const client = yield* SocketClient; |
| 365 | return yield* client.increment(); |
| 366 | }); |
| 367 | const results = yield* Effect.all( |
| 368 | Array.from({ length: 8 }, () => |
| 369 | Effect.sync(() => runtime.runFork(call)).pipe(Effect.flatMap(Fiber.join)), |
| 370 | ), |
| 371 | { concurrency: "unbounded" }, |
| 372 | ); |
| 373 | expect(results.toSorted((a, b) => a - b)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]); |
| 374 | expect(observed.sockets).toHaveLength(1); |
| 375 | expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN); |
| 376 | yield* Effect.promise(() => runtime.dispose()); |
| 377 | yield* observed.assertClosed; |
| 378 | expect((yield* readStats(`${url}/stats/${object("layer-managed")}`)).count).toBe(8); |
| 379 | }).pipe(Effect.scoped), |
| 380 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 381 | ); |
| 382 | |
| 383 | test( |
| 384 | "a queue subscription owns a separate scope without closing the Layer socket", |
| 385 | Effect.gen(function* () { |
| 386 | const { url } = yield* stack; |
| 387 | const object = yield* freshObjects; |
| 388 | const endpoint = `${url}/rpc/${object("layer-queue")}`; |
| 389 | const observed = yield* observeSockets; |
| 390 | const program: Effect.Effect<void, ClientLayerError | Done> = Effect.gen(function* () { |
| 391 | const client = yield* SocketClient; |
| 392 | yield* Effect.gen(function* () { |
| 393 | const queue = yield* client.watch({ key: "queue" }, { asQueue: true }); |
| 394 | expect(yield* Queue.take(queue)).toBe(1); |
| 395 | }).pipe(Effect.scoped); |
| 396 | expect(observed.sockets).toHaveLength(1); |
| 397 | expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN); |
| 398 | expect((yield* client.greet({ name: "still open" })).message).toBe("Hello, still open!"); |
| 399 | }).pipe(Effect.provide(observed.layer(endpoint))); |
| 400 | yield* program; |
| 401 | yield* observed.assertClosed; |
| 402 | const status = yield* readStats(`${url}/stats/${object("layer-queue")}`).pipe( |
| 403 | Effect.repeat({ |
| 404 | schedule: Schedule.spaced("250 millis"), |
| 405 | times: 40, |
| 406 | until: (state) => state.closed.includes("queue"), |
| 407 | }), |
| 408 | ); |
| 409 | expect(status.closed).toEqual(["queue"]); |
| 410 | expect(status.invocations).toEqual({ queue: 1 }); |
| 411 | }), |
| 412 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 413 | ); |
| 414 | |
| 415 | test( |
| 416 | "multiplexes concurrent calls without crossing instance state", |
| 417 | Effect.gen(function* () { |
| 418 | const { url } = yield* stack; |
| 419 | const object = yield* freshObjects; |
| 420 | const { client } = yield* connect(`${url}/rpc/${object("concurrent")}`); |
| 421 | const results = yield* Effect.all( |
| 422 | Array.from({ length: 40 }, () => client.increment()), |
| 423 | { concurrency: "unbounded" }, |
| 424 | ); |
| 425 | expect(results.sort((a, b) => a - b)).toEqual(Array.from({ length: 40 }, (_, i) => i + 1)); |
| 426 | const other = yield* connect(`${url}/rpc/${object("isolated")}`); |
| 427 | expect((yield* other.client.stats()).count).toBe(0); |
| 428 | }).pipe(Effect.scoped), |
| 429 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 430 | ); |
| 431 | |
| 432 | test( |
| 433 | "stream interruption closes its scope and keeps the socket usable", |
| 434 | Effect.gen(function* () { |
| 435 | const { url } = yield* stack; |
| 436 | const object = yield* freshObjects; |
| 437 | const { client, raw } = yield* connect(`${url}/rpc/${object("interruption")}`); |
| 438 | const scope = yield* Scope.make(); |
| 439 | const values = yield* client |
| 440 | .watch({ key: "cancel" }, { asQueue: true }) |
| 441 | .pipe(Effect.provideService(Scope.Scope, scope)); |
| 442 | expect(yield* Queue.take(values).pipe(Effect.timeout("10 seconds"))).toBe(1); |
| 443 | yield* Scope.close(scope, Exit.void); |
| 444 | const status = yield* client.stats().pipe( |
| 445 | Effect.repeat({ |
| 446 | schedule: Schedule.spaced("250 millis"), |
| 447 | times: 40, |
| 448 | until: (state) => state.closed.includes("cancel"), |
| 449 | }), |
| 450 | ); |
| 451 | expect(status.closed).toContain("cancel"); |
| 452 | expect(raw.readyState).toBe(WebSocket.OPEN); |
| 453 | expect((yield* client.greet({ name: "again" })).message).toBe("Hello, again!"); |
| 454 | }).pipe(Effect.scoped), |
| 455 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 456 | ); |
| 457 | |
| 458 | test( |
| 459 | "socket disconnect interrupts active handler resources", |
| 460 | Effect.gen(function* () { |
| 461 | const { url } = yield* stack; |
| 462 | const object = yield* freshObjects; |
| 463 | const connection = yield* rawConnect(`${url}/rpc/${object("disconnect")}`); |
| 464 | yield* connection.send({ |
| 465 | _tag: "Request", |
| 466 | id: "1", |
| 467 | tag: "watch", |
| 468 | payload: { key: "disconnect" }, |
| 469 | headers: [], |
| 470 | }); |
| 471 | expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] }); |
| 472 | yield* Effect.sync(() => connection.socket.close()); |
| 473 | yield* connection.closed; |
| 474 | const status = yield* requestWorker( |
| 475 | HttpClientRequest.get(`${url}/stats/${object("disconnect")}`), |
| 476 | ).pipe( |
| 477 | Effect.flatMap((response) => response.json), |
| 478 | Effect.map((state) => state as { closed: string[] }), |
| 479 | Effect.repeat({ |
| 480 | schedule: Schedule.spaced("250 millis"), |
| 481 | times: 40, |
| 482 | until: (state) => state.closed.includes("disconnect"), |
| 483 | }), |
| 484 | ); |
| 485 | expect(status).toMatchObject({ opened: ["disconnect"], closed: ["disconnect"] }); |
| 486 | }).pipe(Effect.scoped), |
| 487 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 488 | ); |
| 489 | |
| 490 | for (const mode of ["unary", "disconnect"] as const) { |
| 491 | test( |
| 492 | mode === "unary" |
| 493 | ? "unary result does not release the activation before deferred cleanup finishes" |
| 494 | : "disconnect before any output retains the activation until deferred cleanup finishes", |
| 495 | Effect.gen(function* () { |
| 496 | const { url } = yield* stack; |
| 497 | const object = yield* freshObjects; |
| 498 | const name = object(`cleanup-${mode}`); |
| 499 | const connection = yield* rawConnect(`${url}/rpc/${name}`); |
| 500 | const before = yield* readStats(`${url}/stats/${name}`); |
| 501 | yield* Effect.gen(function* () { |
| 502 | yield* connection.send({ |
| 503 | _tag: "Request", |
| 504 | id: "1", |
| 505 | tag: "cleanup", |
| 506 | payload: { key: mode, waitForDisconnect: mode === "disconnect" }, |
| 507 | headers: [], |
| 508 | }); |
| 509 | if (mode === "unary") { |
| 510 | expect(yield* connection.receive).toMatchObject({ |
| 511 | _tag: "Exit", |
| 512 | requestId: "1", |
| 513 | exit: { _tag: "Success", value: before.boots }, |
| 514 | }); |
| 515 | } else { |
| 516 | const entered = yield* readStats(`${url}/stats/${name}`).pipe( |
| 517 | Effect.repeat({ |
| 518 | schedule: Schedule.spaced("250 millis"), |
| 519 | times: 40, |
| 520 | until: (state) => state.opened.includes(mode), |
| 521 | }), |
| 522 | ); |
| 523 | expect(entered.boots).toBe(before.boots); |
| 524 | expect(entered.opened).toContain(mode); |
| 525 | expect(entered.cleanupStarted).toEqual([]); |
| 526 | expect(yield* connection.buffered).toBe(0); |
| 527 | yield* Effect.sync(() => connection.socket.close()); |
| 528 | yield* connection.closed; |
| 529 | expect(yield* connection.buffered).toBe(0); |
| 530 | } |
| 531 | const started = yield* readStats(`${url}/stats/${name}`).pipe( |
| 532 | Effect.repeat({ |
| 533 | schedule: Schedule.spaced("250 millis"), |
| 534 | times: 40, |
| 535 | until: (state) => state.cleanupStarted.includes(mode), |
| 536 | }), |
| 537 | ); |
| 538 | expect(started.boots).toBe(before.boots); |
| 539 | expect(started.cleanupStarted).toEqual([mode]); |
| 540 | expect(started.cleanupCompleted).toEqual({}); |
| 541 | |
| 542 | // Raw sockets send no heartbeats; only the test process has a timer. |
| 543 | yield* Effect.sleep("20 seconds"); |
| 544 | const held = yield* readStats(`${url}/stats/${name}`); |
| 545 | expect(held.boots).toBe(before.boots); |
| 546 | expect(held.cleanupStarted).toEqual([mode]); |
| 547 | expect(held.cleanupCompleted).toEqual({}); |
| 548 | |
| 549 | if (mode === "unary") { |
| 550 | expect(connection.socket.readyState).toBe(WebSocket.OPEN); |
| 551 | const control = yield* rawConnect(`${url}/rpc/${name}`); |
| 552 | yield* control.send({ |
| 553 | _tag: "Request", |
| 554 | id: "1", |
| 555 | tag: "releaseCleanup", |
| 556 | payload: { key: mode }, |
| 557 | headers: [], |
| 558 | }); |
| 559 | expect(yield* control.receive).toMatchObject({ |
| 560 | _tag: "Exit", |
| 561 | requestId: "1", |
| 562 | exit: { _tag: "Success", value: true }, |
| 563 | }); |
| 564 | } else { |
| 565 | const response = yield* requestWorker( |
| 566 | HttpClientRequest.post(`${url}/release/${name}/${mode}`), |
| 567 | ); |
| 568 | expect(response.status).toBe(200); |
| 569 | expect(yield* response.json).toEqual({ released: true }); |
| 570 | } |
| 571 | const completed = yield* readStats(`${url}/stats/${name}`).pipe( |
| 572 | Effect.repeat({ |
| 573 | schedule: Schedule.spaced("250 millis"), |
| 574 | times: 40, |
| 575 | until: (state) => state.cleanupCompleted[mode] !== undefined, |
| 576 | }), |
| 577 | ); |
| 578 | expect(completed.boots).toBe(before.boots); |
| 579 | expect(completed.cleanupCompleted).toEqual({ [mode]: before.boots }); |
| 580 | }).pipe( |
| 581 | Effect.ensuring( |
| 582 | requestWorker(HttpClientRequest.post(`${url}/release/${name}/${mode}`)).pipe( |
| 583 | Effect.timeout("15 seconds"), |
| 584 | Effect.ignoreCause, |
| 585 | ), |
| 586 | ), |
| 587 | ); |
| 588 | }).pipe(Effect.scoped), |
| 589 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 90_000 }, |
| 590 | ); |
| 591 | } |
| 592 | |
| 593 | test( |
| 594 | "the same Layer-owned socket survives real hibernation and serves a new RPC", |
| 595 | Effect.gen(function* () { |
| 596 | const { url } = yield* stack; |
| 597 | const object = yield* freshObjects; |
| 598 | const endpoint = `${url}/rpc/${object("idle")}`; |
| 599 | const observed = yield* observeSockets; |
| 600 | yield* Effect.gen(function* () { |
| 601 | const client = yield* SocketClient; |
| 602 | const before = yield* client.stats(); |
| 603 | expect(observed.sockets).toHaveLength(1); |
| 604 | const socket = observed.sockets[0]!.socket; |
| 605 | const after = yield* Effect.gen(function* () { |
| 606 | yield* Effect.sleep("15 seconds"); |
| 607 | return yield* client.stats().pipe(Effect.timeout("5 seconds")); |
| 608 | }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots })); |
| 609 | expect(after.boots).toBeGreaterThan(before.boots); |
| 610 | expect(socket.readyState).toBe(WebSocket.OPEN); |
| 611 | expect((yield* client.greet({ name: "awake" })).message).toBe("Hello, awake!"); |
| 612 | expect((yield* client.stats()).boots).toBe(after.boots); |
| 613 | expect(observed.sockets).toHaveLength(1); |
| 614 | expect(observed.sockets[0]!.socket).toBe(socket); |
| 615 | }).pipe(Effect.provide(observed.layer(endpoint))); |
| 616 | yield* observed.assertClosed; |
| 617 | }), |
| 618 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 }, |
| 619 | ); |
| 620 | |
| 621 | test( |
| 622 | "hibernation resets an actual socket with an incompatible serializer attachment", |
| 623 | Effect.gen(function* () { |
| 624 | const { url } = yield* stack; |
| 625 | const object = yield* freshObjects; |
| 626 | const connection = yield* rawConnect(`${url}/rpc/${object("serialization-reset")}`); |
| 627 | const before = yield* readStats(`${url}/stats/${object("serialization-reset")}`); |
| 628 | const response = yield* requestWorker( |
| 629 | HttpClientRequest.post(`${url}/serialization/${object("serialization-reset")}`), |
| 630 | ); |
| 631 | expect(response.status).toBe(200); |
| 632 | expect(yield* response.json).toEqual({ changed: 1 }); |
| 633 | expect(connection.socket.readyState).toBe(WebSocket.OPEN); |
| 634 | const after = yield* Effect.gen(function* () { |
| 635 | yield* Effect.sleep("15 seconds"); |
| 636 | return yield* readStats(`${url}/stats/${object("serialization-reset")}`); |
| 637 | }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots })); |
| 638 | expect(after.boots).toBeGreaterThan(before.boots); |
| 639 | expect(yield* connection.closed).toEqual({ |
| 640 | code: 1012, |
| 641 | reason: "Durable Object RPC activation reset", |
| 642 | }); |
| 643 | expect(connection.socket.readyState).toBe(WebSocket.CLOSED); |
| 644 | expect(yield* connection.buffered).toBe(0); |
| 645 | const replacement = yield* connect(`${url}/rpc/${object("serialization-reset")}`); |
| 646 | expect((yield* replacement.client.greet({ name: "compatible" })).message).toBe( |
| 647 | "Hello, compatible!", |
| 648 | ); |
| 649 | expect((yield* replacement.client.stats()).boots).toBe(after.boots); |
| 650 | }).pipe(Effect.scoped), |
| 651 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 }, |
| 652 | ); |
| 653 | |
| 654 | test( |
| 655 | "native abort fails an active stream without replaying its request", |
| 656 | Effect.gen(function* () { |
| 657 | const { url } = yield* stack; |
| 658 | const object = yield* freshObjects; |
| 659 | const connection = yield* rawConnect(`${url}/rpc/${object("lost-stream")}`); |
| 660 | yield* connection.send({ |
| 661 | _tag: "Request", |
| 662 | id: "1", |
| 663 | tag: "watch", |
| 664 | payload: { key: "lost" }, |
| 665 | headers: [], |
| 666 | }); |
| 667 | expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] }); |
| 668 | yield* connection.send({ _tag: "Ack", requestId: "1" }); |
| 669 | const before = yield* readStats(`${url}/stats/${object("lost-stream")}`); |
| 670 | expect(before.invocations).toEqual({ lost: 1 }); |
| 671 | expect(before.opened).toEqual(["lost"]); |
| 672 | const response = yield* requestWorker( |
| 673 | HttpClientRequest.post(`${url}/abort/${object("lost-stream")}`), |
| 674 | ).pipe(Effect.timeout("15 seconds")); |
| 675 | expect(response.status).toBe(200); |
| 676 | expect(yield* response.json).toEqual({ aborted: true }); |
| 677 | yield* connection.closed; |
| 678 | expect(connection.socket.readyState).toBe(WebSocket.CLOSED); |
| 679 | expect(yield* connection.buffered).toBe(0); |
| 680 | |
| 681 | const replacement = yield* connect(`${url}/rpc/${object("lost-stream")}`); |
| 682 | const status = yield* replacement.client.stats(); |
| 683 | expect(status.boots).toBeGreaterThan(before.boots); |
| 684 | expect(status.invocations).toEqual({ lost: 1 }); |
| 685 | expect(status.opened).toEqual([]); |
| 686 | expect((yield* replacement.client.greet({ name: "reconnected" })).message).toBe( |
| 687 | "Hello, reconnected!", |
| 688 | ); |
| 689 | expect((yield* replacement.client.stats()).invocations).toEqual({ lost: 1 }); |
| 690 | }).pipe(Effect.scoped), |
| 691 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 45_000 }, |
| 692 | ); |
| 693 | |
| 694 | test( |
| 695 | "schema and unknown-method failures leave the connection usable", |
| 696 | Effect.gen(function* () { |
| 697 | const { url } = yield* stack; |
| 698 | const object = yield* freshObjects; |
| 699 | const connection = yield* rawConnect(`${url}/rpc/${object("invalid-requests")}`); |
| 700 | for (const [id, tag, payload] of [ |
| 701 | ["1", "greet", { name: 42 }], |
| 702 | ["2", "missing", {}], |
| 703 | ] as const) { |
| 704 | yield* connection.send({ _tag: "Request", id, tag, payload, headers: [] }); |
| 705 | expect(yield* connection.receive).toMatchObject({ |
| 706 | _tag: "Exit", |
| 707 | requestId: id, |
| 708 | exit: { _tag: "Failure" }, |
| 709 | }); |
| 710 | } |
| 711 | yield* connection.send({ |
| 712 | _tag: "Request", |
| 713 | id: "3", |
| 714 | tag: "greet", |
| 715 | payload: { name: "valid" }, |
| 716 | headers: [], |
| 717 | }); |
| 718 | expect(yield* connection.receive).toMatchObject({ |
| 719 | _tag: "Exit", |
| 720 | requestId: "3", |
| 721 | exit: { _tag: "Success", value: { message: "Hello, valid!" } }, |
| 722 | }); |
| 723 | }).pipe(Effect.scoped), |
| 724 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 725 | ); |
| 726 | |
| 727 | test( |
| 728 | "malformed frames close the offending connection", |
| 729 | Effect.gen(function* () { |
| 730 | const { url } = yield* stack; |
| 731 | const object = yield* freshObjects; |
| 732 | const connection = yield* rawConnect(`${url}/rpc/${object("malformed")}`); |
| 733 | yield* Effect.sync(() => connection.socket.send("not json")); |
| 734 | expect((yield* connection.closed).code).toBeGreaterThanOrEqual(1002); |
| 735 | const healthy = yield* connect(`${url}/rpc/${object("malformed")}`); |
| 736 | expect((yield* healthy.client.greet({ name: "healthy" })).message).toBe("Hello, healthy!"); |
| 737 | }).pipe(Effect.scoped), |
| 738 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 }, |
| 739 | ); |
| 740 | }, |
| 741 | { tags: ["provider:cloudflare", "provider:cloudflare:worker"] }, |
| 742 | ); |