@forgehive/task 0.1.13 → 0.2.0

package/src/test/task-execution-log.test.ts

@@ -0,0 +1,246 @@
+import { createTask, Schema, getExecutionRecordType } from '../index'
+
+describe('Task execution log record', () => {
+  describe('Task name in execution record', () => {
+    it('should include task name in safeRun execution record when task has a name', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task with a name
+      const task = createTask({
+        name: 'test-multiplication-task',
+        description: 'A task that multiplies input by 2',
+        schema,
+        boundaries: {
+          multiply: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { multiply }) => {
+          const result = await multiply(value)
+          return { result }
+        }
+      })
+
+      // Run the task with safeRun
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+
+      // Verify the task name is included in the record
+      expect(record.taskName).toBe('test-multiplication-task')
+      expect(record.input).toEqual({ value: 5 })
+      expect(record.output).toEqual({ result: 10 })
+    })
+
+    it('should include undefined task name when task has no name', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task without a name
+      const task = createTask({
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 3 }
+        }
+      })
+
+      // Run the task with safeRun
+      const [result, error, record] = await task.safeRun({ value: 4 })
+
+      // Verify the execution was successful
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 12 })
+
+      // Verify the task name is undefined in the record
+      expect(record.taskName).toBeUndefined()
+      expect(record.input).toEqual({ value: 4 })
+      expect(record.output).toEqual({ result: 12 })
+    })
+
+    it('should include task name in error execution records', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task that will throw an error
+      const task = createTask({
+        name: 'error-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          if (value < 0) {
+            throw new Error('Value cannot be negative')
+          }
+          return { result: value }
+        }
+      })
+
+      // Run the task with a value that will cause an error
+      const [result, error, record] = await task.safeRun({ value: -1 })
+
+      // Verify the execution failed as expected
+      expect(result).toBeNull()
+      expect(error).not.toBeNull()
+      expect(error?.message).toBe('Value cannot be negative')
+
+      // Verify the task name is included in the error record
+      expect(record.taskName).toBe('error-task')
+      expect(record.input).toEqual({ value: -1 })
+      expect(record.error).toBe('Value cannot be negative')
+      expect(record.output).toBeUndefined()
+    })
+
+    it('should include task name in safeReplay execution record', async () => {
+    // Create a schema
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      // Create a task with boundaries
+      const task = createTask({
+        name: 'replay-test-task',
+        schema,
+        boundaries: {
+          fetchData: async (value: number) => value * 2
+        },
+        fn: async ({ value }, { fetchData }) => {
+          const result = await fetchData(value)
+          return { result }
+        }
+      })
+
+      // First, run the task normally to get an execution record
+      const [, , originalRecord] = await task.safeRun({ value: 3 })
+
+      // Now replay the task
+      const [replayResult, replayError, replayRecord] = await task.safeReplay(
+        originalRecord,
+        { boundaries: { fetchData: 'replay' } }
+      )
+
+      // Verify the replay was successful
+      expect(replayError).toBeNull()
+      expect(replayResult).toEqual({ result: 6 })
+
+      // Verify the task name is included in the replay record
+      expect(replayRecord.taskName).toBe('replay-test-task')
+      expect(replayRecord.input).toEqual({ value: 3 })
+      expect(replayRecord.output).toEqual({ result: 6 })
+    })
+  })
+
+  describe('Type computation in execution record', () => {
+    it('should have type "success" when task completes successfully', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'success-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.type).toBe('success')
+      expect(record.output).toEqual({ result: 10 })
+      expect(record.error).toBeUndefined()
+    })
+
+    it('should have type "error" when task throws an error', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'error-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          if (value < 0) {
+            throw new Error('Value cannot be negative')
+          }
+          return { result: value }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: -1 })
+
+      expect(result).toBeNull()
+      expect(error).not.toBeNull()
+      expect(record.type).toBe('error')
+      expect(record.error).toBe('Value cannot be negative')
+      expect(record.output).toBeUndefined()
+    })
+
+    it('should have type "pending" when neither output nor error is set', async () => {
+      // This tests the getExecutionRecordType utility function directly
+      const partialRecord = {
+        input: { value: 1 },
+        boundaries: {},
+        taskName: 'test'
+      }
+
+      const type = getExecutionRecordType(partialRecord)
+      expect(type).toBe('pending')
+    })
+  })
+
+  describe('Context in execution record', () => {
+    it('should include context when provided to safeRun', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'context-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.metadata).toEqual({})
+      expect(record.taskName).toBe('context-task')
+    })
+
+    it('should handle undefined context gracefully', async () => {
+      const schema = new Schema({
+        value: Schema.number()
+      })
+
+      const task = createTask({
+        name: 'no-context-task',
+        schema,
+        boundaries: {},
+        fn: async ({ value }) => {
+          return { result: value * 2 }
+        }
+      })
+
+      const [result, error, record] = await task.safeRun({ value: 5 })
+
+      expect(error).toBeNull()
+      expect(result).toEqual({ result: 10 })
+      expect(record.metadata).toEqual({})
+    })
+  })
+})

package/src/test/task-with-boundaries.test.ts

@@ -14,14 +14,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const indentity = createTask(
+    const indentity = createTask({
+      name: 'indentity',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       }
-    )
+    })
 
     const object = await indentity.run({ bar: true })
     const { foo } = await indentity.run({ foo: true })
@@ -43,22 +44,21 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask with boundariesData
-    const indentity = createTask(
+    const indentity = createTask({
+      name: 'indentity',
       schema,
       boundaries,
-      async (argv, boundaries) => {
+      fn: async (argv, boundaries) => {
         const externalData = await boundaries.fetchExternalData()
         return { ...externalData, ...argv }
       },
-      {
-        boundariesData: {
-          fetchExternalData: [
-            { input: [], output: { foo: false } }
-          ]
-        },
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: {
+        fetchExternalData: [
+          { input: [], output: { foo: false } }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
 
     const object = await indentity.run({ bar: true })
     const { foo } = await indentity.run({ foo: true })
@@ -81,14 +81,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const add = createTask(
+    const add = createTask({
+      name: 'add',
       schema,
       boundaries,
-      async function (argv, boundaries) {
+      fn: async function (argv, boundaries) {
         const externalData: number = await boundaries.fetchExternalData(1)
         return argv.value + externalData
       }
-    )
+    })
 
     const six = await add.run({ value: 4 })
     const seven = await add.run({ value: 5 })
@@ -111,22 +112,21 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask with boundariesData
-    const add = createTask(
+    const add = createTask({
+      name: 'add',
       schema,
       boundaries,
-      async function (argv, boundaries) {
+      fn: async function (argv, boundaries) {
         const externalData: number = await boundaries.fetchExternalData(argv.value)
         return argv.value + externalData
       },
-      {
-        boundariesData: {
-          fetchExternalData: [
-            { input: [4], output: 2 }
-          ]
-        },
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: {
+        fetchExternalData: [
+          { input: [4], output: 2 }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
 
     const six = await add.run({ value: 4 }) // From tape data
     const fifteen = await add.run({ value: 5 })
@@ -163,14 +163,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const multiplyTask = createTask(
+    const multiplyTask = createTask({
+      name: 'multiplyTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData}) {
+      fn: async function ({ value }, { fetchExternalData}) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       }
-    )
+    })
 
     multiplyTask.addListener((record) => {
       records.push(record)
@@ -238,14 +239,15 @@ describe('Boundaries tasks tests', () => {
     }
 
     // Create the task using createTask
-    const multiplyTask = createTask(
+    const multiplyTask = createTask({
+      name: 'multiplyTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData }) {
+      fn: async function ({ value }, { fetchExternalData }) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       }
-    )
+    })
 
     // Run task with value 2
     await multiplyTask.run({ value: 2 })
@@ -308,18 +310,17 @@ describe('Boundaries tasks tests', () => {
     expect(finalSortedTape[2].output).toBe(8)
 
     // Verify tape can be used for replay in proxy-pass mode
-    const replayTask = createTask(
+    const replayTask = createTask({
+      name: 'replayTask',
       schema,
       boundaries,
-      async function ({ value }, { fetchExternalData }) {
+      fn: async function ({ value }, { fetchExternalData }) {
         const externalData: number = await fetchExternalData(value)
         return value * externalData
       },
-      {
-        boundariesData: boundariesData3 as BoundaryTapeData,
-        mode: 'proxy-pass'
-      }
-    )
+      boundariesData: boundariesData3 as BoundaryTapeData,
+      mode: 'proxy-pass'
+    })
 
     // Run task with all three values from the tape
     const result2 = await replayTask.run({ value: 2 })