@forgehive/task 0.1.13 → 0.2.1

package/src/test/add-listener-with-boundaries.test.ts

@@ -1,299 +1,249 @@
-import { type TaskRecord, createTask, Schema } from '../index'
-
-describe('Listener with boundaries tests', () => {
-  it('Should record one item and its boundaries tape', async () => {
-    const tape: TaskRecord<{ value: number }, { value: number, foo: boolean }>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      fetchExternalData: async (): Promise<{ foo: boolean }> => {
-        return { foo: false }
-      }
-    }
-
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        const externalData = await boundaries.fetchExternalData()
-        return { ...externalData, ...argv }
+import { type ExecutionRecord, createTask, Schema } from '../index'
+
+describe('Listener with boundaries', () => {
+  it('Should add a listener to the task and capture boundaries', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {
+        getTen: async () => {
+          return 10
+        }
+      },
+      fn: async (argv, boundaries) => {
+        const ten = await boundaries.getTen()
+        return { value: argv.value, foo: ten > 5 }
       }
-    )
-
-    task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
-      tape.push(record)
     })
 
-    await task.run({ value: 5 })
-
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ value: 5, foo: false })
-    expect(tape[0].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
-    })
-  })
-
-  it('Should record multiple items and their boundaries tape', async () => {
-    const tape: TaskRecord<{ value: number }, { value: number, foo: boolean }>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      fetchExternalData: async (): Promise<{ foo: boolean }> => {
-        return { foo: false }
-      }
-    }
-
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        const externalData = await boundaries.fetchExternalData()
-        return { ...externalData, ...argv }
-      }
-    )
-
-    task.addListener<{ value: number }, { value: number, foo: boolean }>((record) => {
+    task.addListener((record) => {
       tape.push(record)
     })
 
     await task.run({ value: 5 })
-    await task.run({ value: 6 })
-
-    expect(tape.length).toBe(2)
-
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ value: 5, foo: false })
-    expect(tape[0].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
-    })
-
-    expect(tape[1].input).toEqual({ value: 6 })
-    expect(tape[1].output).toEqual({ value: 6, foo: false })
-    expect(tape[1].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
-    })
+    expect(tape).toEqual([{
+      input: { value: 5 },
+      output: { value: 5, foo: true },
+      boundaries: {
+        getTen: [{
+          input: [],
+          output: 10
+        }]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'success'
+    }])
   })
 
-  it('Should record error and its boundaries tape', async () => {
-    const tape: TaskRecord<Record<string, unknown>, { value: number, foo: boolean }>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number().optional()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      fetchExternalData: async (): Promise<{ foo: boolean }> => {
-        return { foo: false }
-      }
-    }
-
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        const externalData = await boundaries.fetchExternalData()
-        if (typeof argv.value === 'undefined') {
-          throw new Error('Value is required')
+  it('Should add a listener to the task and capture boundaries with error', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {
+        getTen: async () => {
+          throw new Error('Network error')
         }
-
-        return { ...externalData, ...argv as { value: number } }
+      },
+      fn: async (argv, boundaries) => {
+        const ten = await boundaries.getTen()
+        return { value: argv.value, foo: ten > 5 }
       }
-    )
+    })
 
-    task.addListener<Record<string, unknown>, { value: number, foo: boolean }>((record) => {
+    task.addListener((record) => {
       tape.push(record)
     })
 
     try {
-      await task.run({})
-    } catch (e) {
-      // Error is expected
+      await task.run({ value: 5 })
+    } catch (error) {
+      // Expected error
     }
 
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({})
-    expect(tape[0].error).toBe('Value is required')
-    expect(tape[0].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
-    })
+    expect(tape).toEqual([{
+      input: { value: 5 },
+      error: 'Network error',
+      boundaries: {
+        getTen: [{
+          input: [],
+          error: 'Network error'
+        }]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'error'
+    }])
   })
 
-  it('Should record error + success and their boundaries tape', async () => {
-    const tape: TaskRecord<{ value?: number }, { value: number, foo: boolean }>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number().optional()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      fetchExternalData: async (): Promise<{ foo: boolean }> => {
-        return { foo: false }
-      }
-    }
-
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        const externalData = await boundaries.fetchExternalData()
-        if (typeof argv.value === 'undefined') {
-          throw new Error('Value is required')
+  it('Should add a listener to the task and capture boundaries with dynamic parameters', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({}),
+      boundaries: {
+        addNumbers: async (a: number, b: number) => {
+          return a + b
         }
-
-        return { ...externalData, ...argv as { value: number } }
+      },
+      fn: async (argv, boundaries) => {
+        const sum = await boundaries.addNumbers(3, 7)
+        return { value: sum, foo: sum > 5 }
       }
-    )
-
-    task.addListener<{ value?: number }, { value: number, foo: boolean }>((record) => {
-      tape.push(record)
     })
 
-    try {
-      await task.run({})
-    } catch (e) {
-      // Error is expected
-    }
-    await task.run({ value: 5 })
-
-    expect(tape.length).toBe(2)
-    expect(tape[0].input).toEqual({})
-    expect(tape[0].error).toBe('Value is required')
-    expect(tape[0].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
+    task.addListener((record) => {
+      tape.push(record)
     })
 
-    expect(tape[1].input).toEqual({ value: 5 })
-    expect(tape[1].output).toEqual({ value: 5, foo: false })
-    expect(tape[1].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } }
-      ]
-    })
+    await task.run({})
+    expect(tape).toEqual([{
+      input: {},
+      output: { value: 10, foo: true },
+      boundaries: {
+        addNumbers: [{
+          input: [3, 7],
+          output: 10
+        }]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'success'
+    }])
   })
 
-  it('Should record 2 run logs if boundary called twice', async () => {
-    const tape: TaskRecord<{ value: number }, { foo: boolean }>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      fetchExternalData: async (): Promise<{ foo: boolean }> => {
-        return { foo: false }
-      }
-    }
-
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        await boundaries.fetchExternalData()
-        await boundaries.fetchExternalData()
-
-        return { foo: true }
+  it('Should add a listener to the task and capture boundaries with optional parameters', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number().optional()
+      }),
+      boundaries: {
+        processValue: async (val?: number) => {
+          return val || 0
+        }
+      },
+      fn: async (argv, boundaries) => {
+        const processed = await boundaries.processValue(argv.value)
+        return { value: processed, foo: processed > 5 }
       }
-    )
+    })
 
-    task.addListener<{ value: number }, { foo: boolean }>((record) => {
+    task.addListener((record) => {
       tape.push(record)
     })
 
-    await task.run({ value: 5 })
-
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toEqual({ foo: true })
-    expect(tape[0].boundaries).toEqual({
-      fetchExternalData: [
-        { input: [], output: { foo: false } },
-        { input: [], output: { foo: false } }
-      ]
-    })
+    await task.run({ value: undefined })
+    expect(tape).toEqual([{
+      input: { value: undefined },
+      output: { value: 0, foo: false },
+      boundaries: {
+        processValue: [{
+          input: [undefined],
+          output: 0
+        }]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'success'
+    }])
   })
 
-  it('Should record 2 boundary logs', async () => {
-    const tape: TaskRecord<{ value: number }, number>[] = []
-
-    // Create a schema for the task
-    const schema = new Schema({
-      value: Schema.number()
-    })
-
-    // Define the boundaries
-    const boundaries = {
-      add: async (value: number): Promise<number> => {
-        return value + 1
+  it('Should add a listener to the task and capture boundaries with multiple calls', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {
+        multiplyByTwo: async (num: number) => {
+          return num * 2
+        }
       },
-      subtract: async (value: number): Promise<number> => {
-        return value - 1
+      fn: async (argv, boundaries) => {
+        const doubled = await boundaries.multiplyByTwo(argv.value)
+        const quadrupled = await boundaries.multiplyByTwo(doubled)
+        return { foo: quadrupled > 10 }
       }
-    }
+    })
 
-    // Create the task using createTask
-    const task = createTask(
-      schema,
-      boundaries,
-      async (argv, boundaries) => {
-        let counter = argv.value
+    task.addListener((record) => {
+      tape.push(record)
+    })
 
-        counter = await boundaries.add(counter)
-        counter = await boundaries.subtract(counter)
-        counter = await boundaries.subtract(counter)
+    await task.run({ value: 3 })
+    expect(tape).toEqual([{
+      input: { value: 3 },
+      output: { foo: true },
+      boundaries: {
+        multiplyByTwo: [
+          {
+            input: [3],
+            output: 6
+          },
+          {
+            input: [6],
+            output: 12
+          }
+        ]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'success'
+    }])
+  })
 
-        return counter
+  it('Should add a listener to the task and capture boundaries with mixed results', async () => {
+    const tape: ExecutionRecord[] = []
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({
+        value: Schema.number()
+      }),
+      boundaries: {
+        getResult: async (num: number) => {
+          if (num > 5) {
+            return num * 2
+          }
+          throw new Error('Number too small')
+        }
+      },
+      fn: async (argv, boundaries) => {
+        let result = 0
+        try {
+          result = await boundaries.getResult(argv.value)
+        } catch (error) {
+          // Continue with default
+        }
+        return result
       }
-    )
+    })
 
-    task.addListener<{ value: number }, number>((record) => {
+    task.addListener((record) => {
       tape.push(record)
     })
 
-    await task.run({ value: 5 })
-
-    expect(tape.length).toBe(1)
-    expect(tape[0].input).toEqual({ value: 5 })
-    expect(tape[0].output).toBe(4)
-    expect(tape[0].boundaries).toEqual({
-      add: [
-        { input: [5], output: 6 }
-      ],
-      subtract: [
-        { input: [6], output: 5 },
-        { input: [5], output: 4 }
-      ]
-    })
+    await task.run({ value: 3 })
+    expect(tape).toEqual([{
+      input: { value: 3 },
+      output: 0,
+      boundaries: {
+        getResult: [{
+          input: [3],
+          error: 'Number too small'
+        }]
+      },
+      taskName: 'test',
+      metadata: {},
+      type: 'success'
+    }])
   })
 })