@forgehive/task 0.1.0

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

@@ -0,0 +1,110 @@
+import { Task, type TaskRecord } from '../index'
+import { Schema, type InferSchema } from '@shadow/schema'
+
+describe('Listener tests', () => {
+  it('Should record one item', async () => {
+    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
+    const task = new Task(function (_argv: { value: number }) {
+      return _argv
+    })
+
+    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({ value: 5 })
+  })
+
+  it('Should record execution error', async () => {
+    const tape: TaskRecord<{ value: number }, never>[] = []
+    const task = new Task(function (_argv: { value: number }) {
+      throw new Error('This should happen')
+    })
+
+    task.addListener((record) => {
+      tape.push(record)
+    })
+
+    try {
+      await task.run({ value: 5 })
+    } catch (e) {
+      // Error is expected
+    }
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].error).toBe('This should happen')
+  })
+
+  it('Should record validation error', async () => {
+    const tape: TaskRecord<{ value: number | null }, { value: number }>[] = []
+    const schema = new Schema({
+      value: Schema.number().min(5)
+    })
+
+    const task = new Task(function (_argv: InferSchema<typeof schema>) {
+      return _argv
+    }, {
+      schema
+    })
+
+    task.addListener<{ value: number | null }, { value: number }>((record) => {
+      tape.push(record)
+    })
+
+    try {
+      await task.run({ value: 3 })
+    } catch (e) {
+      // Error is expected
+    }
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 3 })
+    expect(tape[0].error).toBe('Invalid input')
+  })
+
+  it('Should record multiple records', async () => {
+    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
+    const task = new Task(function (_argv: { value: number }) {
+      return _argv
+    })
+
+    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 })
+
+    expect(tape[1].input).toEqual({ value: 6 })
+    expect(tape[1].output).toEqual({ value: 6 })
+  })
+
+  it('Should stop recording', async () => {
+    const tape: TaskRecord<{ value: number }, { value: number }>[] = []
+    const task = new Task(function (_argv: { value: number }) {
+      return _argv
+    })
+
+    task.addListener((record) => {
+      tape.push(record)
+    })
+
+    await task.run({ value: 5 })
+
+    task.removeListener()
+    await task.run({ value: 6 })
+
+    expect(tape.length).toBe(1)
+    expect(tape[0].input).toEqual({ value: 5 })
+    expect(tape[0].output).toEqual({ value: 5 })
+  })
+})

package/src/test/boundary-modes.test.ts

@@ -0,0 +1,215 @@
+import { Task } from '../index'
+
+type FetchIncrementFn = (argv: { value: number }) => Promise<number>
+
+interface TaskBoundaries {
+  fetchIncrement: FetchIncrementFn
+}
+
+describe('Proxy mode', function () {
+  // Proxy: execute the function and records it
+  it('Should execute the boundary', async function () {
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          return argv.value
+        }
+      },
+      mode: 'proxy'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(result).toBe(10)
+    expect(fetchIncrement.getMode()).toBe('proxy')
+  })
+})
+
+describe('Proxy pass mode', function () {
+  // Proxy pass: review if the input exist, it it exist returns the previous value and if not execute the functions
+  it('Should return value from record', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          i++
+          return argv.value
+        }
+      },
+      boundariesData: {
+        fetchIncrement: [
+          { input: [{ value: 5 }], output: 5 }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(fetchIncrement.getMode()).toBe('proxy-pass')
+    expect(result).toBe(10)
+    expect(i).toBe(0)
+  })
+
+  it('Should run boundary', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          i++
+          return argv.value
+        }
+      },
+      boundariesData: {
+        fetchIncrement: [
+          { input: [{ value: 6 }], output: 5 }
+        ]
+      },
+      mode: 'proxy-pass'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(fetchIncrement.getMode()).toBe('proxy-pass')
+    expect(result).toBe(10)
+    expect(i).toBe(1)
+  })
+})
+
+describe('Proxy catch mode', function () {
+  // Proxy-catch: executes the function and if it throws and error, it tries to use a previews output if it exists for the input.
+  it('Should run boundary', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          i++
+          return argv.value
+        }
+      },
+      boundariesData: {
+        fetchIncrement: [
+          { input: [{ value: 5 }], output: 5 }
+        ]
+      },
+      mode: 'proxy-catch'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(fetchIncrement.getMode()).toBe('proxy-catch')
+    expect(result).toBe(10)
+    expect(i).toBe(1)
+  })
+
+  it('After boundary fails, should return value from record', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (_argv: { value: number }): Promise<number> => {
+          i++
+          throw new Error('Something')
+        }
+      },
+      boundariesData: {
+        fetchIncrement: [
+          { input: [{ value: 5 }], output: 5 }
+        ]
+      },
+      mode: 'proxy-catch'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(fetchIncrement.getMode()).toBe('proxy-catch')
+    expect(result).toBe(10)
+    expect(i).toBe(1)
+  })
+})
+
+describe('Replay mode', function () {
+  // Replay: review if the input exist and if it doesnt throws and error.
+  it('Should return value from record', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (_argv: { value: number }): Promise<number> => {
+          i++
+          return 0 // This should never be called in replay mode with existing data
+        }
+      },
+      boundariesData: {
+        fetchIncrement: [
+          { input: [{ value: 5 }], output: 5 }
+        ]
+      },
+      mode: 'replay'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+    const result = await add.run({ value: 5 })
+
+    expect(fetchIncrement.getMode()).toBe('replay')
+    expect(result).toBe(10)
+    expect(i).toBe(0)
+  })
+
+  it('Should fail if the input its not present', async function () {
+    let i = 0
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }: TaskBoundaries) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (_argv: { value: number }): Promise<number> => {
+          i++
+          return 0 // This should never be called in replay mode
+        }
+      },
+      mode: 'replay'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+
+    let err: Error | undefined
+    try {
+      await add.run({ value: 5 })
+    } catch (e) {
+      err = e as Error
+    }
+
+    expect(fetchIncrement.getMode()).toBe('replay')
+    expect(err?.message).toBe('No tape value for this inputs')
+    expect(i).toBe(0)
+  })
+})

package/src/test/change-mode.test.ts

@@ -0,0 +1,45 @@
+import { Task } from '../index'
+
+describe('Change modes', () => {
+  it('On task start, boundaries should start in the same mode', async () => {
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          return argv.value
+        }
+      },
+      mode: 'proxy-catch'
+    })
+
+    const { fetchIncrement } = add.getBoundaries()
+
+    expect(fetchIncrement.getMode()).toBe('proxy-catch')
+  })
+
+  it('On task mode change, boundaries should change to the same', async () => {
+    const add = new Task(async (argv: { value: number }, { fetchIncrement }) => {
+      const increment: number = await fetchIncrement(argv)
+
+      return argv.value + increment
+    }, {
+      boundaries: {
+        fetchIncrement: async (argv: { value: number }): Promise<number> => {
+          return argv.value
+        }
+      },
+      mode: 'proxy-catch'
+    })
+
+    const { fetchIncrement: original } = add.getBoundaries()
+    expect(original.getMode()).toBe('proxy-catch')
+
+    add.setMode('replay')
+
+    const { fetchIncrement: updated } = add.getBoundaries()
+    expect(updated.getMode()).toBe('replay')
+  })
+})

package/src/test/index.test.ts

@@ -0,0 +1,62 @@
+import { Task } from '../index'
+
+describe('Task class', () => {
+  it('Identity test', async () => {
+    const identity = new Task(function (argv) {
+      return argv
+    })
+
+    const { bar } = await identity.run({ bar: true })
+    const { foo } = await identity.run({ foo: true })
+
+    expect(bar).toBe(true)
+    expect(foo).toBe(true)
+  })
+
+  it('Identity types test', async () => {
+    interface Identity {
+      bar?: boolean
+      foo?: boolean
+    }
+    const caller = async function (argv: Identity): Promise<Identity> {
+      return argv
+    }
+
+    const identity = new Task(caller)
+
+    const { bar } = await identity.run({ bar: true })
+    const { foo } = await identity.run({ foo: true })
+
+    expect(bar).toBe(true)
+    expect(foo).toBe(true)
+  })
+
+  it('Add test', async () => {
+    const add2 = new Task(function (int: number) {
+      return int + 2
+    })
+
+    const six = await add2.run(4)
+    const seven = await add2.run(5)
+
+    expect(six).toBe(6)
+    expect(seven).toBe(7)
+  })
+
+  it('getMode proxy test', async () => {
+    const proxy = new Task(function (int: number) {
+      return int + 2
+    }, {
+      mode: 'proxy'
+    })
+
+    const proxyPass = new Task(function (int: number) {
+      return int + 2
+    }, {
+      mode: 'proxy-pass'
+    })
+
+    expect(proxy.getMode()).toBe('proxy')
+    expect(proxyPass.getMode()).toBe('proxy-pass')
+  })
+})

package/src/test/run-boundary.test.ts

@@ -0,0 +1,64 @@
+import { createBoundary } from '../utils/boundary'
+
+describe('Run boundary tests', function () {
+  it('Should add a run record', async function () {
+    const identity = createBoundary(async function (argv) {
+      return argv
+    })
+
+    identity.startRun()
+    await identity({ value: 5 })
+
+    const runTape = identity.getRunData()
+
+    expect(runTape.length).toBe(1)
+    expect(runTape[0]).toEqual({ input: [{ value: 5 }], output: { value: 5 } })
+  })
+
+  it('Should only add a record if run is active', async function () {
+    const identity = createBoundary(async function (argv) {
+      return argv
+    })
+
+    await identity({ value: 5 })
+
+    const runTape = identity.getRunData()
+
+    expect(runTape.length).toBe(0)
+  })
+
+  it('Shouldn\'t add after run stoped', async function () {
+    const identity = createBoundary(async function (argv) {
+      return argv
+    })
+
+    identity.startRun()
+    await identity({ value: 5 })
+
+    identity.stopRun()
+    await identity({ value: 5 })
+
+    const runTape = identity.getRunData()
+
+    expect(runTape.length).toBe(1)
+    expect(runTape[0]).toEqual({ input: [{ value: 5 }], output: { value: 5 } })
+  })
+
+  it('Should have run elements from this run', async function () {
+    const identity = createBoundary(async function (argv) {
+      return argv
+    })
+
+    identity.startRun()
+    await identity({ value: 4 })
+    identity.stopRun()
+
+    identity.startRun()
+    await identity({ value: 5 })
+
+    const runTape = identity.getRunData()
+
+    expect(runTape.length).toBe(1)
+    expect(runTape[0]).toEqual({ input: [{ value: 5 }], output: { value: 5 } })
+  })
+})

package/src/test/run-without-args.test.ts

@@ -0,0 +1,33 @@
+import { Task } from '../index'
+
+describe('Task run without arguments', () => {
+  it('should run a task with no arguments', async () => {
+    // Create a task that doesn't require arguments
+    const noArgsTask = new Task(function () {
+      return 'success'
+    })
+
+    // Call run without passing any arguments
+    const result = await noArgsTask.run()
+
+    // Verify the result
+    expect(result).toBe('success')
+  })
+
+  it('should run a task with optional arguments', async () => {
+    // Create a task with optional arguments
+    const optionalArgsTask = new Task(function (argv?: { value?: string }) {
+      return argv?.value || 'default'
+    })
+
+    // Call run without passing any arguments
+    const defaultResult = await optionalArgsTask.run()
+
+    // Call run with arguments for comparison
+    const customResult = await optionalArgsTask.run({ value: 'custom' })
+
+    // Verify the results
+    expect(defaultResult).toBe('default')
+    expect(customResult).toBe('custom')
+  })
+})

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

@@ -0,0 +1,137 @@
+import { createTask, Schema } from '../index'
+
+// Need to add proxy cache mode to the boundaries
+describe('Boundaries tasks tests', () => {
+  it('Indentity + boundaries test', async () => {
+    // Create a schema for the task
+    const schema = new Schema({})
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask
+    const indentity = createTask(
+      schema,
+      boundaries,
+      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 })
+
+    expect(object).toEqual({ bar: true, foo: false })
+    expect(foo).toBe(true)
+  })
+
+  it('Indentity test with tape data', async () => {
+    // Create a schema for the task
+    const schema = new Schema({})
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (): Promise<{ foo: boolean }> => {
+        // Return an empty implementation, the actual data will come from boundariesData
+        return { foo: false }
+      }
+    }
+
+    // Create the task using createTask with boundariesData
+    const indentity = createTask(
+      schema,
+      boundaries,
+      async (argv, boundaries) => {
+        const externalData = await boundaries.fetchExternalData()
+        return { ...externalData, ...argv }
+      },
+      {
+        boundariesData: {
+          fetchExternalData: [
+            { input: [], output: { foo: false } }
+          ]
+        },
+        mode: 'proxy-pass'
+      }
+    )
+
+    const object = await indentity.run({ bar: true })
+    const { foo } = await indentity.run({ foo: true })
+
+    expect(object).toEqual({ bar: true, foo: false })
+    expect(foo).toBe(true)
+  })
+
+  it('Add task with boundaries test', async () => {
+    // Create a schema for the task that accepts a number
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (int: number): Promise<number> => {
+        return int * 2
+      }
+    }
+
+    // Create the task using createTask
+    const add = createTask(
+      schema,
+      boundaries,
+      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 })
+
+    expect(six).toBe(6)
+    expect(seven).toBe(7)
+  })
+
+  it('Add task + boundaries + tape test', async () => {
+    // Create a schema for the task that accepts a number
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (int: number): Promise<number> => {
+        return int * 2
+      }
+    }
+
+    // Create the task using createTask with boundariesData
+    const add = createTask(
+      schema,
+      boundaries,
+      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'
+      }
+    )
+
+    const six = await add.run({ value: 4 }) // From tape data
+    const fifteen = await add.run({ value: 5 })
+
+    expect(six).toBe(6)
+    expect(fifteen).toBe(15)
+  })
+})