@forgehive/record-tape 0.0.1

package/src/tests/index.test.ts

@@ -0,0 +1,88 @@
+import * as path from 'path'
+import { RecordTape } from '../index'
+
+const emptyPath = path.resolve('any')
+const tapePath = path.resolve(__dirname, './fixtures/load')
+
+describe('Base tests', () => {
+  it('Load sync with no file should return a empty tape', () => {
+    const tape = new RecordTape({ path: emptyPath })
+    tape.loadSync()
+
+    const data = tape.getLog()
+    expect(data.length).toBe(0)
+  })
+
+  it('Load sync with fixture tape should return a tape with one element', () => {
+    const tape = new RecordTape({ path: tapePath })
+    tape.loadSync()
+
+    const data = tape.getLog()
+    expect(data.length).toBe(2)
+  })
+
+  it('Load with no file should return a empty tape', async () => {
+    const tape = new RecordTape({ path: emptyPath })
+    await tape.load()
+
+    const data = tape.getLog()
+    expect(data.length).toBe(0)
+  })
+
+  it('Load with fixture tape should return a tape with one element', async () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapePath })
+    await tape.load()
+
+    const data = tape.getLog()
+    expect(data.length).toBe(2)
+
+    const successRecord = data[0]
+    expect(successRecord.type).toBe('success')
+    expect(successRecord.input).toEqual([true])
+    expect(successRecord.output).toBe(true)
+    expect(successRecord.error).toBeUndefined()
+
+    const errorRecord = data[1]
+    expect(errorRecord.type).toBe('error')
+    expect(errorRecord.input).toEqual([true])
+    expect(errorRecord.output).toBeUndefined()
+    expect(errorRecord.error).toBe('invalid data')
+  })
+
+  it('Should create a new tape with generic types', () => {
+    type InputType = [{ name: string }]
+    type OutputType = {
+      age: number
+    }
+
+    const tape = new RecordTape<InputType, OutputType>({ path: emptyPath })
+    tape.addLogItem('test', { input: [{name: 'test'}], output: { age: 1 } })
+    tape.addLogItem('test', { input: [{name: 'test'}], error: new Error('test') })
+
+    const data = tape.getLog()
+    expect(data.length).toBe(2)
+
+    const input = data[0].input
+    const output = data[0].output
+    const type = data[0].type
+    const error = data[0].error
+
+    expect(input).toEqual([{name: 'test'}])
+    expect(output).toEqual({ age: 1 })
+    expect(error).toBeUndefined()
+    expect(type).toBe('success')
+
+    const input2 = data[1].input
+    const output2 = data[1].output
+    const type2 = data[1].type
+    const error2 = data[1].error
+
+    expect(input2).toEqual([{name: 'test'}])
+    expect(output2).toBeUndefined()
+    expect(error2).toEqual(new Error('test'))
+    expect(type2).toBe('error')
+  })
+})

package/src/tests/load.test.ts

@@ -0,0 +1,108 @@
+import path from 'path'
+import fs from 'fs'
+import { RecordTape } from '../index'
+
+const baseTapeData = [
+  {
+    name: 'name',
+    type: 'success',
+    input: [true],
+    output: true,
+    boundaries: {}
+  },
+  {
+    name: 'name',
+    type: 'error',
+    input: [true],
+    error: 'invalid data',
+    boundaries: {}
+  }
+]
+
+describe('Load async', () => {
+  it('Load async from file', async () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tape = new RecordTape<InputType, OutputType>({
+      path: path.resolve(__dirname, './fixtures/load')
+    })
+
+    await tape.load()
+    const log = tape.getLog()
+
+    expect(log).toEqual(baseTapeData)
+  })
+
+  it('Load async from file on a directory that doesnt exist', async () => {
+    const tape = new RecordTape({
+      path: path.resolve(__dirname, './nowhere/nop')
+    })
+
+    await expect(tape.load()).rejects.toThrow('Logs folder doesn\'t exists')
+  })
+
+  it('Load async from file that doesnt exist', async () => {
+    const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
+
+    try {
+      await fs.promises.unlink(tapeFilePath + '.log')
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('Didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape({
+      path: path.resolve(__dirname, './fixtures/nop')
+    })
+
+    await tape.load()
+    const log = tape.getLog()
+
+    expect(log).toEqual([])
+  })
+})
+
+describe('Load sync', () => {
+  it('load sync from file', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tape = new RecordTape<InputType, OutputType>({
+      path: path.resolve(__dirname, './fixtures/load')
+    })
+
+    tape.loadSync()
+    const log = tape.getLog()
+
+    expect(log).toEqual(baseTapeData)
+  })
+
+  it('Load sync from file on a directory that doesnt exist', () => {
+    const tape = new RecordTape({
+      path: path.resolve(__dirname, './somewhere/nop')
+    })
+
+    expect(() => tape.loadSync()).toThrow('Logs folder doesn\'t exists')
+  })
+
+  it('Load sync from file that doesnt exist', () => {
+    const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
+
+    try {
+      fs.unlinkSync(tapeFilePath + '.log')
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('Didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape({
+      path: path.resolve(__dirname, './fixtures/nop')
+    })
+
+    tape.loadSync()
+    const log = tape.getLog()
+
+    expect(log).toEqual([])
+  })
+})

package/src/tests/log-format.test.ts

@@ -0,0 +1,48 @@
+import { RecordTape } from '../index'
+
+const baseTapeData = [
+  {
+    name: 'name',
+    type: 'success',
+    input: [true],
+    output: true,
+    boundaries: {}
+  },
+  {
+    name: 'name',
+    type: 'error',
+    input: [true],
+    error: 'invalid data',
+    boundaries: {}
+  }
+]
+
+const logFileData = '{"name":"name","type":"success","input":[true],"output":true,"boundaries":{}}\n{"name":"name","type":"error","input":[true],"error":"invalid data","boundaries":{}}\n'
+
+describe('Log format', () => {
+  it('Should ensure format', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tape = new RecordTape<InputType, OutputType>({})
+
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+
+    expect(tape.getLog()).toEqual(baseTapeData)
+  })
+
+  it('Should serialize to one line per item', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tape = new RecordTape<InputType, OutputType>({})
+
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+
+    const logFile = tape.stringify()
+
+    expect(logFile).toBe(logFileData)
+  })
+})

package/src/tests/mode.test.ts

@@ -0,0 +1,93 @@
+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: {}
+      }
+    ])
+  })
+})

package/src/tests/save.test.ts

@@ -0,0 +1,127 @@
+import fs from 'fs'
+import path from 'path'
+import { RecordTape } from '../index'
+
+const logFileData = '{"name":"name","type":"success","input":[true],"output":true,"boundaries":{}}\n{"name":"name","type":"error","input":[true],"error":"invalid data","boundaries":{}}\n'
+
+describe('Save to file async', () => {
+  it('Save async to existing file(should add new logs)', async () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './fixtures/save')
+    try {
+      await fs.promises.writeFile(tapeFilePath + '.log', logFileData)
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('Didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    await tape.load()
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    await tape.save()
+
+    const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
+
+    expect(tape.getLog().length).toBe(4)
+    expect(tape.stringify()).toBe(logFileData + logFileData)
+    expect(content).toBe(logFileData + logFileData)
+  })
+
+  it('Save async to a path of invalid folder', async () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+
+    await expect(tape.save()).rejects.toThrow('Folder doesn\'t exists')
+  })
+
+  it('Save async to a log file that doesnt exist', async () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
+    try {
+      await fs.promises.unlink(tapeFilePath + '.log')
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('Didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    await tape.save()
+
+    const content = await fs.promises.readFile(tapeFilePath + '.log', 'utf8')
+
+    expect(content).toBe(logFileData)
+  })
+})
+
+describe('Save to file sync', () => {
+  it('Save sync', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './fixtures/save')
+    try {
+      fs.unlinkSync(tapeFilePath + '.log')
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.saveSync()
+
+    const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')
+
+    expect(content).toBe(logFileData)
+  })
+
+  it('Save sync to a path of invalid folder', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './nowhere/nop')
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+
+    expect(() => tape.saveSync()).toThrow('Folder doesn\'t exists')
+  })
+
+  it('Save sync to a log file that doesnt exist', () => {
+    type InputType = boolean[]
+    type OutputType = boolean
+
+    const tapeFilePath = path.resolve(__dirname, './fixtures/nop')
+
+    try {
+      fs.unlinkSync(tapeFilePath + '.log')
+    } catch (_e) {
+      // eslint-disable-next-line no-console
+      // console.warn('Didnt found a file to unlink')
+    }
+
+    const tape = new RecordTape<InputType, OutputType>({ path: tapeFilePath })
+    tape.addLogItem('name', { input: [true], output: true, boundaries: {} })
+    tape.addLogItem('name', { input: [true], error: 'invalid data', boundaries: {} })
+    tape.saveSync()
+
+    const content = fs.readFileSync(tapeFilePath + '.log', 'utf8')
+
+    expect(content).toBe(logFileData)
+  })
+})

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

@@ -0,0 +1,170 @@
+import { Task, createTask, Schema } from '@forgehive/task'
+import { RecordTape, LogItem } 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> => {
+        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)
+    })
+
+    await task.run({})
+
+    expect(tape.getLog()).toEqual([
+      { name: 'test', type: 'success', input: {}, output: { value: 1, foo: true }, boundaries: {} }
+    ])
+  })
+
+  it('Should has errors and sucess items', async () => {
+    const task = new Task(
+      async (input: { value: number }): Promise<{ result: number }> => {
+        if (input.value < 10 || input.value > 20) {
+          throw new Error('Value is not between 10 and 20')
+        }
+
+        return { result: input.value * 2 }
+      }
+    )
+
+    const tape = new RecordTape<{ value: number }, { result: number }>({})
+
+    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)
+    })
+
+    try {
+      await task.run({ value: 5 })
+    } catch (_error) {
+      // this is expected
+    }
+
+    await task.run({ value: 15 })
+
+    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: {} }
+    ])
+  })
+
+  it('Should get types from task', async () => {
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      multiply: async (value: number): Promise<number> => {
+        return value * 2
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      async (input, { multiply }) => {
+        const result = await multiply(input.value)
+        return { result }
+      }
+    )
+
+    type InputType = typeof schema
+    type OutputType = Awaited<ReturnType<typeof task.run>>
+
+    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)
+    })
+
+    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 }]
+        }
+      }
+    ])
+  })
+
+  it('Should listen to task events with boundaries', async () => {
+    type InputType = { value: number }
+    type OutputType = { result: number }
+
+    const tape = new RecordTape<InputType, OutputType>({})
+
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      multiply: async (value: number): Promise<number> => {
+        return value * 2
+      }
+    }
+
+    // Create the task using createTask
+    const task = createTask(
+      schema,
+      boundaries,
+      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)
+    })
+
+    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 }]
+        }
+      }
+    ])
+  })
+})
+

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "composite": false,
+    "incremental": false,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}