@forgehive/record-tape 0.2.0 → 0.2.2

package/src/tests/save.test.ts

@@ -2,7 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import { RecordTape } from '../index'
 
-const logFileData = '{"name":"name","input":true,"output":true,"boundaries":{},"type":"success"}\n{"name":"name","input":true,"error":"invalid data","boundaries":{},"type":"error"}\n'
+const logFileData = '{"input":true,"output":true,"boundaries":{},"type":"success","taskName":"name","metadata":{}}\n{"input":true,"error":"invalid data","boundaries":{},"type":"error","taskName":"name","metadata":{}}\n'
 
 describe('Save to file async', () => {
   it('Save async to existing file(should add new logs)', async () => {
@@ -19,8 +19,8 @@ describe('Save to file async', () => {
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
     await tape.load()
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     await tape.save()
 
     const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
@@ -37,8 +37,8 @@ describe('Save to file async', () => {
     const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     await expect(tape.save()).rejects.toThrow('Folder doesn\'t exists')
   })
@@ -56,8 +56,8 @@ describe('Save to file async', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     await tape.save()
 
     const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
@@ -80,8 +80,8 @@ describe('Save to file sync', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     tape.saveSync()
 
     const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')
@@ -96,8 +96,8 @@ describe('Save to file sync', () => {
     const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
 
     expect(() => tape.saveSync()).toThrow('Folder doesn\'t exists')
   })
@@ -116,8 +116,8 @@ describe('Save to file sync', () => {
     }
 
     const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
-    tape.addLogRecord({ name: 'name', input: true, output: true, boundaries: {}, type: 'success' })
-    tape.addLogRecord({ name: 'name', input: true, error: 'invalid data', boundaries: {}, type: 'error' })
+    tape.push({ input: true, output: true, boundaries: {}, type: 'success', taskName: 'name' })
+    tape.push({ input: true, error: 'invalid data', boundaries: {}, type: 'error', taskName: 'name' })
     tape.saveSync()
 
     const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')

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

@@ -3,29 +3,24 @@ 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 executionRecord = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
+    })
 
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tape.push('test', executionRecord as any)
+    task.addListener((record) => {
+      tape.push(record)
     })
 
     await task.run({})
 
     expect(tape.getLog()).toEqual([
-      { name: 'test', type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {}, metadata: {} }
+      { type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {}, metadata: {}, taskName: 'test' }
     ])
   })
 
@@ -42,13 +37,9 @@ describe('Task listener', () => {
 
     const tape = new RecordTape<{ value: number }, { result: number }>({})
 
+    task.setName('test')
     task.addListener<{ value: number }, { result: number }>((record) => {
-      const executionRecord = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
-        : { input: record.input, output: record.output as { result: number }, boundaries: record.boundaries || {}, type: 'success' as const }
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tape.push('test', executionRecord as any)
+      tape.push(record)
     })
 
     try {
@@ -62,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: {}, metadata: {}, output: undefined },
-      { name: 'test', type: 'success', input: { value: 15 }, output: { result: 30 }, boundaries: {}, metadata: {} }
+      { 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' }
     ])
   })
 
@@ -96,26 +87,21 @@ describe('Task listener', () => {
     const tape = new RecordTape<InputType, OutputType>({})
 
     task.addListener<InputType, OutputType>((record) => {
-      const executionRecord = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tape.push('test', executionRecord as any)
+      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, error: null }]
+          multiply: [{ input: [5], output: 10 }]
         },
-        metadata: {}
+        metadata: {},
+        taskName: undefined
       }
     ])
   })
@@ -149,26 +135,21 @@ describe('Task listener', () => {
     })
 
     task.addListener<InputType, OutputType>((record) => {
-      const executionRecord = record.error
-        ? { input: record.input, error: record.error, boundaries: record.boundaries || {}, type: 'error' as const }
-        : { input: record.input, output: record.output as OutputType, boundaries: record.boundaries || {}, type: 'success' as const }
-
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      tape.push('test', executionRecord as any)
+      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, error: null }]
+          multiply: [{ input: [5], output: 10 }]
         },
-        metadata: {}
+        metadata: {},
+        taskName: undefined
       }
     ])
   })

package/src/tests/mode.test.ts

@@ -1,106 +0,0 @@
-import { RecordTape } from '../index'
-
-describe('Test mode', () => {
-  it('Should record items if mode is record', () => {
-    type InputType = { name: string }
-    type OutputType = { age: number }
-
-    const tape = new RecordTape<InputType, OutputType>({})
-    tape.setMode('record')
-
-    tape.addLogRecord({
-      name: 'test',
-      input: { name: 'test' },
-      output: { age: 1 },
-      boundaries: {},
-      type: 'success'
-    })
-
-    const data = tape.getLog()
-
-    expect(data).toEqual([{
-      name: 'test',
-      input: { name: 'test' },
-      output: { age: 1 },
-      boundaries: {},
-      type: 'success'
-    }])
-  })
-
-  it('Should not record items if mode is replay', () => {
-    type InputType = { name: string }
-    type OutputType = { age: number }
-
-    const tape = new RecordTape<InputType, OutputType>({})
-    tape.setMode('replay')
-
-    tape.addLogRecord({
-      name: 'test',
-      input: { name: 'test' },
-      output: { age: 1 },
-      boundaries: {},
-      type: 'success'
-    })
-
-    const data = tape.getLog()
-    expect(data).toEqual([])
-  })
-
-  it('Should append logs with same name', () => {
-    type InputType = { name: string }
-    type OutputType = { age: number }
-
-    const tape = new RecordTape<InputType, OutputType>({})
-    tape.setMode('record')
-
-    tape.addLogRecord({
-      name: 'test1',
-      input: { name: 'test' },
-      output: { age: 1 },
-      boundaries: {},
-      type: 'success'
-    })
-
-    tape.addLogRecord({
-      name: 'test2',
-      input: { name: 'test' },
-      output: { age: 2 },
-      boundaries: {},
-      type: 'success'
-    })
-
-    tape.addLogRecord({
-      name: 'test3',
-      input: { name: 'test' },
-      output: { age: 3 },
-      boundaries: {},
-      type: 'success'
-    })
-
-    const data = tape.getLog()
-
-    expect(data).toEqual([
-      {
-        name: 'test1',
-        input: { name: 'test' },
-        output: { age: 1 },
-        boundaries: {},
-        type: 'success'
-      },
-      {
-        name: 'test2',
-        input: { name: 'test' },
-        output: { age: 2 },
-        boundaries: {},
-        type: 'success'
-      },
-      {
-        name: 'test3',
-        input: { name: 'test' },
-        output: { age: 3 },
-        boundaries: {},
-        type: 'success'
-      }
-    ])
-  })
-})