@copilotkitnext/runtime 0.0.1

package/src/__tests__/in-process-agent-runner.test.ts

@@ -0,0 +1,726 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { InMemoryAgentRunner } from "../runner/in-memory";
+import { AbstractAgent, BaseEvent, RunAgentInput } from "@ag-ui/client";
+import { firstValueFrom } from "rxjs";
+import { toArray } from "rxjs/operators";
+
+// Mock agent implementations for testing
+class MockAgent extends AbstractAgent {
+  private events: BaseEvent[];
+  private delay: number;
+
+  constructor(events: BaseEvent[] = [], delay: number = 0) {
+    super();
+    this.events = events;
+    this.delay = delay;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void }
+  ): Promise<void> {
+    for (const event of this.events) {
+      if (this.delay > 0) {
+        await new Promise((resolve) => setTimeout(resolve, this.delay));
+      }
+      options.onEvent({ event });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new MockAgent(this.events, this.delay);
+  }
+}
+
+class DelayedEventAgent extends AbstractAgent {
+  private eventCount: number;
+  private eventDelay: number;
+  private prefix: string;
+
+  constructor(eventCount: number = 5, eventDelay: number = 10, prefix: string = "delayed") {
+    super();
+    this.eventCount = eventCount;
+    this.eventDelay = eventDelay;
+    this.prefix = prefix;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void }
+  ): Promise<void> {
+    for (let i = 0; i < this.eventCount; i++) {
+      await new Promise((resolve) => setTimeout(resolve, this.eventDelay));
+      options.onEvent({
+        event: {
+          type: "message",
+          id: `${this.prefix}-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i, prefix: this.prefix }
+        } as BaseEvent
+      });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new DelayedEventAgent(this.eventCount, this.eventDelay, this.prefix);
+  }
+}
+
+class ErrorThrowingAgent extends AbstractAgent {
+  private throwAfterEvents: number;
+  private errorMessage: string;
+
+  constructor(throwAfterEvents: number = 2, errorMessage: string = "Test error") {
+    super();
+    this.throwAfterEvents = throwAfterEvents;
+    this.errorMessage = errorMessage;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void }
+  ): Promise<void> {
+    for (let i = 0; i < this.throwAfterEvents; i++) {
+      options.onEvent({
+        event: {
+          type: "message",
+          id: `error-agent-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i }
+        } as BaseEvent
+      });
+    }
+    throw new Error(this.errorMessage);
+  }
+
+  clone(): AbstractAgent {
+    return new ErrorThrowingAgent(this.throwAfterEvents, this.errorMessage);
+  }
+}
+
+class MultiEventAgent extends AbstractAgent {
+  private runId: string;
+
+  constructor(runId: string) {
+    super();
+    this.runId = runId;
+  }
+
+  async runAgent(
+    input: RunAgentInput,
+    options: { onEvent: (event: { event: BaseEvent }) => void }
+  ): Promise<void> {
+    // Emit different types of events
+    const eventTypes = ["start", "message", "tool_call", "tool_result", "end"];
+    
+    for (const eventType of eventTypes) {
+      options.onEvent({
+        event: {
+          type: eventType,
+          id: `${this.runId}-${eventType}`,
+          timestamp: new Date().toISOString(),
+          data: { 
+            runId: this.runId,
+            eventType,
+            metadata: { source: "MultiEventAgent" }
+          }
+        } as BaseEvent
+      });
+    }
+  }
+
+  clone(): AbstractAgent {
+    return new MultiEventAgent(this.runId);
+  }
+}
+
+describe("InMemoryAgentRunner", () => {
+  let runner: InMemoryAgentRunner;
+
+  beforeEach(() => {
+    runner = new InMemoryAgentRunner();
+  });
+
+  describe("Basic Functionality", () => {
+    it("should run a single agent and collect all events", async () => {
+      const threadId = "test-thread-1";
+      const events: BaseEvent[] = [
+        { type: "start", id: "1", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+        { type: "message", id: "2", timestamp: new Date().toISOString(), data: { text: "Hello" } } as BaseEvent,
+        { type: "end", id: "3", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ];
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const runObservable = runner.run({ threadId, agent, input });
+      const collectedEvents = await firstValueFrom(runObservable.pipe(toArray()));
+
+      expect(collectedEvents).toHaveLength(3);
+      expect(collectedEvents).toEqual(events);
+    });
+
+    it("should allow connecting after run completes and receive all past events", async () => {
+      const threadId = "test-thread-3";
+      const events: BaseEvent[] = [
+        { type: "message", id: "past-1", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+        { type: "message", id: "past-2", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ];
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-3",
+      };
+
+      // Run and wait for completion
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Connect after completion
+      const connectObservable = runner.connect({ threadId });
+      const collectedEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      expect(collectedEvents).toHaveLength(2);
+      expect(collectedEvents).toEqual(events);
+    });
+  });
+
+  describe("Multiple Runs", () => {
+    it("should accumulate events from multiple sequential runs on same thread", async () => {
+      const threadId = "test-thread-multi-1";
+      
+      // First run
+      const agent1 = new MultiEventAgent("run-1");
+      const input1: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const run1 = runner.run({ threadId, agent: agent1, input: input1 });
+      await firstValueFrom(run1.pipe(toArray()));
+
+      // Second run
+      const agent2 = new MultiEventAgent("run-2");
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-2",
+      };
+
+      const run2 = runner.run({ threadId, agent: agent2, input: input2 });
+      await firstValueFrom(run2.pipe(toArray()));
+
+      // Third run
+      const agent3 = new MultiEventAgent("run-3");
+      const input3: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-3",
+      };
+
+      const run3 = runner.run({ threadId, agent: agent3, input: input3 });
+      await firstValueFrom(run3.pipe(toArray()));
+
+      // Connect and verify all events
+      const connectObservable = runner.connect({ threadId });
+      const allEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      expect(allEvents).toHaveLength(15); // 5 events per run × 3 runs
+      
+      // Verify events from all runs are present
+      const run1Events = allEvents.filter(e => e.id?.startsWith("run-1"));
+      const run2Events = allEvents.filter(e => e.id?.startsWith("run-2"));
+      const run3Events = allEvents.filter(e => e.id?.startsWith("run-3"));
+
+      expect(run1Events).toHaveLength(5);
+      expect(run2Events).toHaveLength(5);
+      expect(run3Events).toHaveLength(5);
+
+      // Verify order preservation
+      const runOrder = allEvents.map(e => e.id?.split("-")[0] + "-" + e.id?.split("-")[1]);
+      expect(runOrder.slice(0, 5).every(id => id.startsWith("run-1"))).toBe(true);
+      expect(runOrder.slice(5, 10).every(id => id.startsWith("run-2"))).toBe(true);
+      expect(runOrder.slice(10, 15).every(id => id.startsWith("run-3"))).toBe(true);
+    });
+
+    it("should handle connect during multiple runs", async () => {
+      const threadId = "test-thread-multi-2";
+      
+      // Start first run
+      const agent1 = new DelayedEventAgent(5, 20, "first");
+      const input1: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      const run1Observable = runner.run({ threadId, agent: agent1, input: input1 });
+
+      // Wait a bit to ensure first run is in progress
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Connect during first run
+      const connectObservable = runner.connect({ threadId });
+      const eventCollector = firstValueFrom(connectObservable.pipe(toArray()));
+
+      // Wait for first run to complete
+      await firstValueFrom(run1Observable.pipe(toArray()));
+
+      // Collect all events from the connect during first run
+      const allEvents = await eventCollector;
+
+      // Connect only receives events from the first run since it completes
+      expect(allEvents).toHaveLength(5); // Only events from first run
+      const firstRunEvents = allEvents.filter(e => e.id?.startsWith("first"));
+
+      expect(firstRunEvents).toHaveLength(5);
+
+      // Start second run
+      const agent2 = new DelayedEventAgent(3, 10, "second");
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-2",
+      };
+
+      const run2Observable = runner.run({ threadId, agent: agent2, input: input2 });
+      await firstValueFrom(run2Observable.pipe(toArray()));
+
+      // Connect after both runs to verify all events are accumulated
+      const allEventsAfter = await firstValueFrom(runner.connect({ threadId }).pipe(toArray()));
+      expect(allEventsAfter).toHaveLength(8); // 5 from first + 3 from second
+    });
+
+    it("should preserve event order across different agent types", async () => {
+      const threadId = "test-thread-multi-3";
+      
+      // Run different types of agents
+      const agents = [
+        new MockAgent([
+          { type: "mock", id: "mock-1", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+          { type: "mock", id: "mock-2", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+        ]),
+        new MultiEventAgent("multi"),
+        new DelayedEventAgent(2, 0, "delayed"),
+      ];
+
+      for (let i = 0; i < agents.length; i++) {
+        const input: RunAgentInput = {
+          messages: [],
+          state: {},
+          threadId,
+          runId: `run-${i}`,
+        };
+
+        const run = runner.run({ threadId, agent: agents[i], input });
+        await firstValueFrom(run.pipe(toArray()));
+      }
+
+      // Verify all events are preserved
+      const connectObservable = runner.connect({ threadId });
+      const allEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      expect(allEvents).toHaveLength(9); // 2 + 5 + 2
+      
+      // Verify event groups are in order
+      expect(allEvents[0].id).toBe("mock-1");
+      expect(allEvents[1].id).toBe("mock-2");
+      expect(allEvents[2].id).toContain("multi");
+      expect(allEvents[7].id).toContain("delayed");
+    });
+  });
+
+  describe("Concurrent Subscribers", () => {
+    it("should provide same events to multiple concurrent connect calls", async () => {
+      const threadId = "test-thread-concurrent-1";
+      const agent = new MultiEventAgent("concurrent");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-concurrent",
+      };
+
+      // Run agent
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Multiple concurrent connects
+      const connect1 = runner.connect({ threadId });
+      const connect2 = runner.connect({ threadId });
+      const connect3 = runner.connect({ threadId });
+
+      const [events1, events2, events3] = await Promise.all([
+        firstValueFrom(connect1.pipe(toArray())),
+        firstValueFrom(connect2.pipe(toArray())),
+        firstValueFrom(connect3.pipe(toArray())),
+      ]);
+
+      // All should receive same events
+      expect(events1).toHaveLength(5);
+      expect(events2).toHaveLength(5);
+      expect(events3).toHaveLength(5);
+      expect(events1).toEqual(events2);
+      expect(events2).toEqual(events3);
+    });
+
+    it("should handle late subscribers during active run", async () => {
+      const threadId = "test-thread-concurrent-2";
+      const agent = new DelayedEventAgent(10, 20, "late-sub");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-late",
+      };
+
+      // Start run
+      runner.run({ threadId, agent, input });
+
+      // Connect at different times during the run
+      await new Promise(resolve => setTimeout(resolve, 50)); // After ~2 events
+      const connect1 = runner.connect({ threadId });
+      
+      await new Promise(resolve => setTimeout(resolve, 60)); // After ~5 events
+      const connect2 = runner.connect({ threadId });
+
+      await new Promise(resolve => setTimeout(resolve, 80)); // After ~9 events
+      const connect3 = runner.connect({ threadId });
+
+      const [events1, events2, events3] = await Promise.all([
+        firstValueFrom(connect1.pipe(toArray())),
+        firstValueFrom(connect2.pipe(toArray())),
+        firstValueFrom(connect3.pipe(toArray())),
+      ]);
+
+      // All subscribers should eventually receive all events
+      expect(events1).toHaveLength(10);
+      expect(events2).toHaveLength(10);
+      expect(events3).toHaveLength(10);
+
+      // Verify they all have the same events
+      expect(events1.map(e => e.id)).toEqual(events2.map(e => e.id));
+      expect(events2.map(e => e.id)).toEqual(events3.map(e => e.id));
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should throw error when thread is already running", async () => {
+      const threadId = "test-thread-error-1";
+      const agent = new DelayedEventAgent(5, 50, "blocking");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-1",
+      };
+
+      // Start first run
+      runner.run({ threadId, agent, input });
+
+      // Try to start another run on same thread immediately
+      expect(() => {
+        runner.run({ threadId, agent, input });
+      }).toThrow("Thread already running");
+    });
+
+    it("should handle agent errors gracefully", async () => {
+      const threadId = "test-thread-error-2";
+      const agent = new ErrorThrowingAgent(3, "Agent crashed!");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-error-1",
+      };
+
+      const runObservable = runner.run({ threadId, agent, input });
+      const events = await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Should still receive events emitted before error
+      expect(events).toHaveLength(3);
+      expect(events.every(e => e.id?.startsWith("error-agent"))).toBe(true);
+
+      // Should be able to run again after error
+      const agent2 = new MockAgent([
+        { type: "recovery", id: "recovery-1", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ]);
+
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-error-2",
+      };
+
+      const run2 = runner.run({ threadId, agent: agent2, input: input2 });
+      const events2 = await firstValueFrom(run2.pipe(toArray()));
+
+      expect(events2).toHaveLength(1); // Only events from current run
+      expect(events2[0].id).toBe("recovery-1");
+
+      // Connect should have all events including from errored run
+      const allEvents = await firstValueFrom(runner.connect({ threadId }).pipe(toArray()));
+      expect(allEvents).toHaveLength(4); // 3 from error run + 1 from recovery
+    });
+
+    it("should properly set isRunning to false after agent error", async () => {
+      const threadId = "test-thread-error-3";
+      const agent = new ErrorThrowingAgent(1, "Quick fail");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-fail",
+      };
+
+      // Run and wait for completion (even with error)
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+      
+      // Verify thread is not running
+      const isRunning = await runner.isRunning({ threadId });
+      expect(isRunning).toBe(false);
+
+      // Should be able to run again
+      const agent2 = new MockAgent([
+        { type: "test", id: "after-error", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ]);
+
+      const input2: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-fail-2",
+      };
+
+      expect(() => {
+        runner.run({ threadId, agent: agent2, input: input2 });
+      }).not.toThrow();
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should return EMPTY observable when connecting to non-existent thread", async () => {
+      const connectObservable = runner.connect({ threadId: "non-existent-thread" });
+      
+      // EMPTY completes immediately with no values
+      let completed = false;
+      let eventCount = 0;
+      
+      await new Promise<void>((resolve) => {
+        connectObservable.subscribe({
+          next: () => eventCount++,
+          complete: () => {
+            completed = true;
+            resolve();
+          }
+        });
+      });
+
+      expect(completed).toBe(true);
+      expect(eventCount).toBe(0);
+    });
+
+    it("should handle very large number of events", async () => {
+      const threadId = "test-thread-large";
+      const eventCount = 1000;
+      const events: BaseEvent[] = [];
+
+      for (let i = 0; i < eventCount; i++) {
+        events.push({
+          type: "bulk",
+          id: `bulk-${i}`,
+          timestamp: new Date().toISOString(),
+          data: { index: i, payload: "x".repeat(100) }
+        } as BaseEvent);
+      }
+
+      const agent = new MockAgent(events);
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-large",
+      };
+
+      // Run with large event set
+      const runObservable = runner.run({ threadId, agent, input });
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Connect and verify all events are preserved
+      const connectObservable = runner.connect({ threadId });
+      const collectedEvents = await firstValueFrom(connectObservable.pipe(toArray()));
+
+      expect(collectedEvents).toHaveLength(eventCount);
+      expect(collectedEvents[0].id).toBe("bulk-0");
+      expect(collectedEvents[eventCount - 1].id).toBe(`bulk-${eventCount - 1}`);
+    });
+
+    it("should return false for isRunning on non-existent thread", async () => {
+      const isRunning = await runner.isRunning({ threadId: "non-existent" });
+      expect(isRunning).toBe(false);
+    });
+
+    it("should properly track isRunning state", async () => {
+      const threadId = "test-thread-running";
+      const agent = new DelayedEventAgent(5, 20, "running");
+      const input: RunAgentInput = {
+        messages: [],
+        state: {},
+        threadId,
+        runId: "run-running",
+      };
+
+      // Check before run
+      expect(await runner.isRunning({ threadId })).toBe(false);
+
+      // Start run
+      const runObservable = runner.run({ threadId, agent, input });
+
+      // Check during run
+      expect(await runner.isRunning({ threadId })).toBe(true);
+
+      // Wait for completion
+      await firstValueFrom(runObservable.pipe(toArray()));
+
+      // Check after run
+      expect(await runner.isRunning({ threadId })).toBe(false);
+    });
+
+    it("should throw error for stop method (not implemented)", async () => {
+      expect(() => {
+        runner.stop({ threadId: "any-thread" });
+      }).toThrow("Method not implemented");
+    });
+
+    it("should handle thread isolation correctly", async () => {
+      const thread1 = "test-thread-iso-1";
+      const thread2 = "test-thread-iso-2";
+
+      const agent1 = new MockAgent([
+        { type: "thread1", id: "t1-event", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ]);
+      const agent2 = new MockAgent([
+        { type: "thread2", id: "t2-event", timestamp: new Date().toISOString(), data: {} } as BaseEvent,
+      ]);
+
+      // Run on different threads
+      const run1 = runner.run({
+        threadId: thread1,
+        agent: agent1,
+        input: { messages: [], state: {}, threadId: thread1, runId: "run-t1" }
+      });
+      const run2 = runner.run({
+        threadId: thread2,
+        agent: agent2,
+        input: { messages: [], state: {}, threadId: thread2, runId: "run-t2" }
+      });
+
+      await Promise.all([
+        firstValueFrom(run1.pipe(toArray())),
+        firstValueFrom(run2.pipe(toArray()))
+      ]);
+
+      // Connect to each thread
+      const events1 = await firstValueFrom(runner.connect({ threadId: thread1 }).pipe(toArray()));
+      const events2 = await firstValueFrom(runner.connect({ threadId: thread2 }).pipe(toArray()));
+
+      // Verify isolation
+      expect(events1).toHaveLength(1);
+      expect(events1[0].id).toBe("t1-event");
+
+      expect(events2).toHaveLength(1);
+      expect(events2[0].id).toBe("t2-event");
+    });
+  });
+
+  describe("Complex Scenarios", () => {
+    it("should handle rapid sequential runs with mixed event patterns", async () => {
+      const threadId = "test-thread-complex-1";
+      const runs = [
+        { agent: new MockAgent([{ type: "instant", id: "instant-1", timestamp: new Date().toISOString(), data: {} } as BaseEvent]), runId: "run-1" },
+        { agent: new DelayedEventAgent(3, 5, "delayed"), runId: "run-2" },
+        { agent: new MockAgent([{ type: "instant", id: "instant-2", timestamp: new Date().toISOString(), data: {} } as BaseEvent]), runId: "run-3" },
+        { agent: new MultiEventAgent("multi"), runId: "run-4" },
+        { agent: new DelayedEventAgent(2, 10, "slow"), runId: "run-5" },
+      ];
+
+      for (const { agent, runId } of runs) {
+        const input: RunAgentInput = {
+          messages: [],
+          state: {},
+          threadId,
+          runId,
+        };
+
+        const run = runner.run({ threadId, agent, input });
+        await firstValueFrom(run.pipe(toArray()));
+      }
+
+      const allEvents = await firstValueFrom(runner.connect({ threadId }).pipe(toArray()));
+      
+      expect(allEvents).toHaveLength(12); // 1 + 3 + 1 + 5 + 2
+      
+      // Verify event ordering
+      expect(allEvents[0].id).toBe("instant-1");
+      expect(allEvents[1].id).toContain("delayed-0");
+      expect(allEvents[4].id).toBe("instant-2");
+      expect(allEvents[5].id).toContain("multi-start");
+      expect(allEvents[10].id).toContain("slow-0");
+    });
+
+    it("should handle subscriber that connects between runs", async () => {
+      const threadId = "test-thread-complex-2";
+      
+      // First run
+      const agent1 = new MultiEventAgent("first");
+      const run1 = runner.run({
+        threadId,
+        agent: agent1,
+        input: { messages: [], state: {}, threadId, runId: "run-1" }
+      });
+      await firstValueFrom(run1.pipe(toArray()));
+
+      // Connect after first run - should only get first run events
+      const midConnectObservable = runner.connect({ threadId });
+      const midEvents = await firstValueFrom(midConnectObservable.pipe(toArray()));
+
+      expect(midEvents).toHaveLength(5); // Only events from first run
+      const firstRunEvents = midEvents.filter(e => e.id?.includes("first"));
+      expect(firstRunEvents).toHaveLength(5);
+      
+      // Second run
+      const agent2 = new MultiEventAgent("second");
+      const run2 = runner.run({
+        threadId,
+        agent: agent2,
+        input: { messages: [], state: {}, threadId, runId: "run-2" }
+      });
+      await firstValueFrom(run2.pipe(toArray()));
+
+      // Connect after both runs to verify all events
+      const allEvents = await firstValueFrom(runner.connect({ threadId }).pipe(toArray()));
+      expect(allEvents).toHaveLength(10); // Events from both runs
+      
+      const allFirstRunEvents = allEvents.filter(e => e.id?.includes("first"));
+      const allSecondRunEvents = allEvents.filter(e => e.id?.includes("second"));
+      expect(allFirstRunEvents).toHaveLength(5);
+      expect(allSecondRunEvents).toHaveLength(5);
+    });
+  });
+});