The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as DenoRedis from "@effect/platform-deno/DenoRedis" |
| 2 | import { assert, it } from "@effect/vitest" |
| 3 | import { RedisContainer } from "@testcontainers/redis" |
| 4 | import { Deferred, Effect, Exit, Fiber, Layer, Queue, Schema } from "effect" |
| 5 | import { CircuitBreaker, PersistedQueue, Persistence, Redis } from "effect/persistence" |
| 6 | import { TestClock } from "effect/testing" |
| 7 | import * as CircuitBreakerRedisTest from "../../../effect/test/persistence/CircuitBreakerRedisTest.ts" |
| 8 | import * as CircuitBreakerTest from "../../../effect/test/persistence/CircuitBreakerTest.ts" |
| 9 | import * as PersistedCacheTest from "../../../effect/test/persistence/PersistedCacheTest.ts" |
| 10 | import * as PersistedQueueTest from "../../../effect/test/persistence/PersistedQueueTest.ts" |
| 11 | |
| 12 | const RedisLayer = Layer.unwrap( |
| 13 | Effect.gen(function*() { |
| 14 | const container = yield* Effect.acquireRelease( |
| 15 | Effect.promise(() => new RedisContainer("redis:alpine").start()), |
| 16 | (container) => Effect.promise(() => container.stop()) |
| 17 | ) |
| 18 | return DenoRedis.layer({ |
| 19 | url: `redis://${container.getHost()}:${container.getMappedPort(6379)}` |
| 20 | }) |
| 21 | }).pipe( |
| 22 | Effect.catchCause(() => Effect.fail(new PersistedCacheTest.TransientError())) |
| 23 | ) |
| 24 | ) |
| 25 | |
| 26 | PersistedCacheTest.suite( |
| 27 | "DenoRedis", |
| 28 | Persistence.layerRedis.pipe(Layer.provide(RedisLayer)) |
| 29 | ) |
| 30 | |
| 31 | PersistedQueueTest.suite( |
| 32 | "DenoRedis", |
| 33 | // short intervals so the periodic reset runs while the suite's takes are |
| 34 | // in flight |
| 35 | PersistedQueue.layerStoreRedis({ |
| 36 | pollInterval: "50 millis", |
| 37 | lockRefreshInterval: "100 millis" |
| 38 | }).pipe(Layer.provide(RedisLayer)) |
| 39 | ) |
| 40 | |
| 41 | CircuitBreakerTest.suite( |
| 42 | "DenoRedis", |
| 43 | (options) => CircuitBreaker.layerStoreRedis(options).pipe(Layer.provide(RedisLayer)), |
| 44 | // the store reads Redis TIME, so time only moves on the wall clock |
| 45 | (duration) => TestClock.withLive(Effect.sleep(duration)) |
| 46 | ) |
| 47 | |
| 48 | CircuitBreakerRedisTest.suite("DenoRedis", RedisLayer) |
| 49 | |
| 50 | const PersistedQueueRedisLayer = Layer.mergeAll( |
| 51 | RedisLayer, |
| 52 | PersistedQueue.layer.pipe( |
| 53 | Layer.provideMerge( |
| 54 | PersistedQueue.layerStoreRedis().pipe(Layer.provide(RedisLayer)) |
| 55 | ) |
| 56 | ) |
| 57 | ) |
| 58 | |
| 59 | it.layer(PersistedQueueRedisLayer, { timeout: "30 seconds" })( |
| 60 | "PersistedQueue (DenoRedis)", |
| 61 | (it) => { |
| 62 | it.effect("receives published messages", () => |
| 63 | Effect.gen(function*() { |
| 64 | const redis = yield* Redis.Redis |
| 65 | const subscription = yield* redis.subscribe("effect-test") |
| 66 | |
| 67 | const subscribers = yield* redis.send<number>("PUBLISH", "effect-test", "hello") |
| 68 | assert.strictEqual(subscribers, 1) |
| 69 | |
| 70 | assert.deepStrictEqual(yield* Queue.take(subscription), { |
| 71 | channel: "effect-test", |
| 72 | message: "hello" |
| 73 | }) |
| 74 | })) |
| 75 | |
| 76 | it.effect("runs blocking reads on a reserved connection without delaying shared commands", () => |
| 77 | Effect.gen(function*() { |
| 78 | const redis = yield* Redis.Redis |
| 79 | const read = yield* redis.reserve.pipe( |
| 80 | Effect.flatMap((connection) => |
| 81 | connection.send("XREAD", "BLOCK", "5000", "STREAMS", "effect-test-reserve", "$") |
| 82 | ), |
| 83 | Effect.scoped, |
| 84 | Effect.forkChild |
| 85 | ) |
| 86 | // XREAD with "$" only sees entries added after it starts blocking |
| 87 | yield* redis.send<string>("CLIENT", "LIST").pipe( |
| 88 | Effect.repeat({ until: (clients) => clients.includes("cmd=xread") }) |
| 89 | ) |
| 90 | yield* redis.send("XADD", "effect-test-reserve", "*", "key", "value") |
| 91 | |
| 92 | assert.include(JSON.stringify(yield* Fiber.join(read)), "value") |
| 93 | })) |
| 94 | |
| 95 | it.effect("fails a reserved command when its connection drops instead of replaying it", () => |
| 96 | Effect.gen(function*() { |
| 97 | const redis = yield* Redis.Redis |
| 98 | const list = "effect-test-reserve-drop" |
| 99 | const exit = yield* Effect.scoped(Effect.gen(function*() { |
| 100 | const connection = yield* redis.reserve |
| 101 | const id = yield* connection.send<number>("CLIENT", "ID") |
| 102 | const pop = yield* connection.send("BLPOP", list, "0").pipe(Effect.forkChild) |
| 103 | yield* redis.send<string>("CLIENT", "LIST").pipe( |
| 104 | Effect.repeat({ |
| 105 | until: (clients) => |
| 106 | clients.split("\n").some((client) => client.startsWith(`id=${id} `) && client.includes("cmd=blpop")) |
| 107 | }) |
| 108 | ) |
| 109 | yield* redis.send("CLIENT", "KILL", "ID", String(id)) |
| 110 | yield* redis.send("LPUSH", list, "item") |
| 111 | return yield* Fiber.await(pop) |
| 112 | })) |
| 113 | |
| 114 | assert.isTrue(Exit.isFailure(exit)) |
| 115 | assert.strictEqual(yield* redis.send<number>("LLEN", list), 1) |
| 116 | })) |
| 117 | |
| 118 | it.effect("moves exhausted elements to the failed list", () => |
| 119 | Effect.gen(function*() { |
| 120 | const redis = yield* DenoRedis.DenoRedis |
| 121 | const queueName = "test-redis-failed" |
| 122 | |
| 123 | const queue = yield* PersistedQueue.make({ |
| 124 | name: queueName, |
| 125 | schema: RedisItem, |
| 126 | maxAttempts: 1 |
| 127 | }) |
| 128 | const id = yield* queue.offer({ n: 42 }) |
| 129 | const error = yield* queue.take(() => Effect.fail("boom")).pipe(Effect.flip) |
| 130 | assert.strictEqual(error, "boom") |
| 131 | |
| 132 | const failed = yield* redis.use((client) => client.lrange(`effectq:${queueName}:failed`, 0, -1)) |
| 133 | assert.strictEqual(failed.length, 1) |
| 134 | const failedItem = JSON.parse(failed[0]) |
| 135 | assert.strictEqual(failedItem.id, id) |
| 136 | assert.deepStrictEqual(failedItem.element, { n: 42 }) |
| 137 | assert.strictEqual(failedItem.attempts, 1) |
| 138 | |
| 139 | const pending = yield* redis.use((client) => client.hlen(`effectq:${queueName}:pending`)) |
| 140 | assert.strictEqual(pending, 0) |
| 141 | })) |
| 142 | } |
| 143 | ) |
| 144 | |
| 145 | it.effect("closes the connection when interrupted during acquisition", () => |
| 146 | Effect.gen(function*() { |
| 147 | const listener = yield* makeListener |
| 148 | const authReceived = yield* Deferred.make<void>() |
| 149 | const sendAuthReply = yield* Deferred.make<void>() |
| 150 | const server = yield* Effect.gen(function*() { |
| 151 | const connection = yield* accept(listener) |
| 152 | yield* read(connection) |
| 153 | yield* Deferred.succeed(authReceived, void 0) |
| 154 | yield* Deferred.await(sendAuthReply) |
| 155 | yield* write(connection, "+OK\r\n") |
| 156 | return yield* read(connection) |
| 157 | }).pipe(Effect.forkChild) |
| 158 | |
| 159 | const port = (listener.addr as Deno.NetAddr).port |
| 160 | const layerFiber = yield* Layer.build(DenoRedis.layer({ |
| 161 | url: `redis://:secret@127.0.0.1:${port}` |
| 162 | })).pipe(Effect.forkChild({ startImmediately: true })) |
| 163 | |
| 164 | yield* Deferred.await(authReceived) |
| 165 | const interruptFiber = yield* Fiber.interrupt(layerFiber).pipe( |
| 166 | Effect.forkChild({ startImmediately: true }) |
| 167 | ) |
| 168 | yield* Deferred.succeed(sendAuthReply, void 0) |
| 169 | yield* Fiber.join(interruptFiber) |
| 170 | |
| 171 | assert.isNull(yield* Fiber.join(server)) |
| 172 | })) |
| 173 | |
| 174 | it.effect("uses the URL username for two-argument AUTH", () => |
| 175 | Effect.gen(function*() { |
| 176 | const listener = yield* makeListener |
| 177 | const server = yield* Effect.gen(function*() { |
| 178 | const connection = yield* accept(listener) |
| 179 | const request = yield* read(connection) |
| 180 | yield* write(connection, "+OK\r\n") |
| 181 | return request |
| 182 | }).pipe(Effect.forkChild) |
| 183 | |
| 184 | const port = (listener.addr as Deno.NetAddr).port |
| 185 | yield* Layer.build(DenoRedis.layer({ |
| 186 | url: `redis://alice:secret@127.0.0.1:${port}`, |
| 187 | password: undefined |
| 188 | })) |
| 189 | |
| 190 | assert.strictEqual( |
| 191 | yield* Fiber.join(server), |
| 192 | "*3\r\n$4\r\nAUTH\r\n$5\r\nalice\r\n$6\r\nsecret\r\n" |
| 193 | ) |
| 194 | })) |
| 195 | |
| 196 | it.effect("decodes URL authority credentials once", () => |
| 197 | Effect.gen(function*() { |
| 198 | const listener = yield* makeListener |
| 199 | const server = yield* Effect.gen(function*() { |
| 200 | const connection = yield* accept(listener) |
| 201 | const request = yield* read(connection) |
| 202 | yield* write(connection, "+OK\r\n") |
| 203 | return request |
| 204 | }).pipe(Effect.forkChild) |
| 205 | |
| 206 | const port = (listener.addr as Deno.NetAddr).port |
| 207 | yield* Layer.build(DenoRedis.layer({ |
| 208 | url: `redis://app%3A%2540:p%40ss%2525@127.0.0.1:${port}` |
| 209 | })) |
| 210 | |
| 211 | assert.strictEqual( |
| 212 | yield* Fiber.join(server), |
| 213 | "*3\r\n$4\r\nAUTH\r\n$7\r\napp:%40\r\n$7\r\np@ss%25\r\n" |
| 214 | ) |
| 215 | })) |
| 216 | |
| 217 | it.effect("does not decode a query-string password twice", () => |
| 218 | Effect.gen(function*() { |
| 219 | const listener = yield* makeListener |
| 220 | const server = yield* Effect.gen(function*() { |
| 221 | const connection = yield* accept(listener) |
| 222 | const request = yield* read(connection) |
| 223 | yield* write(connection, "+OK\r\n") |
| 224 | return request |
| 225 | }).pipe(Effect.forkChild) |
| 226 | |
| 227 | const port = (listener.addr as Deno.NetAddr).port |
| 228 | yield* Layer.build(DenoRedis.layer({ |
| 229 | url: `redis://alice@127.0.0.1:${port}/?password=p%2540ss` |
| 230 | })) |
| 231 | |
| 232 | assert.strictEqual( |
| 233 | yield* Fiber.join(server), |
| 234 | "*3\r\n$4\r\nAUTH\r\n$5\r\nalice\r\n$6\r\np%40ss\r\n" |
| 235 | ) |
| 236 | })) |
| 237 | |
| 238 | it.effect("prefers explicit credentials over URL credentials", () => |
| 239 | Effect.gen(function*() { |
| 240 | const listener = yield* makeListener |
| 241 | const server = yield* Effect.gen(function*() { |
| 242 | const connection = yield* accept(listener) |
| 243 | const request = yield* read(connection) |
| 244 | yield* write(connection, "+OK\r\n") |
| 245 | return request |
| 246 | }).pipe(Effect.forkChild) |
| 247 | |
| 248 | const port = (listener.addr as Deno.NetAddr).port |
| 249 | yield* Layer.build(DenoRedis.layer({ |
| 250 | url: `redis://alice:secret@127.0.0.1:${port}`, |
| 251 | username: "bob", |
| 252 | password: "other" |
| 253 | })) |
| 254 | |
| 255 | assert.strictEqual( |
| 256 | yield* Fiber.join(server), |
| 257 | "*3\r\n$4\r\nAUTH\r\n$3\r\nbob\r\n$5\r\nother\r\n" |
| 258 | ) |
| 259 | })) |
| 260 | |
| 261 | const RedisItem = Schema.Struct({ |
| 262 | n: Schema.Number |
| 263 | }) |
| 264 | |
| 265 | const encoder = new TextEncoder() |
| 266 | const decoder = new TextDecoder() |
| 267 | |
| 268 | const makeListener = Effect.acquireRelease( |
| 269 | Effect.sync(() => Deno.listen({ hostname: "127.0.0.1", port: 0 })), |
| 270 | (listener) => Effect.sync(() => listener.close()) |
| 271 | ) |
| 272 | |
| 273 | const accept = (listener: Deno.TcpListener) => |
| 274 | Effect.acquireRelease( |
| 275 | Effect.promise(() => listener.accept()), |
| 276 | (connection) => Effect.sync(() => connection.close()) |
| 277 | ) |
| 278 | |
| 279 | const read = (connection: Deno.TcpConn) => |
| 280 | Effect.promise(() => { |
| 281 | const buffer = new Uint8Array(256) |
| 282 | return connection.read(buffer).then((size) => size === null ? null : decoder.decode(buffer.subarray(0, size))) |
| 283 | }) |
| 284 | |
| 285 | const write = (connection: Deno.TcpConn, value: string) => Effect.promise(() => connection.write(encoder.encode(value))) |