@reventlessdev/reventless-local 3.0.0-alpha.113

package/tests/components/aggregate/AggregateFixtures.res

@@ -0,0 +1,78 @@
+// E2E test fixtures for the Aggregate E2E test.
+// Contains specs, behavior, bus setup, and shared test data.
+
+// ─────────────────────────────────────────────────────────────
+// Simple Item aggregate spec
+// ─────────────────────────────────────────────────────────────
+
+module ItemSpec = {
+  module Id = Reventless.Id.String
+  let name = "TestItem"
+
+  @schema
+  type command = CreateItem({name: string})
+
+  @schema
+  type event = ItemCreated({name: string})
+
+  @schema
+  type error = AlreadyExists
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+}
+
+// ─────────────────────────────────────────────────────────────
+// Item behavior: CreateItem → ItemCreated
+// ─────────────────────────────────────────────────────────────
+
+module ItemBehavior: ReventlessCore.Behavior.T with module Spec := ItemSpec = {
+  type state = bool // true = item exists
+
+  let initialState = false
+
+  let moduleUrl: string = %raw(`import.meta.url`)
+
+  let evolve = (_state, _event: ItemSpec.event) => true
+
+  let decide = (state, command: ItemSpec.command) =>
+    if state {
+      Error(ItemSpec.AlreadyExists)
+    } else {
+      switch command {
+      | ItemSpec.CreateItem({name}) => Ok([ItemSpec.ItemCreated({name: name})])
+      }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Isolated bus for the E2E test (shared across all tests here)
+// ─────────────────────────────────────────────────────────────
+
+module Bus = LocalBus.Make()
+
+// Capture events published to the aggregate's event topic.
+// Topic name = Spec.name ++ "Aggr" ++ "EventTopic" = "TestItemAggrEventTopic"
+let capturedEventCount: ref<int> = ref(0)
+
+let _ = Bus.subscribeToEvents("TestItemAggrEventTopic", async (_, _, _) => {
+  capturedEventCount := capturedEventCount.contents + 1
+})
+
+// ─────────────────────────────────────────────────────────────
+// Activate Pulumi mock mode (must be before any Component.make)
+// ─────────────────────────────────────────────────────────────
+
+let _ = TestRunner.setup()
+
+// ─────────────────────────────────────────────────────────────
+// Build the aggregate (creates Pulumi components + wires bus)
+// ─────────────────────────────────────────────────────────────
+
+module ItemAggregateMaker = Aggregate_Builder.Make(Bus)
+module ItemAgg = ItemAggregateMaker.Make(
+  ItemSpec,
+  ItemBehavior,
+  ReventlessInfra.NoEventMappings.Make(ItemSpec),
+)
+
+let agg = ItemAgg.make(~api=())

package/tests/components/aggregate/AggregateFixtures.res.mjs

@@ -0,0 +1,109 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as NoEventMappings$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/NoEventMappings.res.mjs";
+import * as Aggregate_Builder$ReventlessLocal from "../../../src/components/Aggregate_Builder.res.mjs";
+
+let name = "TestItem";
+
+let commandSchema = S.schema(s => ({
+  TAG: "CreateItem",
+  name: s.m(S.string)
+}));
+
+let eventSchema = S.schema(s => ({
+  TAG: "ItemCreated",
+  name: s.m(S.string)
+}));
+
+let errorSchema = S.literal("AlreadyExists");
+
+let moduleUrl = import.meta.url;
+
+function commandAuthorization(param) {
+  return "AllowAuthenticated";
+}
+
+let ItemSpec = {
+  Id: undefined,
+  name: name,
+  commandSchema: commandSchema,
+  eventSchema: eventSchema,
+  errorSchema: errorSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+};
+
+let moduleUrl$1 = import.meta.url;
+
+function evolve(_state, _event) {
+  return true;
+}
+
+function decide(state, command) {
+  if (state) {
+    return {
+      TAG: "Error",
+      _0: "AlreadyExists"
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: [{
+          TAG: "ItemCreated",
+          name: command.name
+        }]
+    };
+  }
+}
+
+let ItemBehavior = {
+  initialState: false,
+  evolve: evolve,
+  decide: decide,
+  moduleUrl: moduleUrl$1
+};
+
+let Bus = LocalBus$ReventlessLocal.Make({});
+
+let capturedEventCount = {
+  contents: 0
+};
+
+Bus.subscribeToEvents("TestItemAggrEventTopic", async (param, param$1, param$2) => {
+  capturedEventCount.contents = capturedEventCount.contents + 1 | 0;
+});
+
+TestRunner$ReventlessLocal.setup();
+
+let ItemAggregateMaker = Aggregate_Builder$ReventlessLocal.Make(Bus);
+
+let ItemAgg = ItemAggregateMaker.Make({
+  Id: Id$Reventless.$$String,
+  name: name,
+  eventSchema: eventSchema,
+  errorSchema: errorSchema,
+  commandSchema: commandSchema,
+  moduleUrl: moduleUrl,
+  commandAuthorization: commandAuthorization
+})(ItemBehavior)(NoEventMappings$ReventlessInfra.Make({
+  name: name,
+  Id: Id$Reventless.$$String,
+  commandSchema: commandSchema
+}));
+
+let agg = ItemAgg.make(undefined, undefined);
+
+export {
+  ItemSpec,
+  ItemBehavior,
+  Bus,
+  capturedEventCount,
+  ItemAggregateMaker,
+  ItemAgg,
+  agg,
+}
+/* commandSchema Not a pure module */

package/tests/components/aggregate/AggregateTest.res

@@ -0,0 +1,129 @@
+// E2E test for reventless-local package.
+// Verifies the full aggregate command → event flow using the in-memory bus.
+
+open TestFixtures
+open JestGlobals
+open AggregateFixtures
+
+describe("LocalBus", () => {
+  testPromise("publishes events to all subscribers", async () => {
+    module TestBus = LocalBus.Make()
+    let count: ref<int> = ref(0)
+    TestBus.subscribeToEvents("t1", async (_, _, _) => {
+      count := count.contents + 1
+    })
+    TestBus.subscribeToEvents("t1", async (_, _, _) => {
+      count := count.contents + 1
+    })
+    await TestBus.publishEvent("t1", "memory:InMemory", testMeta, JSON.Null)
+    expect(count.contents)->toBe(2)
+  })
+
+  testPromise("dispatches commands to registered handler", async () => {
+    module TestBus = LocalBus.Make()
+    let received: ref<option<string>> = ref(None)
+    TestBus.registerCommandHandler("cmd1", async (json, _) => {
+      received := switch json {
+      | JSON.String(s) => Some(s)
+      | _ => None
+      }
+    })
+    await TestBus.dispatchCommand("cmd1", JSON.Encode.string("hello"))
+    expect(received.contents)->toEqual(Some("hello"))
+  })
+
+  testPromise("reset clears all handlers and subscribers", async () => {
+    module TestBus = LocalBus.Make()
+    let count: ref<int> = ref(0)
+    TestBus.subscribeToEvents("topic", async (_, _, _) => {
+      count := count.contents + 1
+    })
+    TestBus.reset()
+    // After reset, no subscribers — this just verifies no crash
+    expect(count.contents)->toBe(0)
+  })
+})
+
+describe("EventLogStorage_InMemory", () => {
+  testPromise("append stores events and replay returns them", async () => {
+    let opts: Pulumi.CustomResourceOptions.t = {}
+    let storage = EventLogStorage_InMemory.make(~name="test-log", ~opts)
+    let ops = await storage.operations->TestRunner.resolve
+    let _ = await ops.append(0, "agg-1", [JSON.Encode.string("e1"), JSON.Encode.string("e2")])
+    let events = await ops.replay("agg-1")
+    expect(events->Array.length)->toBe(2)
+  })
+
+  testPromise("replay returns empty array for unknown aggregate id", async () => {
+    let opts: Pulumi.CustomResourceOptions.t = {}
+    let storage = EventLogStorage_InMemory.make(~name="test-log-2", ~opts)
+    let ops = await storage.operations->TestRunner.resolve
+    let events = await ops.replay("unknown-id")
+    expect(events->Array.length)->toBe(0)
+  })
+
+  testPromise("multiple appends accumulate events", async () => {
+    let opts: Pulumi.CustomResourceOptions.t = {}
+    let storage = EventLogStorage_InMemory.make(~name="test-log-3", ~opts)
+    let ops = await storage.operations->TestRunner.resolve
+    let _ = await ops.append(0, "agg-2", [JSON.Encode.string("e1")])
+    let _ = await ops.append(1, "agg-2", [JSON.Encode.string("e2"), JSON.Encode.string("e3")])
+    let events = await ops.replay("agg-2")
+    expect(events->Array.length)->toBe(3)
+  })
+})
+
+describe("Aggregate E2E", () => {
+  // Resolve the Output chain before any test runs so bus wiring is complete.
+  let _ = beforeAllAsync(async () => {
+    let _ = await agg->ItemAgg.operations->TestRunner.resolve
+  })
+
+  let _ = beforeEach(() => {
+    capturedEventCount := 0
+  })
+
+  testPromise("CreateItem command produces ItemCreated event on event topic", async () => {
+    let ops = await agg->ItemAgg.operations->TestRunner.resolve
+    let commandJson =
+      ItemSpec.CreateItem({name: "Widget"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
+    await ops.publishJsons([
+      {
+        Reventless.Message.id: "item-1",
+        meta: testMeta,
+        commandJson: commandJson,
+      },
+    ])
+    expect(capturedEventCount.contents)->toBe(1)
+  })
+
+  testPromise("second CreateItem for same id produces no events (AlreadyExists)", async () => {
+    // item-1 was already created in the previous test (same aggregate instance)
+    let ops = await agg->ItemAgg.operations->TestRunner.resolve
+    let commandJson =
+      ItemSpec.CreateItem({name: "Widget2"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
+    await ops.publishJsons([
+      {
+        Reventless.Message.id: "item-1",
+        meta: testMeta,
+        commandJson: commandJson,
+      },
+    ])
+    // AlreadyExists error → no events generated → no bus publish
+    expect(capturedEventCount.contents)->toBe(0)
+  })
+
+  testPromise("CreateItem for new id produces event", async () => {
+    let ops = await agg->ItemAgg.operations->TestRunner.resolve
+    let commandJson =
+      ItemSpec.CreateItem({name: "NewItem"})->ReventlessCore.Message.encode(ItemSpec.commandSchema)
+    await ops.publishJsons([
+      {
+        Reventless.Message.id: "item-2",
+        meta: testMeta,
+        commandJson: commandJson,
+      },
+    ])
+    expect(capturedEventCount.contents)->toBe(1)
+  })
+})

package/tests/components/aggregate/AggregateTest.res.mjs

@@ -0,0 +1,129 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Message$ReventlessCore from "@reventlessdev/reventless-core/src/Message.res.mjs";
+import * as LocalBus$ReventlessLocal from "../../../src/adapter/LocalBus.res.mjs";
+import * as TestRunner$ReventlessLocal from "../../../src/test/TestRunner.res.mjs";
+import * as TestFixtures$ReventlessLocal from "../../TestFixtures.res.mjs";
+import * as AggregateFixtures$ReventlessLocal from "./AggregateFixtures.res.mjs";
+import * as EventLogStorage_InMemory$ReventlessLocal from "../../../src/adapter/EventLog/EventLogStorage_InMemory.res.mjs";
+
+globalThis.describe("LocalBus", () => {
+  globalThis.test("publishes events to all subscribers", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let count = {
+      contents: 0
+    };
+    TestBus.subscribeToEvents("t1", async (param, param$1, param$2) => {
+      count.contents = count.contents + 1 | 0;
+    });
+    TestBus.subscribeToEvents("t1", async (param, param$1, param$2) => {
+      count.contents = count.contents + 1 | 0;
+    });
+    await TestBus.publishEvent("t1", "memory:InMemory", TestFixtures$ReventlessLocal.testMeta, null);
+    globalThis.expect(count.contents).toBe(2);
+  });
+  globalThis.test("dispatches commands to registered handler", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let received = {
+      contents: undefined
+    };
+    TestBus.registerCommandHandler("cmd1", async (json, param) => {
+      let tmp;
+      tmp = typeof json === "string" ? json : undefined;
+      received.contents = tmp;
+    });
+    await TestBus.dispatchCommand("cmd1", "hello");
+    globalThis.expect(received.contents).toEqual("hello");
+  });
+  globalThis.test("reset clears all handlers and subscribers", async () => {
+    let TestBus = LocalBus$ReventlessLocal.Make({});
+    let count = {
+      contents: 0
+    };
+    TestBus.subscribeToEvents("topic", async (param, param$1, param$2) => {
+      count.contents = count.contents + 1 | 0;
+    });
+    TestBus.reset();
+    globalThis.expect(count.contents).toBe(0);
+  });
+});
+
+globalThis.describe("EventLogStorage_InMemory", () => {
+  globalThis.test("append stores events and replay returns them", async () => {
+    let storage = EventLogStorage_InMemory$ReventlessLocal.make("test-log", {});
+    let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+    await ops.append(0, "agg-1", [
+      "e1",
+      "e2"
+    ]);
+    let events = await ops.replay("agg-1");
+    globalThis.expect(events.length).toBe(2);
+  });
+  globalThis.test("replay returns empty array for unknown aggregate id", async () => {
+    let storage = EventLogStorage_InMemory$ReventlessLocal.make("test-log-2", {});
+    let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+    let events = await ops.replay("unknown-id");
+    globalThis.expect(events.length).toBe(0);
+  });
+  globalThis.test("multiple appends accumulate events", async () => {
+    let storage = EventLogStorage_InMemory$ReventlessLocal.make("test-log-3", {});
+    let ops = await TestRunner$ReventlessLocal.resolve(storage.operations);
+    await ops.append(0, "agg-2", ["e1"]);
+    await ops.append(1, "agg-2", [
+      "e2",
+      "e3"
+    ]);
+    let events = await ops.replay("agg-2");
+    globalThis.expect(events.length).toBe(3);
+  });
+});
+
+globalThis.describe("Aggregate E2E", () => {
+  globalThis.beforeAll(async () => {
+    await TestRunner$ReventlessLocal.resolve(AggregateFixtures$ReventlessLocal.ItemAgg.operations(AggregateFixtures$ReventlessLocal.agg));
+  });
+  globalThis.beforeEach(() => {
+    AggregateFixtures$ReventlessLocal.capturedEventCount.contents = 0;
+  });
+  globalThis.test("CreateItem command produces ItemCreated event on event topic", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(AggregateFixtures$ReventlessLocal.ItemAgg.operations(AggregateFixtures$ReventlessLocal.agg));
+    let commandJson = Message$ReventlessCore.encode({
+      TAG: "CreateItem",
+      name: "Widget"
+    }, AggregateFixtures$ReventlessLocal.ItemSpec.commandSchema);
+    await ops.publishJsons([{
+        id: "item-1",
+        meta: TestFixtures$ReventlessLocal.testMeta,
+        commandJson: commandJson
+      }]);
+    globalThis.expect(AggregateFixtures$ReventlessLocal.capturedEventCount.contents).toBe(1);
+  });
+  globalThis.test("second CreateItem for same id produces no events (AlreadyExists)", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(AggregateFixtures$ReventlessLocal.ItemAgg.operations(AggregateFixtures$ReventlessLocal.agg));
+    let commandJson = Message$ReventlessCore.encode({
+      TAG: "CreateItem",
+      name: "Widget2"
+    }, AggregateFixtures$ReventlessLocal.ItemSpec.commandSchema);
+    await ops.publishJsons([{
+        id: "item-1",
+        meta: TestFixtures$ReventlessLocal.testMeta,
+        commandJson: commandJson
+      }]);
+    globalThis.expect(AggregateFixtures$ReventlessLocal.capturedEventCount.contents).toBe(0);
+  });
+  globalThis.test("CreateItem for new id produces event", async () => {
+    let ops = await TestRunner$ReventlessLocal.resolve(AggregateFixtures$ReventlessLocal.ItemAgg.operations(AggregateFixtures$ReventlessLocal.agg));
+    let commandJson = Message$ReventlessCore.encode({
+      TAG: "CreateItem",
+      name: "NewItem"
+    }, AggregateFixtures$ReventlessLocal.ItemSpec.commandSchema);
+    await ops.publishJsons([{
+        id: "item-2",
+        meta: TestFixtures$ReventlessLocal.testMeta,
+        commandJson: commandJson
+      }]);
+    globalThis.expect(AggregateFixtures$ReventlessLocal.capturedEventCount.contents).toBe(1);
+  });
+});
+
+/*  Not a pure module */

package/tests/components/automationslice/AutomationSliceCallbackTest.res

@@ -0,0 +1,212 @@
+// Unit tests for AutomationSlice_Callback (Plan 04 mixed-source shape) —
+// exercises per-source decode dispatch, context plumbing, and toTags
+// validation.
+
+open JestGlobals
+open AutomationSliceFixtures
+
+module Callback = ReventlessCore.AutomationSlice_Callback.Make(
+  ShipOrderSpec,
+  ShipOrderAutomation,
+)
+
+module SkipCallback = ReventlessCore.AutomationSlice_Callback.Make(
+  SkipProcessSpec,
+  SkipProcessAutomation,
+)
+
+open ReventlessCore.AutomationSlice_Callback
+
+describe("AutomationSlice Callback (mixed-source)", () => {
+  let _ = beforeEach(() => {
+    Callback.todoItems
+    ->Dict.keysToArray
+    ->Array.forEach(k => Callback.todoItems->Dict.delete(k))
+    SkipCallback.todoItems
+    ->Dict.keysToArray
+    ->Array.forEach(k => SkipCallback.todoItems->Dict.delete(k))
+  })
+
+  describe("Phase 1 — collect", () => {
+    testPromise("OrderPlaced JSON creates a pending TODO item", async () => {
+      let json = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+      Callback.phase1([json], testContext)
+      let items = Callback.todoItems
+      expect(items->Dict.toArray->Array.length)->toBe(1)
+      let row = items->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Pending)
+      expect(row.retryCount)->toBe(0)
+    })
+
+    testPromise("duplicate OrderPlaced is idempotent", async () => {
+      let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+      let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "456 Oak Ave"}))
+      Callback.phase1([j1], testContext)
+      Callback.phase1([j2], testContext)
+      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(1)
+    })
+
+    testPromise("multiple OrderPlaced events create multiple TODO items", async () => {
+      let j1 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))
+      let j2 = encodeShipOrderEvent(OrderPlaced({orderId: "ord-2", address: "456 Oak Ave"}))
+      Callback.phase1([j1, j2], testContext)
+      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(2)
+    })
+
+    testPromise("ShipmentCreated does not create a TODO item", async () => {
+      let json = encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))
+      Callback.phase1([json], testContext)
+      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
+    })
+  })
+
+  describe("Phase 1 — resolve", () => {
+    testPromise("ShipmentCreated marks pending TODO item as completed", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      Callback.phase1(
+        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+        testContext,
+      )
+      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Completed)
+    })
+
+    testPromise("ShipmentCreated for unknown id is a no-op", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(ShipmentCreated({orderId: "unknown"}))],
+        testContext,
+      )
+      expect(Callback.todoItems->Dict.toArray->Array.length)->toBe(0)
+    })
+  })
+
+  describe("Phase 2 — process", () => {
+    testPromise("pending items produce commands via publishJsons", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await Callback.phase2(mockPublish)
+
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      let cmd = publishedCommands.contents->Array.getUnsafe(0)
+      expect(cmd.id)->toBe("ord-1")
+
+      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Processing)
+    })
+
+    testPromise("completed items are not processed", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      Callback.phase1(
+        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+        testContext,
+      )
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await Callback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("items where process returns None are skipped", async () => {
+      let json = encodeSkipProcessEvent(OrderPlaced({orderId: "ord-1"}))
+      SkipCallback.phase1([json], testContext)
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await SkipCallback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+      let row = SkipCallback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Pending)
+    })
+
+    testPromise("empty TODO list produces no commands", async () => {
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await Callback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(0)
+    })
+
+    testPromise("publishJsons failure marks items as Failed", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
+        JsError.throwWithMessage("publish failed")
+      }
+      await Callback.phase2(failingPublish)
+      let row = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row.status)->toBe(Failed)
+      expect(row.retryCount)->toBe(1)
+    })
+
+    testPromise("failed items with retryCount < maxRetries are retried", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      let failingPublish: ReventlessInfra.CommandTopic.publishJsons = async _cmds => {
+        JsError.throwWithMessage("publish failed")
+      }
+      await Callback.phase2(failingPublish)
+      let row1 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row1.retryCount)->toBe(1)
+
+      let publishedCommands = ref([])
+      let successPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await Callback.phase2(successPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      let row2 = Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow
+      expect(row2.status)->toBe(Processing)
+    })
+  })
+
+  describe("full lifecycle", () => {
+    testPromise("collect → process → resolve completes the TODO item", async () => {
+      Callback.phase1(
+        [encodeShipOrderEvent(OrderPlaced({orderId: "ord-1", address: "123 Main St"}))],
+        testContext,
+      )
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Pending)
+
+      let publishedCommands = ref([])
+      let mockPublish: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands := cmds
+      }
+      await Callback.phase2(mockPublish)
+      expect(publishedCommands.contents->Array.length)->toBe(1)
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Processing)
+
+      Callback.phase1(
+        [encodeShipOrderEvent(ShipmentCreated({orderId: "ord-1"}))],
+        testContext,
+      )
+      expect((Callback.todoItems->Dict.get("ord-1")->Option.getOrThrow).status)->toBe(Completed)
+
+      let publishedCommands2 = ref([])
+      let mockPublish2: ReventlessInfra.CommandTopic.publishJsons = async cmds => {
+        publishedCommands2 := cmds
+      }
+      await Callback.phase2(mockPublish2)
+      expect(publishedCommands2.contents->Array.length)->toBe(0)
+    })
+  })
+})