@forgehive/task 0.2.2 → 0.2.4

package/src/test/safe-replay-complex-boundary.test.ts

@@ -1,5 +1,5 @@
 import { Schema } from '@forgehive/schema'
-import { createTask, ExecutionRecord, getExecutionRecordType } from '../index'
+import { createTask, ExecutionRecord, getExecutionRecordType, BoundaryRecord } from '../index'
 
 describe('Complex boundary replay tests', () => {
   // Helper function to create ExecutionRecord with computed type
@@ -190,21 +190,41 @@ describe('Complex boundary replay tests', () => {
                 { ticker: 'MSFT', quantity: 5 },
                 { ticker: 'GOOGL', quantity: 8 }
               ]
+            },
+            timing: {
+              startTime: 1000,
+              endTime: 1100,
+              duration: 100
             }
           }
         ],
         fetchPrice: [
           {
             input: ['AAPL'],
-            output: 190.50
+            output: 190.50,
+            timing: {
+              startTime: 1100,
+              endTime: 1200,
+              duration: 100
+            }
           },
           {
             input: ['MSFT'],
-            output: 405.75
+            output: 405.75,
+            timing: {
+              startTime: 1200,
+              endTime: 1300,
+              duration: 100
+            }
           },
           {
             input: ['GOOGL'],
-            output: 161.16
+            output: 161.16,
+            timing: {
+              startTime: 1300,
+              endTime: 1400,
+              duration: 100
+            }
           }
         ]
       }
@@ -239,6 +259,22 @@ describe('Complex boundary replay tests', () => {
     // Verify that boundary calls were properly replayed
     expect(replayLog.boundaries.fetchPortfolio).toHaveLength(1)
     expect(replayLog.boundaries.fetchPrice).toHaveLength(3)
+
+    // Verify timing information is preserved
+    expect(replayLog.boundaries.fetchPortfolio[0]).toMatchObject({
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
+    expect(replayLog.boundaries.fetchPrice[0]).toMatchObject({
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
   })
 
   it('Should handle errors during replay', async () => {
@@ -258,21 +294,41 @@ describe('Complex boundary replay tests', () => {
                 { ticker: 'MSFT', quantity: 5 },
                 { ticker: 'GOOGL', quantity: 8 }
               ]
+            },
+            timing: {
+              startTime: 2000,
+              endTime: 2100,
+              duration: 100
             }
           }
         ],
         fetchPrice: [
           {
             input: ['AAPL'],
-            output: 190.50
+            output: 190.50,
+            timing: {
+              startTime: 2100,
+              endTime: 2200,
+              duration: 100
+            }
           },
           {
             input: ['MSFT'],
-            output: 405.75
+            output: 405.75,
+            timing: {
+              startTime: 2200,
+              endTime: 2300,
+              duration: 100
+            }
           },
           {
             input: ['GOOGL'],
-            error: 'Price data not available for ticker: GOOGL'
+            error: 'Price data not available for ticker: GOOGL',
+            timing: {
+              startTime: 2300,
+              endTime: 2350,
+              duration: 50
+            }
           }
         ]
       }
@@ -304,6 +360,15 @@ describe('Complex boundary replay tests', () => {
     )
     expect(googPriceCall).toBeDefined()
     expect(googPriceCall?.error).toBe('Price data not available for ticker: GOOGL')
+
+    // Verify timing information is preserved even with errors
+    expect(googPriceCall).toMatchObject({
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
   })
 
   it('Should support mixed replay with some boundaries in replay mode and others in proxy mode', async () => {
@@ -335,21 +400,41 @@ describe('Complex boundary replay tests', () => {
                 { ticker: 'MSFT', quantity: 5 },
                 { ticker: 'GOOGL', quantity: 8 }
               ]
+            },
+            timing: {
+              startTime: 3000,
+              endTime: 3100,
+              duration: 100
             }
           }
         ],
         fetchPrice: [
           {
             input: ['AAPL'],
-            output: 190.50
+            output: 190.50,
+            timing: {
+              startTime: 3100,
+              endTime: 3200,
+              duration: 100
+            }
           },
           {
             input: ['MSFT'],
-            output: 405.75
+            output: 405.75,
+            timing: {
+              startTime: 3200,
+              endTime: 3300,
+              duration: 100
+            }
           },
           {
             input: ['GOOGL'],
-            output: 161.16
+            output: 161.16,
+            timing: {
+              startTime: 3300,
+              endTime: 3400,
+              duration: 100
+            }
           }
         ]
       }
@@ -389,5 +474,25 @@ describe('Complex boundary replay tests', () => {
     // Verify the log shows the mixed sources correctly
     expect(replayLog.boundaries.fetchPortfolio).toHaveLength(1)
     expect(replayLog.boundaries.fetchPrice).toHaveLength(3)
+
+    // Verify timing information for mixed execution
+    expect(replayLog.boundaries.fetchPortfolio[0]).toMatchObject({
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
+
+    // All price fetches should have timing since they execute in proxy mode
+    replayLog.boundaries.fetchPrice.forEach((call: BoundaryRecord) => {
+      expect(call).toMatchObject({
+        timing: expect.objectContaining({
+          startTime: expect.any(Number),
+          endTime: expect.any(Number),
+          duration: expect.any(Number)
+        })
+      })
+    })
   })
 })

package/src/test/safe-replay.test.ts

@@ -72,7 +72,12 @@ describe('safeReplay functionality tests', () => {
         fetchData: [
           {
             input: ['AAPL'],
-            output: 160.23
+            output: 160.23,
+            timing: {
+              startTime: 1000,
+              endTime: 1100,
+              duration: 100
+            }
           }
         ]
       }
@@ -102,6 +107,11 @@ describe('safeReplay functionality tests', () => {
           {
             input: ['AAPL'],
             output: 150.23,
+            timing: expect.objectContaining({
+              startTime: expect.any(Number),
+              endTime: expect.any(Number),
+              duration: expect.any(Number)
+            })
           }
         ]
       }
@@ -120,7 +130,12 @@ describe('safeReplay functionality tests', () => {
         fetchData: [
           {
             input: ['AAPL'],
-            output: 160.23
+            output: 160.23,
+            timing: {
+              startTime: 1000,
+              endTime: 1100,
+              duration: 100
+            }
           }
         ]
       }
@@ -153,7 +168,12 @@ describe('safeReplay functionality tests', () => {
         fetchData: [
           {
             input: ['AAPL'],
-            output: 160.23
+            output: 160.23,
+            timing: expect.objectContaining({
+              startTime: expect.any(Number),
+              endTime: expect.any(Number),
+              duration: expect.any(Number)
+            })
           }
         ]
       }
@@ -170,7 +190,12 @@ describe('safeReplay functionality tests', () => {
         fetchData: [
           {
             input: ['AAPL'],
-            error: 'API error: Rate limit exceeded'
+            error: 'API error: Rate limit exceeded',
+            timing: {
+              startTime: 1000,
+              endTime: 1100,
+              duration: 100
+            }
           }
         ]
       }
@@ -206,7 +231,12 @@ describe('safeReplay functionality tests', () => {
           {
             input: ['AAPL'],
             output: 160.23,
-            error: null
+            error: null,
+            timing: {
+              startTime: 1000,
+              endTime: 1100,
+              duration: 100
+            }
           }
         ]
       }

package/src/test/safe-run.test.ts

@@ -40,6 +40,11 @@ describe('Task safeRun tests', () => {
     expect(data.input).toEqual([5])
     expect(data.output).toEqual(10)
     expect(data.error).toBeUndefined()
+    expect(data.timing).toEqual(expect.objectContaining({
+      startTime: expect.any(Number),
+      endTime: expect.any(Number),
+      duration: expect.any(Number)
+    }))
   })
 
   it('returns [null, error, record] on failed execution', async () => {
@@ -87,6 +92,11 @@ describe('Task safeRun tests', () => {
     expect(data.input).toEqual([-5])
     expect(data.error).toContain('Value cannot be negative')
     expect(data.output).toBeUndefined()
+    expect(data.timing).toEqual(expect.objectContaining({
+      startTime: expect.any(Number),
+      endTime: expect.any(Number),
+      duration: expect.any(Number)
+    }))
   })
 
   it('returns [null, error, record] on schema validation failure', async () => {
@@ -238,9 +248,41 @@ describe('Task safeRun tests', () => {
 
     expect(record.boundaries.doubleValue).toHaveLength(3)
     expect(record.boundaries.sumValues).toHaveLength(1)
-    expect(record.boundaries.doubleValue[0]).toEqual({ input: [1], output: 2 })
-    expect(record.boundaries.doubleValue[1]).toEqual({ input: [2], output: 4 })
-    expect(record.boundaries.doubleValue[2]).toEqual({ input: [3], output: 6 })
-    expect(record.boundaries.sumValues[0]).toEqual({ input: [[2, 4, 6]], output: 12 })
+    expect(record.boundaries.doubleValue[0]).toEqual({
+      input: [1],
+      output: 2,
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
+    expect(record.boundaries.doubleValue[1]).toEqual({
+      input: [2],
+      output: 4,
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
+    expect(record.boundaries.doubleValue[2]).toEqual({
+      input: [3],
+      output: 6,
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
+    expect(record.boundaries.sumValues[0]).toEqual({
+      input: [[2, 4, 6]],
+      output: 12,
+      timing: expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      })
+    })
   })
 })

package/src/test/setmetrics-boundary.test.ts

@@ -0,0 +1,223 @@
+import { createTask, type Metric, validateMetric, createMetric } from '../index'
+import { Schema } from '@forgehive/schema'
+
+describe('setMetrics boundary', () => {
+  describe('validateMetric function', () => {
+    it('should validate correct metrics', () => {
+      const validMetric: Metric = {
+        type: 'performance',
+        name: 'response_time',
+        value: 150
+      }
+
+      expect(validateMetric(validMetric)).toBe(true)
+    })
+
+    it('should reject invalid metrics', () => {
+      expect(validateMetric(null)).toBe(false)
+      expect(validateMetric(undefined)).toBe(false)
+      expect(validateMetric({})).toBe(false)
+      expect(validateMetric({ type: '', name: 'test', value: 1 })).toBe(false)
+      expect(validateMetric({ type: 'test', name: '', value: 1 })).toBe(false)
+      expect(validateMetric({ type: 'test', name: 'test', value: NaN })).toBe(false)
+      expect(validateMetric({ type: 'test', name: 'test', value: Infinity })).toBe(false)
+    })
+  })
+
+  describe('createMetric function', () => {
+    it('should create valid metrics', () => {
+      const metric = createMetric('performance', 'response_time', 150)
+
+      expect(metric).toEqual({
+        type: 'performance',
+        name: 'response_time',
+        value: 150
+      })
+    })
+
+    it('should throw for invalid metrics', () => {
+      expect(() => createMetric('', 'test', 1)).toThrow('Invalid metric')
+      expect(() => createMetric('test', '', 1)).toThrow('Invalid metric')
+      expect(() => createMetric('test', 'test', NaN)).toThrow('Invalid metric')
+    })
+  })
+
+  describe('setMetrics boundary integration', () => {
+    it('should collect metrics during task execution', async () => {
+      const schema = new Schema({
+        userId: Schema.string()
+      })
+
+      const task = createTask({
+        name: 'getUserData',
+        schema,
+        boundaries: {
+          fetchUser: async (userId: string) => ({ id: userId, name: 'Test User' })
+        },
+        fn: async ({ userId }, { fetchUser, setMetrics }) => {
+          // Add a performance metric
+          await setMetrics({
+            type: 'performance',
+            name: 'api_response_time',
+            value: 250
+          })
+
+          const user = await fetchUser(userId)
+
+          // Add a business metric
+          await setMetrics({
+            type: 'business',
+            name: 'users_processed',
+            value: 1
+          })
+
+          return { user }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ userId: 'user123' })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({
+        user: { id: 'user123', name: 'Test User' }
+      })
+
+      // Check that metrics were collected
+      expect(record.metrics).toHaveLength(2)
+      expect(record.metrics?.[0]).toEqual({
+        type: 'performance',
+        name: 'api_response_time',
+        value: 250
+      })
+      expect(record.metrics?.[1]).toEqual({
+        type: 'business',
+        name: 'users_processed',
+        value: 1
+      })
+
+      // Check that timing was captured
+      expect(record.timing).toEqual(expect.objectContaining({
+        startTime: expect.any(Number),
+        endTime: expect.any(Number),
+        duration: expect.any(Number)
+      }))
+    })
+
+    it('should validate metrics and reject invalid ones', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'testValidation',
+        schema,
+        boundaries: {},
+        fn: async ({ value }, { setMetrics }) => {
+          // Try to set an invalid metric
+          await setMetrics({
+            type: '',
+            name: 'invalid_metric',
+            value: value
+          } as Metric)
+
+          return { result: value }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 42 })
+
+      expect(result).toBeNull()
+      expect(error).not.toBeNull()
+      expect(error?.message).toContain('Invalid metric provided')
+      expect(record.type).toBe('error')
+    })
+
+    it('should accumulate multiple metrics correctly', async () => {
+      const schema = new Schema({
+        count: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'accumulateMetrics',
+        schema,
+        boundaries: {},
+        fn: async ({ count }, { setMetrics }) => {
+          // Add metrics in a loop
+          for (let i = 0; i < count; i++) {
+            await setMetrics({
+              type: 'processing',
+              name: `item_${i}`,
+              value: i * 10
+            })
+          }
+
+          return { processedCount: count }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ count: 3 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ processedCount: 3 })
+
+      // Check that all metrics were collected
+      expect(record.metrics).toHaveLength(3)
+      expect(record.metrics?.[0]).toEqual({
+        type: 'processing',
+        name: 'item_0',
+        value: 0
+      })
+      expect(record.metrics?.[1]).toEqual({
+        type: 'processing',
+        name: 'item_1',
+        value: 10
+      })
+      expect(record.metrics?.[2]).toEqual({
+        type: 'processing',
+        name: 'item_2',
+        value: 20
+      })
+    })
+
+    it('should not include setMetrics calls in boundary logs', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'metricsNotInBoundaries',
+        schema,
+        boundaries: {
+          calculate: async (val: number) => val * 2
+        },
+        fn: async ({ value }, { calculate, setMetrics }) => {
+          const result = await calculate(value)
+
+          await setMetrics({
+            type: 'calculation',
+            name: 'result_value',
+            value: result
+          })
+
+          return { result }
+        }
+      })
+
+      const [, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+
+      // Verify that setMetrics is not in the boundary logs
+      expect(record.boundaries).toHaveProperty('calculate')
+      expect(record.boundaries).not.toHaveProperty('setMetrics')
+
+      // But metrics should be collected
+      expect(record.metrics).toHaveLength(1)
+      expect(record.metrics?.[0]).toEqual({
+        type: 'calculation',
+        name: 'result_value',
+        value: 10
+      })
+    })
+  })
+})