The best way to control Claude Code, Codex and more from any computer or phone

main
ts 142 lines 6.17 KB
Raw
1 import { assert, it } from "@effect/vitest"
2 import { Deferred, Effect, Fiber, Layer, Option, Queue } from "effect"
3 import * as RegressionTest from "effect-test/eventlog/EventLogServerUnencryptedRegressionTest"
4 import {
5 makeEntry,
6 makeOptions,
7 makeStorage,
8 makeStoreId,
9 openChanges,
10 suite
11 } from "effect-test/eventlog/SqlEventLogServerUnencryptedStorageTest"
12 import * as SqlEventLogServerUnencrypted from "effect/eventlog/SqlEventLogServerUnencrypted"
13 import { Reactivity } from "effect/reactivity"
14 import { PreventSchedulerYield } from "effect/Scheduler"
15 import * as SqlClient from "effect/sql/SqlClient"
16 import { PgContainer } from "./utils.ts"
17
18 suite("sql-pg", PgContainer.layerClient)
19
20 RegressionTest.suite(
21 "sql-pg",
22 SqlEventLogServerUnencrypted.layerStorage().pipe(
23 Layer.provide(PgContainer.layerClient),
24 Layer.provide(Reactivity.layer)
25 )
26 )
27
28 it.layer(Layer.merge(Reactivity.layer, PgContainer.layerClient), { timeout: "30 seconds" })(
29 "SqlEventLogServerUnencrypted commit visibility",
30 (it) => {
31 it.effect("streams concurrent commits in sequence order even when the first SQL return is delayed", () =>
32 Effect.gen(function*() {
33 const sql = yield* SqlClient.SqlClient
34 const committed = yield* Deferred.make<void>()
35 const publish = yield* Deferred.make<void>()
36 // Pause after SQL commits and releases its connection, before storage publishes.
37 let pauseNext = false
38 let observeSecond = false
39 let secondEnteredSql = false
40 const delayedSql: SqlClient.SqlClient = Object.assign(
41 (...args: Parameters<SqlClient.SqlClient>) => sql(...args),
42 sql,
43 {
44 withTransaction: <A, E, R>(effect: Effect.Effect<A, E, R>) =>
45 Effect.suspend(() => {
46 if (observeSecond) secondEnteredSql = true
47 const pause = pauseNext
48 pauseNext = false
49 return sql.withTransaction(effect).pipe(
50 Effect.tap(() =>
51 pause
52 ? Deferred.succeed(committed, undefined).pipe(Effect.andThen(Deferred.await(publish)))
53 : Effect.void
54 )
55 )
56 })
57 }
58 )
59 const storage = yield* makeStorage(makeOptions("concurrent_publication")).pipe(
60 Effect.provideService(SqlClient.SqlClient, delayedSql)
61 )
62 const storeId = makeStoreId("concurrent_publication")
63 const backlog = makeEntry("Ada")
64 const firstEntry = makeEntry("Grace")
65 const secondEntry = makeEntry("Margaret")
66 yield* storage.write(storeId, [backlog])
67 const changes = yield* openChanges(storage, storeId)
68 assert.strictEqual((yield* Queue.take(changes)).remoteSequence, 1)
69
70 pauseNext = true
71 const firstWriter = yield* storage.write(storeId, [firstEntry]).pipe(Effect.forkChild)
72 yield* Deferred.await(committed)
73 // Run writer two until it enters SQL or waits for the storage permit.
74 observeSecond = true
75 const secondWriter = yield* storage.write(storeId, [secondEntry]).pipe(
76 Effect.provideService(PreventSchedulerYield, true),
77 Effect.forkChild({ startImmediately: true })
78 )
79 observeSecond = false
80 if (secondEnteredSql) {
81 // Without serialization, force writer two to publish first.
82 yield* Fiber.join(secondWriter).pipe(
83 Effect.ensuring(Deferred.succeed(publish, undefined))
84 )
85 } else {
86 // Release writer one so writer two can acquire the permit.
87 yield* Deferred.succeed(publish, undefined)
88 yield* Fiber.join(secondWriter)
89 }
90 yield* Fiber.join(firstWriter)
91
92 const rows = yield* Queue.takeN(changes, 2)
93 yield* Effect.yieldNow
94 assert.strictEqual(Option.isNone(yield* Queue.poll(changes)), true)
95 const persisted = yield* Queue.takeAll(yield* openChanges(storage, storeId))
96 assert.deepStrictEqual(persisted.map((row) => row.remoteSequence), [1, 2, 3])
97 assert.deepStrictEqual(
98 persisted.map((row) => row.entry.idString),
99 [backlog.idString, firstEntry.idString, secondEntry.idString]
100 )
101 assert.deepStrictEqual(rows.map((row) => row.remoteSequence), [2, 3])
102 assert.deepStrictEqual(rows.map((row) => row.entry.idString), [firstEntry.idString, secondEntry.idString])
103 }))
104
105 it.effect("streams a write committed after the startup backlog read exactly once", () =>
106 Effect.gen(function*() {
107 const storage = yield* makeStorage(makeOptions("commit_visibility"))
108 const storeId = makeStoreId("commit_visibility")
109 const backlogEntry = makeEntry("Ada")
110 const racedEntry = makeEntry("Grace")
111 const liveEntry = makeEntry("Margaret")
112 yield* storage.write(storeId, [backlogEntry])
113
114 const written = yield* Deferred.make<void>()
115 const commit = yield* Deferred.make<void>()
116 const writer = yield* storage.withTransaction(Effect.gen(function*() {
117 yield* storage.write(storeId, [racedEntry])
118 yield* Deferred.succeed(written, undefined)
119 yield* Deferred.await(commit)
120 })).pipe(Effect.forkChild)
121 yield* Deferred.await(written)
122
123 // Read the backlog before commit to establish the subscription and snapshot.
124 const changes = yield* openChanges(storage, storeId)
125 const first = yield* Queue.take(changes)
126 assert.strictEqual(first.entry.idString, backlogEntry.idString)
127
128 yield* Deferred.succeed(commit, undefined)
129 yield* Fiber.join(writer)
130 // A later write exposes a missed row as [1, 3] instead of a timeout.
131 yield* storage.write(storeId, [liveEntry])
132 const second = yield* Queue.take(changes)
133 assert.deepStrictEqual([first.remoteSequence, second.remoteSequence], [1, 2])
134 assert.strictEqual(second.entry.idString, racedEntry.idString)
135 const third = yield* Queue.take(changes)
136 assert.strictEqual(third.remoteSequence, 3)
137 assert.strictEqual(third.entry.idString, liveEntry.idString)
138 yield* Effect.yieldNow
139 assert.strictEqual(Option.isNone(yield* Queue.poll(changes)), true)
140 }))
141 }
142 )