@forgehive/record-tape 0.1.6 → 0.2.1

package/src/tests/task-listener.test.ts

@@ -1,30 +1,26 @@
 import { Task, createTask, Schema } from '@forgehive/task'
-import { RecordTape, LogItem } from '../index'
+import { RecordTape } from '../index'
 
 describe('Task listener', () => {
   it('Should listen to task events', async () => {
-    type InputType = Record<string, unknown>
-    type OutputType = { value: number, foo: boolean }
-
-    const tape = new RecordTape<InputType, OutputType>({})
-    const task = new Task(
-      async (_input: InputType): Promise<OutputType> => {
+    const tape = new RecordTape({})
+    const task = createTask({
+      name: 'test',
+      schema: new Schema({}),
+      boundaries: {},
+      fn: async (_input) => {
         return { value: 1, foo: true }
       }
-    )
-
-    task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
+    })
 
-      tape.addLogItem('test', logItem)
+    task.addListener((record) => {
+      tape.push(record)
     })
 
     await task.run({})
 
     expect(tape.getLog()).toEqual([
-      { name: 'test', type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {} }
+      { type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {}, metadata: {}, taskName: 'test' }
     ])
   })
 
@@ -41,12 +37,9 @@ describe('Task listener', () => {
 
     const tape = new RecordTape<{ value: number }, { result: number }>({})
 
+    task.setName('test')
     task.addListener<{ value: number }, { result: number }>((record) => {
-      const logItem: LogItem<{ value: number }, { result: number }> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as { result: number }, boundaries: record.boundaries }
-
-      tape.addLogItem('test', logItem)
+      tape.push(record)
     })
 
     try {
@@ -60,8 +53,8 @@ describe('Task listener', () => {
     const log = tape.getLog()
 
     expect(log).toEqual([
-      { name: 'test', type: 'error', input: { value: 5 }, error: 'Value is not between 10 and 20', boundaries: {} },
-      { name: 'test', type: 'success', input: { value: 15 }, output: { result: 30 }, boundaries: {} }
+      { type: 'error', input: { value: 5 }, error: 'Value is not between 10 and 20', boundaries: {}, metadata: {}, output: undefined, taskName: 'test' },
+      { type: 'success', input: { value: 15 }, output: { result: 30 }, boundaries: {}, metadata: {}, taskName: 'test' }
     ])
   })
 
@@ -79,14 +72,14 @@ describe('Task listener', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async (input, { multiply }) => {
+      fn: async (input, { multiply }) => {
         const result = await multiply(input.value)
         return { result }
       }
-    )
+    })
 
     type InputType = typeof schema
     type OutputType = Awaited<ReturnType<typeof task.run>>
@@ -94,24 +87,21 @@ describe('Task listener', () => {
     const tape = new RecordTape<InputType, OutputType>({})
 
     task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
-
-      tape.addLogItem('test', logItem)
+      tape.push(record)
     })
 
     await task.run({ value: 5 })
 
     expect(tape.getLog()).toEqual([
       {
-        name: 'test',
         type: 'success',
         input: { value: 5 },
         output: { result: 10 },
         boundaries: {
           multiply: [{ input: [5], output: 10 }]
-        }
+        },
+        metadata: {},
+        taskName: undefined
       }
     ])
   })
@@ -135,34 +125,31 @@ describe('Task listener', () => {
     }
 
     // Create the task using createTask
-    const task = createTask(
+    const task = createTask({
       schema,
       boundaries,
-      async (input, { multiply }) => {
+      fn: async (input, { multiply }) => {
         const result = await multiply(input.value)
         return { result }
       }
-    )
+    })
 
     task.addListener<InputType, OutputType>((record) => {
-      const logItem: LogItem<InputType, OutputType> = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries }
-
-      tape.addLogItem('test', logItem)
+      tape.push(record)
     })
 
     await task.run({ value: 5 })
 
     expect(tape.getLog()).toEqual([
       {
-        name: 'test',
         type: 'success',
         input: { value: 5 },
         output: { result: 10 },
         boundaries: {
           multiply: [{ input: [5], output: 10 }]
-        }
+        },
+        metadata: {},
+        taskName: undefined
       }
     ])
   })

package/src/tests/mode.test.ts

@@ -1,93 +0,0 @@
-import { RecordTape } from '../index'
-
-describe('Mode behavior', () => {
-  it('Should start in record mode by default', () => {
-    const tape = new RecordTape()
-    expect(tape.getMode()).toBe('record')
-  })
-
-  it('Should not add log items in replay mode', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
-
-    const tape = new RecordTape<InputType, OutputType>()
-    tape.setMode('replay')
-
-    tape.addLogItem('test', {
-      input: { value: 1 },
-      output: { result: 2 }
-    })
-
-    expect(tape.getLog()).toEqual([])
-  })
-
-  it('Should add log items in record mode', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
-
-    const tape = new RecordTape<InputType, OutputType>()
-    tape.setMode('record')
-
-    tape.addLogItem('test', {
-      input: { value: 1 },
-      output: { result: 2 }
-    })
-
-    expect(tape.getLog()).toEqual([
-      {
-        name: 'test',
-        type: 'success',
-        input: { value: 1 },
-        output: { result: 2 },
-        boundaries: {}
-      }
-    ])
-  })
-
-  it('Should switch between modes', () => {
-    type InputType = { value: number }
-    type OutputType = { result: number }
-
-    const tape = new RecordTape<InputType, OutputType>()
-
-    // Start in record mode
-    expect(tape.getMode()).toBe('record')
-    tape.addLogItem('test1', {
-      input: { value: 1 },
-      output: { result: 2 }
-    })
-
-    // Switch to replay mode
-    tape.setMode('replay')
-    expect(tape.getMode()).toBe('replay')
-    tape.addLogItem('test2', {
-      input: { value: 3 },
-      output: { result: 4 }
-    })
-
-    // Switch back to record mode
-    tape.setMode('record')
-    expect(tape.getMode()).toBe('record')
-    tape.addLogItem('test3', {
-      input: { value: 5 },
-      output: { result: 6 }
-    })
-
-    expect(tape.getLog()).toEqual([
-      {
-        name: 'test1',
-        type: 'success',
-        input: { value: 1 },
-        output: { result: 2 },
-        boundaries: {}
-      },
-      {
-        name: 'test3',
-        type: 'success',
-        input: { value: 5 },
-        output: { result: 6 },
-        boundaries: {}
-      }
-    ])
-  })
-})