@copilotkitnext/runtime 0.0.2 → 0.0.4

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

@@ -1,726 +0,0 @@
-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);
-    });
-  });
-});