@mastra/upstash 0.2.2-alpha.1 → 0.2.2-alpha.3

package/src/storage/upstash.test.ts

@@ -1,4 +1,9 @@
-import { MastraStorage } from '@mastra/core/storage';
+import { randomUUID } from 'crypto';
+import type { MetricResult, TestInfo } from '@mastra/core/eval';
+import type { MessageType } from '@mastra/core/memory';
+import type { TABLE_NAMES } from '@mastra/core/storage';
+import { TABLE_MESSAGES, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS } from '@mastra/core/storage';
+import type { WorkflowRunState } from '@mastra/core/workflows';
 import { describe, it, expect, beforeAll, beforeEach, afterAll, vi } from 'vitest';
 
 import { UpstashStore } from './index';
@@ -6,6 +11,67 @@ import { UpstashStore } from './index';
 // Increase timeout for all tests in this file to 30 seconds
 vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
 
+const createSampleThread = (date?: Date) => ({
+  id: `thread-${randomUUID()}`,
+  resourceId: `resource-${randomUUID()}`,
+  title: 'Test Thread',
+  createdAt: date || new Date(),
+  updatedAt: date || new Date(),
+  metadata: { key: 'value' },
+});
+
+const createSampleMessage = (threadId: string, content: string = 'Hello') =>
+  ({
+    id: `msg-${randomUUID()}`,
+    role: 'user',
+    type: 'text',
+    threadId,
+    content: [{ type: 'text', text: content }],
+    createdAt: new Date(),
+  }) as any;
+
+const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
+  const runId = `run-${randomUUID()}`;
+  const stepId = `step-${randomUUID()}`;
+  const timestamp = createdAt || new Date();
+  const snapshot = {
+    result: { success: true },
+    value: {},
+    context: {
+      steps: {
+        [stepId]: {
+          status,
+          payload: {},
+          error: undefined,
+        },
+      },
+      triggerData: {},
+      attempts: {},
+    },
+    activePaths: [],
+    runId,
+    timestamp: timestamp.getTime(),
+  } as WorkflowRunState;
+  return { snapshot, runId, stepId };
+};
+
+const createSampleEval = (agentName: string, isTest = false) => {
+  const testInfo = isTest ? { testPath: 'test/path.ts', testName: 'Test Name' } : undefined;
+
+  return {
+    agent_name: agentName,
+    input: 'Sample input',
+    output: 'Sample output',
+    result: JSON.stringify({ score: 0.8 }),
+    metric_name: 'sample-metric',
+    instructions: 'Sample instructions',
+    test_info: testInfo ? JSON.stringify(testInfo) : undefined,
+    global_run_id: `global-${randomUUID()}`,
+    run_id: `run-${randomUUID()}`,
+    created_at: new Date().toISOString(),
+  };
+};
+
 describe('UpstashStore', () => {
   let store: UpstashStore;
   const testTableName = 'test_table';
@@ -26,16 +92,18 @@ describe('UpstashStore', () => {
 
   afterAll(async () => {
     // Clean up test tables
-    await store.clearTable({ tableName: testTableName });
-    await store.clearTable({ tableName: testTableName2 });
-    await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
-    await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
+    await store.clearTable({ tableName: testTableName as TABLE_NAMES });
+    await store.clearTable({ tableName: testTableName2 as TABLE_NAMES });
+    await store.clearTable({ tableName: TABLE_THREADS });
+    await store.clearTable({ tableName: TABLE_MESSAGES });
+    await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+    await store.clearTable({ tableName: TABLE_EVALS });
   });
 
   describe('Table Operations', () => {
     it('should create a new table with schema', async () => {
       await store.createTable({
-        tableName: testTableName,
+        tableName: testTableName as TABLE_NAMES,
         schema: {
           id: { type: 'text', primaryKey: true },
           data: { type: 'text', nullable: true },
@@ -44,17 +112,17 @@ describe('UpstashStore', () => {
 
       // Verify table exists by inserting and retrieving data
       await store.insert({
-        tableName: testTableName,
+        tableName: testTableName as TABLE_NAMES,
         record: { id: 'test1', data: 'test-data' },
       });
 
-      const result = await store.load({ tableName: testTableName, keys: { id: 'test1' } });
+      const result = await store.load({ tableName: testTableName as TABLE_NAMES, keys: { id: 'test1' } });
       expect(result).toBeTruthy();
     });
 
     it('should handle multiple table creation', async () => {
       await store.createTable({
-        tableName: testTableName2,
+        tableName: testTableName2 as TABLE_NAMES,
         schema: {
           id: { type: 'text', primaryKey: true },
           data: { type: 'text', nullable: true },
@@ -63,35 +131,28 @@ describe('UpstashStore', () => {
 
       // Verify both tables work independently
       await store.insert({
-        tableName: testTableName2,
+        tableName: testTableName2 as TABLE_NAMES,
         record: { id: 'test2', data: 'test-data-2' },
       });
 
-      const result = await store.load({ tableName: testTableName2, keys: { id: 'test2' } });
+      const result = await store.load({ tableName: testTableName2 as TABLE_NAMES, keys: { id: 'test2' } });
       expect(result).toBeTruthy();
     });
   });
 
   describe('Thread Operations', () => {
     beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      await store.clearTable({ tableName: TABLE_THREADS });
     });
 
     it('should create and retrieve a thread', async () => {
       const now = new Date();
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now,
-        metadata: { key: 'value' },
-      };
-
-      const savedThread = await store.saveThread({ thread });
+      const thread = createSampleThread(now);
+
+      const savedThread = await store.__saveThread({ thread });
       expect(savedThread).toEqual(thread);
 
-      const retrievedThread = await store.getThreadById({ threadId: thread.id });
+      const retrievedThread = await store.__getThreadById({ threadId: thread.id });
       expect(retrievedThread).toEqual({
         ...thread,
         createdAt: new Date(now.toISOString()),
@@ -105,46 +166,26 @@ describe('UpstashStore', () => {
     });
 
     it('should get threads by resource ID', async () => {
-      const resourceId = 'resource-1';
-      const threads = [
-        {
-          id: 'thread-1',
-          resourceId,
-          title: 'Thread 1',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          metadata: {},
-        },
-        {
-          id: 'thread-2',
-          resourceId,
-          title: 'Thread 2',
-          createdAt: new Date(),
-          updatedAt: new Date(),
-          metadata: {},
-        },
-      ];
+      const thread1 = createSampleThread();
+      const thread2 = { ...createSampleThread(), resourceId: thread1.resourceId };
+      const threads = [thread1, thread2];
+
+      const resourceId = threads[0].resourceId;
+      const threadIds = threads.map(t => t.id);
 
       await Promise.all(threads.map(thread => store.saveThread({ thread })));
 
       const retrievedThreads = await store.getThreadsByResourceId({ resourceId });
       expect(retrievedThreads).toHaveLength(2);
-      expect(retrievedThreads.map(t => t.id)).toEqual(expect.arrayContaining(['thread-1', 'thread-2']));
+      expect(retrievedThreads.map(t => t.id)).toEqual(expect.arrayContaining(threadIds));
     });
 
     it('should update thread metadata', async () => {
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        metadata: { initial: 'value' },
-      };
+      const thread = createSampleThread();
 
       await store.saveThread({ thread });
 
-      const updatedThread = await store.updateThread({
+      const updatedThread = await store.__updateThread({
         id: thread.id,
         title: 'Updated Title',
         metadata: { updated: 'value' },
@@ -152,7 +193,7 @@ describe('UpstashStore', () => {
 
       expect(updatedThread.title).toBe('Updated Title');
       expect(updatedThread.metadata).toEqual({
-        initial: 'value',
+        key: 'value',
         updated: 'value',
       });
     });
@@ -160,19 +201,12 @@ describe('UpstashStore', () => {
 
   describe('Date Handling', () => {
     beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      await store.clearTable({ tableName: TABLE_THREADS });
     });
 
     it('should handle Date objects in thread operations', async () => {
       const now = new Date();
-      const thread = {
-        id: 'thread-1',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now,
-        metadata: {},
-      };
+      const thread = createSampleThread(now);
 
       await store.saveThread({ thread });
       const retrievedThread = await store.getThreadById({ threadId: thread.id });
@@ -184,16 +218,9 @@ describe('UpstashStore', () => {
 
     it('should handle ISO string dates in thread operations', async () => {
       const now = new Date();
-      const thread = {
-        id: 'thread-2',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now.toISOString(),
-        updatedAt: now.toISOString(),
-        metadata: {},
-      };
-
-      await store.saveThread({ thread: thread as any });
+      const thread = createSampleThread(now);
+
+      await store.saveThread({ thread });
       const retrievedThread = await store.getThreadById({ threadId: thread.id });
       expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
       expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
@@ -203,16 +230,9 @@ describe('UpstashStore', () => {
 
     it('should handle mixed date formats in thread operations', async () => {
       const now = new Date();
-      const thread = {
-        id: 'thread-3',
-        resourceId: 'resource-1',
-        title: 'Test Thread',
-        createdAt: now,
-        updatedAt: now.toISOString(),
-        metadata: {},
-      };
-
-      await store.saveThread({ thread: thread as any });
+      const thread = createSampleThread(now);
+
+      await store.saveThread({ thread });
       const retrievedThread = await store.getThreadById({ threadId: thread.id });
       expect(retrievedThread?.createdAt).toBeInstanceOf(Date);
       expect(retrievedThread?.updatedAt).toBeInstanceOf(Date);
@@ -222,28 +242,13 @@ describe('UpstashStore', () => {
 
     it('should handle date serialization in getThreadsByResourceId', async () => {
       const now = new Date();
-      const threads = [
-        {
-          id: 'thread-1',
-          resourceId: 'resource-1',
-          title: 'Thread 1',
-          createdAt: now,
-          updatedAt: now.toISOString(),
-          metadata: {},
-        },
-        {
-          id: 'thread-2',
-          resourceId: 'resource-1',
-          title: 'Thread 2',
-          createdAt: now.toISOString(),
-          updatedAt: now,
-          metadata: {},
-        },
-      ];
+      const thread1 = createSampleThread(now);
+      const thread2 = { ...createSampleThread(now), resourceId: thread1.resourceId };
+      const threads = [thread1, thread2];
 
-      await Promise.all(threads.map(thread => store.saveThread({ thread: thread as any })));
+      await Promise.all(threads.map(thread => store.saveThread({ thread })));
 
-      const retrievedThreads = await store.getThreadsByResourceId({ resourceId: 'resource-1' });
+      const retrievedThreads = await store.getThreadsByResourceId({ resourceId: threads[0].resourceId });
       expect(retrievedThreads).toHaveLength(2);
       retrievedThreads.forEach(thread => {
         expect(thread.createdAt).toBeInstanceOf(Date);
@@ -258,11 +263,11 @@ describe('UpstashStore', () => {
     const threadId = 'test-thread';
 
     beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_MESSAGES });
-      await store.clearTable({ tableName: MastraStorage.TABLE_THREADS });
+      await store.clearTable({ tableName: TABLE_MESSAGES });
+      await store.clearTable({ tableName: TABLE_THREADS });
 
       // Create a test thread
-      await store.saveThread({
+      await store.__saveThread({
         thread: {
           id: threadId,
           resourceId: 'resource-1',
@@ -276,41 +281,20 @@ describe('UpstashStore', () => {
 
     it('should save and retrieve messages in order', async () => {
       const messages = [
-        {
-          id: 'msg-1',
-          threadId,
-          role: 'user',
-          type: 'text',
-          content: [{ type: 'text', text: 'First' }],
-          createdAt: new Date().toISOString(),
-        },
-        {
-          id: 'msg-2',
-          threadId,
-          role: 'assistant',
-          type: 'text',
-          content: [{ type: 'text', text: 'Second' }],
-          createdAt: new Date().toISOString(),
-        },
-        {
-          id: 'msg-3',
-          threadId,
-          role: 'user',
-          type: 'text',
-          content: [{ type: 'text', text: 'Third' }],
-          createdAt: new Date().toISOString(),
-        },
+        createSampleMessage(threadId, 'First'),
+        createSampleMessage(threadId, 'Second'),
+        createSampleMessage(threadId, 'Third'),
       ];
 
-      await store.saveMessages({ messages });
+      await store.__saveMessages({ messages: messages as MessageType[] });
 
-      const retrievedMessages = await store.getMessages({ threadId });
+      const retrievedMessages = await store.__getMessages({ threadId });
       expect(retrievedMessages).toHaveLength(3);
       expect(retrievedMessages.map(m => m.content[0].text)).toEqual(['First', 'Second', 'Third']);
     });
 
     it('should handle empty message array', async () => {
-      const result = await store.saveMessages({ messages: [] });
+      const result = await store.__saveMessages({ messages: [] });
       expect(result).toEqual([]);
     });
 
@@ -326,13 +310,13 @@ describe('UpstashStore', () => {
             { type: 'code', text: 'code block', language: 'typescript' },
             { type: 'text', text: 'and more text' },
           ],
-          createdAt: new Date().toISOString(),
+          createdAt: new Date(),
         },
       ];
 
-      await store.saveMessages({ messages });
+      await store.__saveMessages({ messages: messages as MessageType[] });
 
-      const retrievedMessages = await store.getMessages({ threadId });
+      const retrievedMessages = await store.__getMessages({ threadId });
       expect(retrievedMessages[0].content).toEqual(messages[0].content);
     });
   });
@@ -343,7 +327,7 @@ describe('UpstashStore', () => {
     const testRunId = 'test-run';
 
     beforeEach(async () => {
-      await store.clearTable({ tableName: MastraStorage.TABLE_WORKFLOW_SNAPSHOT });
+      await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
     });
 
     it('should persist and load workflow snapshots', async () => {
@@ -359,7 +343,7 @@ describe('UpstashStore', () => {
         runId: testRunId,
         activePaths: [],
         timestamp: Date.now(),
-      };
+      } as unknown as WorkflowRunState;
 
       await store.persistWorkflowSnapshot({
         namespace: testNamespace,
@@ -386,4 +370,252 @@ describe('UpstashStore', () => {
       expect(result).toBeNull();
     });
   });
+
+  describe('Eval Operations', () => {
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TABLE_EVALS });
+    });
+
+    it('should retrieve evals by agent name', async () => {
+      const agentName = `test-agent-${randomUUID()}`;
+
+      // Create sample evals
+      const liveEval = createSampleEval(agentName, false);
+      const testEval = createSampleEval(agentName, true);
+      const otherAgentEval = createSampleEval(`other-agent-${randomUUID()}`, false);
+
+      // Insert evals
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: liveEval,
+      });
+
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: testEval,
+      });
+
+      await store.insert({
+        tableName: TABLE_EVALS,
+        record: otherAgentEval,
+      });
+
+      // Test getting all evals for the agent
+      const allEvals = await store.getEvalsByAgentName(agentName);
+      expect(allEvals).toHaveLength(2);
+      expect(allEvals.map(e => e.runId)).toEqual(expect.arrayContaining([liveEval.run_id, testEval.run_id]));
+
+      // Test getting only live evals
+      const liveEvals = await store.getEvalsByAgentName(agentName, 'live');
+      expect(liveEvals).toHaveLength(1);
+      expect(liveEvals[0].runId).toBe(liveEval.run_id);
+
+      // Test getting only test evals
+      const testEvals = await store.getEvalsByAgentName(agentName, 'test');
+      expect(testEvals).toHaveLength(1);
+      expect(testEvals[0].runId).toBe(testEval.run_id);
+
+      // Verify the test_info was properly parsed
+      if (testEval.test_info) {
+        const expectedTestInfo = JSON.parse(testEval.test_info);
+        expect(testEvals[0].testInfo).toEqual(expectedTestInfo);
+      }
+
+      // Test getting evals for non-existent agent
+      const nonExistentEvals = await store.getEvalsByAgentName('non-existent-agent');
+      expect(nonExistentEvals).toHaveLength(0);
+    });
+  });
+
+  describe('getWorkflowRuns', () => {
+    const testNamespace = 'test-namespace';
+    beforeEach(async () => {
+      await store.clearTable({ tableName: TABLE_WORKFLOW_SNAPSHOT });
+    });
+    it('returns empty array when no workflows exist', async () => {
+      const { runs, total } = await store.__getWorkflowRuns();
+      expect(runs).toEqual([]);
+      expect(total).toBe(0);
+    });
+
+    it('returns all workflows by default', async () => {
+      const workflowName1 = 'default_test_1';
+      const workflowName2 = 'default_test_2';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName1,
+        runId: runId1,
+        snapshot: workflow1,
+      });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName2,
+        runId: runId2,
+        snapshot: workflow2,
+      });
+
+      const { runs, total } = await store.__getWorkflowRuns({ namespace: testNamespace });
+      expect(runs).toHaveLength(2);
+      expect(total).toBe(2);
+      expect(runs[0]!.workflowName).toBe(workflowName2); // Most recent first
+      expect(runs[1]!.workflowName).toBe(workflowName1);
+      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId2]?.status).toBe('running');
+      expect(secondSnapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+
+    it('filters by workflow name', async () => {
+      const workflowName1 = 'filter_test_1';
+      const workflowName2 = 'filter_test_2';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2 } = createSampleWorkflowSnapshot('failed');
+
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName1,
+        runId: runId1,
+        snapshot: workflow1,
+      });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName2,
+        runId: runId2,
+        snapshot: workflow2,
+      });
+
+      const { runs, total } = await store.__getWorkflowRuns({ namespace: testNamespace, workflowName: workflowName1 });
+      expect(runs).toHaveLength(1);
+      expect(total).toBe(1);
+      expect(runs[0]!.workflowName).toBe(workflowName1);
+      const snapshot = runs[0]!.snapshot as WorkflowRunState;
+      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+
+    it('filters by date range', async () => {
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const twoDaysAgo = new Date(now.getTime() - 2 * 24 * 60 * 60 * 1000);
+      const workflowName1 = 'date_test_1';
+      const workflowName2 = 'date_test_2';
+      const workflowName3 = 'date_test_3';
+
+      const { snapshot: workflow1, runId: runId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace: testNamespace,
+          workflow_name: workflowName1,
+          run_id: runId1,
+          snapshot: workflow1,
+          createdAt: twoDaysAgo,
+          updatedAt: twoDaysAgo,
+        },
+      });
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace: testNamespace,
+          workflow_name: workflowName2,
+          run_id: runId2,
+          snapshot: workflow2,
+          createdAt: yesterday,
+          updatedAt: yesterday,
+        },
+      });
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace: testNamespace,
+          workflow_name: workflowName3,
+          run_id: runId3,
+          snapshot: workflow3,
+          createdAt: now,
+          updatedAt: now,
+        },
+      });
+
+      const { runs } = await store.__getWorkflowRuns({
+        namespace: testNamespace,
+        fromDate: yesterday,
+        toDate: now,
+      });
+
+      expect(runs).toHaveLength(2);
+      expect(runs[0]!.workflowName).toBe(workflowName3);
+      expect(runs[1]!.workflowName).toBe(workflowName2);
+      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
+      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+    });
+
+    it('handles pagination', async () => {
+      const workflowName1 = 'page_test_1';
+      const workflowName2 = 'page_test_2';
+      const workflowName3 = 'page_test_3';
+
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName1,
+        runId: runId1,
+        snapshot: workflow1,
+      });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName2,
+        runId: runId2,
+        snapshot: workflow2,
+      });
+      await new Promise(resolve => setTimeout(resolve, 10)); // Small delay to ensure different timestamps
+      await store.persistWorkflowSnapshot({
+        namespace: testNamespace,
+        workflowName: workflowName3,
+        runId: runId3,
+        snapshot: workflow3,
+      });
+
+      // Get first page
+      const page1 = await store.__getWorkflowRuns({
+        namespace: testNamespace,
+        limit: 2,
+        offset: 0,
+      });
+      expect(page1.runs).toHaveLength(2);
+      expect(page1.total).toBe(3); // Total count of all records
+      expect(page1.runs[0]!.workflowName).toBe(workflowName3);
+      expect(page1.runs[1]!.workflowName).toBe(workflowName2);
+      const firstSnapshot = page1.runs[0]!.snapshot as WorkflowRunState;
+      const secondSnapshot = page1.runs[1]!.snapshot as WorkflowRunState;
+      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
+      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+
+      // Get second page
+      const page2 = await store.__getWorkflowRuns({
+        namespace: testNamespace,
+        limit: 2,
+        offset: 2,
+      });
+      expect(page2.runs).toHaveLength(1);
+      expect(page2.total).toBe(3);
+      expect(page2.runs[0]!.workflowName).toBe(workflowName1);
+      const snapshot = page2.runs[0]!.snapshot as WorkflowRunState;
+      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+    });
+  });
 });