|
|
@@ -1,16 +1,18 @@
|
|
|
-import { describe, test, expect, beforeEach, afterEach, afterAll } from "bun:test"
|
|
|
-import { tmpdir } from "../fixture/fixture"
|
|
|
-import { Schema } from "effect"
|
|
|
+import { describe, expect, beforeEach, afterEach, afterAll } from "bun:test"
|
|
|
+import { provideTmpdirInstance } from "../fixture/fixture"
|
|
|
+import { Effect, Layer, Schema } from "effect"
|
|
|
+import { CrossSpawnSpawner } from "@opencode-ai/core/cross-spawn-spawner"
|
|
|
import { Bus } from "../../src/bus"
|
|
|
-import { Instance } from "../../src/project/instance"
|
|
|
import { SyncEvent } from "../../src/sync"
|
|
|
import { Database } from "@/storage/db"
|
|
|
import { EventTable } from "../../src/sync/event.sql"
|
|
|
-import { Identifier } from "../../src/id/id"
|
|
|
+import { MessageID } from "../../src/session/schema"
|
|
|
import { Flag } from "@opencode-ai/core/flag/flag"
|
|
|
import { initProjectors } from "../../src/server/projectors"
|
|
|
+import { testEffect } from "../lib/effect"
|
|
|
|
|
|
const original = Flag.OPENCODE_EXPERIMENTAL_WORKSPACES
|
|
|
+const it = testEffect(Layer.mergeAll(SyncEvent.defaultLayer, CrossSpawnSpawner.defaultLayer))
|
|
|
|
|
|
beforeEach(() => {
|
|
|
Database.close()
|
|
|
@@ -22,19 +24,6 @@ afterEach(() => {
|
|
|
Flag.OPENCODE_EXPERIMENTAL_WORKSPACES = original
|
|
|
})
|
|
|
|
|
|
-function withInstance(fn: () => void | Promise<void>) {
|
|
|
- return async () => {
|
|
|
- await using tmp = await tmpdir()
|
|
|
-
|
|
|
- await Instance.provide({
|
|
|
- directory: tmp.path,
|
|
|
- fn: async () => {
|
|
|
- await fn()
|
|
|
- },
|
|
|
- })
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
describe("SyncEvent", () => {
|
|
|
function setup() {
|
|
|
SyncEvent.reset()
|
|
|
@@ -59,179 +48,209 @@ describe("SyncEvent", () => {
|
|
|
return { Created, Sent }
|
|
|
}
|
|
|
|
|
|
+ function expectDefect<A, E, R>(effect: Effect.Effect<A, E, R>, pattern: RegExp) {
|
|
|
+ return Effect.gen(function* () {
|
|
|
+ const exit = yield* Effect.exit(effect)
|
|
|
+ if (exit._tag === "Success") throw new Error("Expected effect to fail")
|
|
|
+ expect(String(exit.cause)).toMatch(pattern)
|
|
|
+ })
|
|
|
+ }
|
|
|
+
|
|
|
afterAll(() => {
|
|
|
SyncEvent.reset()
|
|
|
initProjectors()
|
|
|
})
|
|
|
|
|
|
describe("run", () => {
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"inserts event row",
|
|
|
- withInstance(() => {
|
|
|
- const { Created } = setup()
|
|
|
- SyncEvent.run(Created, { id: "evt_1", name: "first" })
|
|
|
- const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
- expect(rows).toHaveLength(1)
|
|
|
- expect(rows[0].type).toBe("item.created.1")
|
|
|
- expect(rows[0].aggregate_id).toBe("evt_1")
|
|
|
- }),
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const { Created } = setup()
|
|
|
+ yield* SyncEvent.use.run(Created, { id: "evt_1", name: "first" })
|
|
|
+ const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
+ expect(rows).toHaveLength(1)
|
|
|
+ expect(rows[0].type).toBe("item.created.1")
|
|
|
+ expect(rows[0].aggregate_id).toBe("evt_1")
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"increments seq per aggregate",
|
|
|
- withInstance(() => {
|
|
|
- const { Created } = setup()
|
|
|
- SyncEvent.run(Created, { id: "evt_1", name: "first" })
|
|
|
- SyncEvent.run(Created, { id: "evt_1", name: "second" })
|
|
|
- const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
- expect(rows).toHaveLength(2)
|
|
|
- expect(rows[1].seq).toBe(rows[0].seq + 1)
|
|
|
- }),
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const { Created } = setup()
|
|
|
+ yield* SyncEvent.use.run(Created, { id: "evt_1", name: "first" })
|
|
|
+ yield* SyncEvent.use.run(Created, { id: "evt_1", name: "second" })
|
|
|
+ const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
+ expect(rows).toHaveLength(2)
|
|
|
+ expect(rows[1].seq).toBe(rows[0].seq + 1)
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"uses custom aggregate field from agg()",
|
|
|
- withInstance(() => {
|
|
|
- const { Sent } = setup()
|
|
|
- SyncEvent.run(Sent, { item_id: "evt_1", to: "james" })
|
|
|
- const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
- expect(rows).toHaveLength(1)
|
|
|
- expect(rows[0].aggregate_id).toBe("evt_1")
|
|
|
- }),
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const { Sent } = setup()
|
|
|
+ yield* SyncEvent.use.run(Sent, { item_id: "evt_1", to: "james" })
|
|
|
+ const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
+ expect(rows).toHaveLength(1)
|
|
|
+ expect(rows[0].aggregate_id).toBe("evt_1")
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"emits events",
|
|
|
- withInstance(async () => {
|
|
|
- const { Created } = setup()
|
|
|
- const events: Array<{
|
|
|
- type: string
|
|
|
- properties: { id: string; name: string }
|
|
|
- }> = []
|
|
|
- const received = new Promise<void>((resolve) => {
|
|
|
- Bus.subscribeAll((event) => {
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const { Created } = setup()
|
|
|
+ const events: Array<{
|
|
|
+ type: string
|
|
|
+ properties: { id: string; name: string }
|
|
|
+ }> = []
|
|
|
+ let resolve = () => {}
|
|
|
+ const received = new Promise<void>((done) => {
|
|
|
+ resolve = done
|
|
|
+ })
|
|
|
+ const dispose = Bus.subscribeAll((event) => {
|
|
|
events.push(event)
|
|
|
resolve()
|
|
|
})
|
|
|
- })
|
|
|
-
|
|
|
- SyncEvent.run(Created, { id: "evt_1", name: "test" })
|
|
|
-
|
|
|
- await received
|
|
|
- expect(events).toHaveLength(1)
|
|
|
- expect(events[0]).toEqual({
|
|
|
- type: "item.created",
|
|
|
- properties: {
|
|
|
- id: "evt_1",
|
|
|
- name: "test",
|
|
|
- },
|
|
|
- })
|
|
|
- }),
|
|
|
+ try {
|
|
|
+ yield* SyncEvent.use.run(Created, { id: "evt_1", name: "test" })
|
|
|
+ yield* Effect.promise(() => received)
|
|
|
+ expect(events).toHaveLength(1)
|
|
|
+ expect(events[0]).toEqual({
|
|
|
+ type: "item.created",
|
|
|
+ properties: {
|
|
|
+ id: "evt_1",
|
|
|
+ name: "test",
|
|
|
+ },
|
|
|
+ })
|
|
|
+ } finally {
|
|
|
+ dispose()
|
|
|
+ }
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
})
|
|
|
|
|
|
describe("replay", () => {
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"inserts event from external payload",
|
|
|
- withInstance(() => {
|
|
|
- const id = Identifier.descending("message")
|
|
|
- SyncEvent.replay({
|
|
|
- id: "evt_1",
|
|
|
- type: "item.created.1",
|
|
|
- seq: 0,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "replayed" },
|
|
|
- })
|
|
|
- const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
- expect(rows).toHaveLength(1)
|
|
|
- expect(rows[0].aggregate_id).toBe(id)
|
|
|
- }),
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const id = MessageID.ascending()
|
|
|
+ yield* SyncEvent.use.replay({
|
|
|
+ id: "evt_1",
|
|
|
+ type: "item.created.1",
|
|
|
+ seq: 0,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "replayed" },
|
|
|
+ })
|
|
|
+ const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
+ expect(rows).toHaveLength(1)
|
|
|
+ expect(rows[0].aggregate_id).toBe(id)
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"throws on sequence mismatch",
|
|
|
- withInstance(() => {
|
|
|
- const id = Identifier.descending("message")
|
|
|
- SyncEvent.replay({
|
|
|
- id: "evt_1",
|
|
|
- type: "item.created.1",
|
|
|
- seq: 0,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "first" },
|
|
|
- })
|
|
|
- expect(() =>
|
|
|
- SyncEvent.replay({
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const id = MessageID.ascending()
|
|
|
+ yield* SyncEvent.use.replay({
|
|
|
id: "evt_1",
|
|
|
type: "item.created.1",
|
|
|
- seq: 5,
|
|
|
+ seq: 0,
|
|
|
aggregateID: id,
|
|
|
- data: { id, name: "bad" },
|
|
|
- }),
|
|
|
- ).toThrow(/Sequence mismatch/)
|
|
|
- }),
|
|
|
+ data: { id, name: "first" },
|
|
|
+ })
|
|
|
+ yield* expectDefect(
|
|
|
+ SyncEvent.use.replay({
|
|
|
+ id: "evt_1",
|
|
|
+ type: "item.created.1",
|
|
|
+ seq: 5,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "bad" },
|
|
|
+ }),
|
|
|
+ /Sequence mismatch/,
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"throws on unknown event type",
|
|
|
- withInstance(() => {
|
|
|
- expect(() =>
|
|
|
- SyncEvent.replay({
|
|
|
- id: "evt_1",
|
|
|
- type: "unknown.event.1",
|
|
|
- seq: 0,
|
|
|
- aggregateID: "x",
|
|
|
- data: {},
|
|
|
- }),
|
|
|
- ).toThrow(/Unknown event type/)
|
|
|
- }),
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ yield* expectDefect(
|
|
|
+ SyncEvent.use.replay({
|
|
|
+ id: "evt_1",
|
|
|
+ type: "unknown.event.1",
|
|
|
+ seq: 0,
|
|
|
+ aggregateID: "x",
|
|
|
+ data: {},
|
|
|
+ }),
|
|
|
+ /Unknown event type/,
|
|
|
+ )
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
|
|
|
- test(
|
|
|
+ it.live(
|
|
|
"replayAll accepts later chunks after the first batch",
|
|
|
- withInstance(() => {
|
|
|
- const { Created } = setup()
|
|
|
- const id = Identifier.descending("message")
|
|
|
+ provideTmpdirInstance(() =>
|
|
|
+ Effect.gen(function* () {
|
|
|
+ const { Created } = setup()
|
|
|
+ const id = MessageID.ascending()
|
|
|
|
|
|
- const one = SyncEvent.replayAll([
|
|
|
- {
|
|
|
- id: "evt_1",
|
|
|
- type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
- seq: 0,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "first" },
|
|
|
- },
|
|
|
- {
|
|
|
- id: "evt_2",
|
|
|
- type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
- seq: 1,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "second" },
|
|
|
- },
|
|
|
- ])
|
|
|
-
|
|
|
- const two = SyncEvent.replayAll([
|
|
|
- {
|
|
|
- id: "evt_3",
|
|
|
- type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
- seq: 2,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "third" },
|
|
|
- },
|
|
|
- {
|
|
|
- id: "evt_4",
|
|
|
- type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
- seq: 3,
|
|
|
- aggregateID: id,
|
|
|
- data: { id, name: "fourth" },
|
|
|
- },
|
|
|
- ])
|
|
|
+ const one = yield* SyncEvent.use.replayAll([
|
|
|
+ {
|
|
|
+ id: "evt_1",
|
|
|
+ type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
+ seq: 0,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "first" },
|
|
|
+ },
|
|
|
+ {
|
|
|
+ id: "evt_2",
|
|
|
+ type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
+ seq: 1,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "second" },
|
|
|
+ },
|
|
|
+ ])
|
|
|
+
|
|
|
+ const two = yield* SyncEvent.use.replayAll([
|
|
|
+ {
|
|
|
+ id: "evt_3",
|
|
|
+ type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
+ seq: 2,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "third" },
|
|
|
+ },
|
|
|
+ {
|
|
|
+ id: "evt_4",
|
|
|
+ type: SyncEvent.versionedType(Created.type, Created.version),
|
|
|
+ seq: 3,
|
|
|
+ aggregateID: id,
|
|
|
+ data: { id, name: "fourth" },
|
|
|
+ },
|
|
|
+ ])
|
|
|
|
|
|
- expect(one).toBe(id)
|
|
|
- expect(two).toBe(id)
|
|
|
+ expect(one).toBe(id)
|
|
|
+ expect(two).toBe(id)
|
|
|
|
|
|
- const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
- expect(rows.map((row) => row.seq)).toEqual([0, 1, 2, 3])
|
|
|
- }),
|
|
|
+ const rows = Database.use((db) => db.select().from(EventTable).all())
|
|
|
+ expect(rows.map((row) => row.seq)).toEqual([0, 1, 2, 3])
|
|
|
+ }),
|
|
|
+ ),
|
|
|
)
|
|
|
})
|
|
|
})
|
Kit Langton