@forgehive/task 0.1.4 → 0.1.6

package/src/test/task-boundary-mocking.test.ts

@@ -0,0 +1,116 @@
+import { createTask, Schema } from '../index'
+import { createMockBoundary } from '../utils/mock'
+
+describe('Task boundary mocking', () => {
+  it('can mock specific boundaries for testing', async () => {
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      fetchExternalData: async (int: number): Promise<number> => {
+        // This would normally fetch data from an external source
+        return int * 2
+      }
+    }
+
+    // Create the task using createTask
+    const multiplyTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { fetchExternalData }) {
+        const result = value * await fetchExternalData(value)
+        return result
+      }
+    )
+
+    // Create mock for fetchExternalData boundary that returns a specific value
+    const mockFetchData = jest.fn().mockResolvedValue(5)
+    const wrappedMockFetchData = createMockBoundary(mockFetchData)
+
+    // Mock only the fetchExternalData boundary, leaving logData boundary as is
+    multiplyTask.mockBoundary('fetchExternalData', wrappedMockFetchData)
+
+    // Run the task with mocked boundary
+    const result = await multiplyTask.run({ value: 3 })
+
+    // Verify the correct result was returned
+    // Since fetchExternalData is mocked to always return 5, result should be 3 * 5 = 15
+    expect(result).toBe(15)
+
+    // Verify the mock was called with correct arguments
+    expect(mockFetchData).toHaveBeenCalledWith(3)
+    expect(mockFetchData).toHaveBeenCalledTimes(1)
+
+    // Reset the mocks
+    multiplyTask.resetMocks()
+
+    // Run the task again, now with original boundaries
+    const result2 = await multiplyTask.run({ value: 3 })
+
+    // With original boundaries, result should be 3 * (3 * 2) = 18
+    expect(result2).toBe(18)
+  })
+
+  it('can mock multiple boundaries at once', async () => {
+    // Create a schema for the task
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries
+    const boundaries = {
+      doubleValue: async (int: number): Promise<number> => {
+        return int * 2
+      },
+      tripleValue: async (int: number): Promise<number> => {
+        return int * 3
+      }
+    }
+
+    // Create the task
+    const calculateTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { doubleValue, tripleValue }) {
+        const doubled = await doubleValue(value)
+        const tripled = await tripleValue(value)
+        return doubled + tripled
+      }
+    )
+
+    // Create wrapped mock functions
+    const mockDoubleValue = jest.fn().mockResolvedValue(10)
+    const mockTripleValue = jest.fn().mockResolvedValue(20)
+
+    // Mock both boundaries
+    calculateTask.mockBoundary('doubleValue', createMockBoundary(mockDoubleValue))
+    calculateTask.mockBoundary('tripleValue', createMockBoundary(mockTripleValue))
+
+    // Run the task with both mocked boundaries
+    const result = await calculateTask.run({ value: 5 })
+
+    // Result should be 10 + 20 = 30
+    expect(result).toBe(30)
+
+    // Reset only the doubleValue mock
+    calculateTask.resetMock('doubleValue')
+
+    // Run the task with only tripleValue mocked
+    const result2 = await calculateTask.run({ value: 5 })
+
+    // Result should be (5 * 2) + 20 = 30
+    expect(result2).toBe(30)
+
+    // Reset all mocks
+    calculateTask.resetMocks()
+
+    // Run the task with original boundaries
+    const result3 = await calculateTask.run({ value: 5 })
+
+    // Result should be (5 * 2) + (5 * 3) = 25
+    expect(result3).toBe(25)
+  })
+})

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

@@ -1,4 +1,4 @@
-import { createTask, Schema } from '../index'
+import { createTask, Schema, TaskRecord } from '../index'
 
 // Need to add proxy cache mode to the boundaries
 describe('Boundaries tasks tests', () => {
@@ -134,4 +134,201 @@ describe('Boundaries tasks tests', () => {
     expect(six).toBe(6)
     expect(fifteen).toBe(15)
   })
+
+  it('Multiple parallel task runs with boundaries', async () => {
+    // Define a type for the boundary data structure we expect
+    type BoundaryData = {
+      input: unknown[];
+      output?: unknown;
+    };
+
+    // Define a type for the record boundaries
+    interface RecordBoundaries {
+      fetchExternalData: BoundaryData[];
+    }
+
+    // Use the correct type definition for records
+    const records: TaskRecord<{value: number}, Promise<number>>[] = []
+
+    // Create a schema for the task that accepts a number
+    const schema = new Schema({
+      value: Schema.number()
+    })
+
+    // Define the boundaries with a function that returns different values based on input
+    const boundaries = {
+      fetchExternalData: async (int: number): Promise<number> => {
+        return int * 2
+      }
+    }
+
+    // Create the task using createTask
+    const multiplyTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { fetchExternalData}) {
+        const externalData: number = await fetchExternalData(value)
+        return value * externalData
+      }
+    )
+
+    multiplyTask.addListener((record) => {
+      records.push(record)
+    })
+
+    // Run multiple tasks in parallel
+    const results = await Promise.all([
+      multiplyTask.run({ value: 2 }),
+      multiplyTask.run({ value: 3 }),
+      multiplyTask.run({ value: 4 })
+    ])
+
+    // Check the results
+    expect(results).toEqual([8, 18, 32])
+
+    // Test records array
+    // Should have exactly 3 elements (one for each task run)
+    expect(records.length).toBe(3)
+
+    // Sort records by input value for consistent testing
+    const sortedRecords = [...records].sort((a, b) => a.input.value - b.input.value)
+
+    // Check record for first task (value: 2)
+    expect(sortedRecords[0].input).toEqual({ value: 2 })
+    expect(sortedRecords[0].output).toBe(8)
+
+    // Use type assertion to access the boundary data safely
+    const boundaries0 = sortedRecords[0].boundaries as unknown as RecordBoundaries
+    expect(boundaries0.fetchExternalData).toHaveLength(1)
+    expect(boundaries0.fetchExternalData[0].input).toEqual([2])
+    expect(boundaries0.fetchExternalData[0].output).toBe(4)
+
+    // Check record for second task (value: 3)
+    expect(sortedRecords[1].input).toEqual({ value: 3 })
+    expect(sortedRecords[1].output).toBe(18)
+
+    // Use type assertion to access the boundary data safely
+    const boundaries1 = sortedRecords[1].boundaries as unknown as RecordBoundaries
+    expect(boundaries1.fetchExternalData).toHaveLength(1)
+    expect(boundaries1.fetchExternalData[0].input).toEqual([3])
+    expect(boundaries1.fetchExternalData[0].output).toBe(6)
+
+    // Check record for third task (value: 4)
+    expect(sortedRecords[2].input).toEqual({ value: 4 })
+    expect(sortedRecords[2].output).toBe(32)
+
+    // Use type assertion to access the boundary data safely
+    const boundaries2 = sortedRecords[2].boundaries as unknown as RecordBoundaries
+    expect(boundaries2.fetchExternalData).toHaveLength(1)
+    expect(boundaries2.fetchExternalData[0].input).toEqual([4])
+    expect(boundaries2.fetchExternalData[0].output).toBe(8)
+  })
+
+  it('Boundary data accumulates run data correctly', 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 multiplyTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { fetchExternalData }) {
+        const externalData: number = await fetchExternalData(value)
+        return value * externalData
+      }
+    )
+
+    // Run task with value 2
+    await multiplyTask.run({ value: 2 })
+
+    // Get boundary data after first run
+    const boundariesData1 = multiplyTask.getBondariesData()
+
+    // Verify data structure
+    expect(boundariesData1).toHaveProperty('fetchExternalData')
+    expect(Array.isArray(boundariesData1.fetchExternalData)).toBe(true)
+    expect(boundariesData1.fetchExternalData).toHaveLength(1)
+
+    // Verify the tape entry for first run
+    const firstRunTape = boundariesData1.fetchExternalData as Array<{input: unknown[], output: unknown}>
+    expect(firstRunTape[0].input).toEqual([2])
+    expect(firstRunTape[0].output).toBe(4)
+
+    // Run task with value 3
+    await multiplyTask.run({ value: 3 })
+
+    // Get boundary data after second run
+    const boundariesData2 = multiplyTask.getBondariesData()
+
+    // Tape should now have 2 entries
+    expect(boundariesData2.fetchExternalData).toHaveLength(2)
+
+    // Sort the tape by input value for consistent testing
+    const secondRunTape = boundariesData2.fetchExternalData as Array<{input: unknown[], output: unknown}>
+    const sortedTape = [...secondRunTape].sort((a, b) => (a.input[0] as number) - (b.input[0] as number))
+
+    // First entry should still be the same
+    expect(sortedTape[0].input).toEqual([2])
+    expect(sortedTape[0].output).toBe(4)
+
+    // Second entry should be from the second run
+    expect(sortedTape[1].input).toEqual([3])
+    expect(sortedTape[1].output).toBe(6)
+
+    // Run task with value 4
+    await multiplyTask.run({ value: 4 })
+
+    // Get boundary data after third run
+    const boundariesData3 = multiplyTask.getBondariesData()
+
+    // Tape should now have 3 entries
+    expect(boundariesData3.fetchExternalData).toHaveLength(3)
+
+    // Sort the tape again
+    const thirdRunTape = boundariesData3.fetchExternalData as Array<{input: unknown[], output: unknown}>
+    const finalSortedTape = [...thirdRunTape].sort((a, b) => (a.input[0] as number) - (b.input[0] as number))
+
+    // Verify all three entries
+    expect(finalSortedTape[0].input).toEqual([2])
+    expect(finalSortedTape[0].output).toBe(4)
+
+    expect(finalSortedTape[1].input).toEqual([3])
+    expect(finalSortedTape[1].output).toBe(6)
+
+    expect(finalSortedTape[2].input).toEqual([4])
+    expect(finalSortedTape[2].output).toBe(8)
+
+    // Verify tape can be used for replay in proxy-pass mode
+    const replayTask = createTask(
+      schema,
+      boundaries,
+      async function ({ value }, { fetchExternalData }) {
+        const externalData: number = await fetchExternalData(value)
+        return value * externalData
+      },
+      {
+        boundariesData: boundariesData3,
+        mode: 'proxy-pass'
+      }
+    )
+
+    // Run task with all three values from the tape
+    const result2 = await replayTask.run({ value: 2 })
+    const result3 = await replayTask.run({ value: 3 })
+    const result4 = await replayTask.run({ value: 4 })
+
+    // Results should match original runs
+    expect(result2).toBe(8)
+    expect(result3).toBe(18)
+    expect(result4).toBe(32)
+  })
 })

package/src/test/validation.test.ts

@@ -34,8 +34,22 @@ describe('Validation tests', () => {
       // If we get here, the test should fail
       expect('no error thrown').toBeUndefined()
     } catch (e) {
-      // Test passes if we get here
-      expect(e).toBeDefined()
+      const error = e as Error
+
+      expect(error.message).toEqual('Invalid input on: value: Expected number, received null')
+    }
+  })
+
+  it('Should provide detailed error messages', async () => {
+    try {
+      await task.run({ value: 'null' })
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e: unknown) {
+      const error = e as Error
+
+      // Test the error message format
+      expect(error.message).toEqual('Invalid input on: value: Expected number, received string')
     }
   })
 
@@ -50,7 +64,7 @@ describe('Validation tests on param', () => {
 
   beforeEach(() => {
     const schema = new Schema({
-      value: Schema.number()
+      name: Schema.string()
     })
 
     task = new Task(function (argv: InferSchema<typeof schema>) {
@@ -61,35 +75,32 @@ describe('Validation tests on param', () => {
   })
 
   it('Should be invalid', () => {
-    const check = task.isValid({ value: null })
+    const check = task.isValid({ name: null })
 
     expect(check).toBe(false)
   })
 
   it('Should be valid', () => {
-    const check = task.isValid({ value: 5 })
+    const check = task.isValid({ name: 'John Doe' })
 
     expect(check).toBe(true)
   })
 
   it('Should validate data as part of run function', async () => {
     try {
-      await task.run({ value: null })
+      await task.run({ name: null })
       // If we get here, the test should fail
       expect('no error thrown').toBeUndefined()
     } catch (e) {
-      // Test passes if we get here
-      expect(e).toBeDefined()
+      const error = e as Error
+      expect(error.message).toEqual('Invalid input on: name: Expected string, received null')
     }
   })
 
   it('Should work well', async () => {
-    try {
-      const result = await task.run({ value: 5 })
-      expect(result.value).toBe(5)
-    } catch (e) {
-      expect('error thrown: ' + e).toBeUndefined()
-    }
+    const result = await task.run({ name: 'John Doe' })
+
+    expect(result.name).toBe('John Doe')
   })
 })
 
@@ -115,8 +126,8 @@ describe('Validation multiple values tests', () => {
       // If we get here, the test should fail
       expect('no error thrown').toBeUndefined()
     } catch (e) {
-      // Test passes if we get here
-      expect(e).toBeDefined()
+      const error = e as Error
+      expect(error.message).toEqual('Invalid input on: value: Expected number, received null, increment: Required')
     }
   })
 
@@ -126,8 +137,8 @@ describe('Validation multiple values tests', () => {
       // If we get here, the test should fail
       expect('no error thrown').toBeUndefined()
     } catch (e) {
-      // Test passes if we get here
-      expect(e).toBeDefined()
+      const error = e as Error
+      expect(error.message).toEqual('Invalid input on: increment: Required')
     }
   })
 
@@ -192,3 +203,171 @@ describe('Set Schema', () => {
     expect(schema).toBeUndefined()
   })
 })
+
+describe('Multiple validation errors', () => {
+  let task: TaskInstanceType
+
+  beforeEach(() => {
+    const schema = new Schema({
+      name: Schema.string(),
+      age: Schema.number(),
+      email: Schema.string().email()
+    })
+
+    task = new Task(function (argv: InferSchema<typeof schema>) {
+      return argv
+    }, {
+      schema
+    })
+  })
+
+  it('Should report all validation errors', async () => {
+    try {
+      await task.run({ name: 123, age: 'twenty', email: 'invalid-email' })
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e: unknown) {
+      const error = e as Error
+      // Test that multiple errors are reported
+      expect(error.message).toContain('Invalid input on')
+      expect(error.message).toContain('name: Expected string, received number')
+      expect(error.message).toContain('age: Expected number, received string')
+      expect(error.message).toContain('email: Invalid email')
+    }
+  })
+})
+
+describe('Array validation tests', () => {
+  let task: TaskInstanceType
+
+  beforeEach(() => {
+    const schema = new Schema({
+      tags: Schema.array(Schema.string())
+    })
+
+    task = new Task(function (argv: InferSchema<typeof schema>) {
+      return argv
+    }, {
+      schema
+    })
+  })
+
+  it('Should be invalid with non-array value', () => {
+    const check = task.isValid({ tags: 'not an array' })
+    expect(check).toBe(false)
+  })
+
+  it('Should be invalid with array containing non-string items', () => {
+    const check = task.isValid({ tags: ['valid', 123, true] })
+    expect(check).toBe(false)
+  })
+
+  it('Should be valid with string array', () => {
+    const check = task.isValid({ tags: ['tag1', 'tag2', 'tag3'] })
+    expect(check).toBe(true)
+  })
+
+  it('Should validate array data on run', async () => {
+    try {
+      await task.run({ tags: 'not an array' })
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e) {
+      const error = e as Error
+      expect(error.message).toEqual('Invalid input on: tags: Expected array, received string')
+    }
+  })
+
+  it('Should validate array items on run', async () => {
+    try {
+      await task.run({ tags: ['valid', 123, true] })
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e) {
+      const error = e as Error
+      expect(error.message).toContain('Invalid input on')
+      expect(error.message).toContain('tags.1: Expected string, received number')
+      expect(error.message).toContain('tags.2: Expected string, received boolean')
+    }
+  })
+
+  it('Should work with valid string array', async () => {
+    const result = await task.run({ tags: ['tag1', 'tag2', 'tag3'] })
+    expect(result.tags).toEqual(['tag1', 'tag2', 'tag3'])
+  })
+})
+
+describe('MixedRecord validation tests', () => {
+  let task: TaskInstanceType
+
+  beforeEach(() => {
+    const schema = new Schema({
+      metadata: Schema.mixedRecord()
+    })
+
+    task = new Task(function (argv: InferSchema<typeof schema>) {
+      return argv
+    }, {
+      schema
+    })
+  })
+
+  it('Should be invalid with non-object value', () => {
+    const check = task.isValid({ metadata: 'not an object' })
+    expect(check).toBe(false)
+  })
+
+  it('Should be invalid with non-string keys', () => {
+    // In JavaScript, object keys are always coerced to strings, so this actually becomes a valid record
+    // with a string key "123"
+    const check = task.isValid({ metadata: { 123: 'value' }})
+    expect(check).toBe(true)
+  })
+
+  it('Should be valid with mixed value types', () => {
+    const check = task.isValid({
+      metadata: {
+        stringValue: 'text',
+        numberValue: 42,
+        booleanValue: true
+      }
+    })
+    expect(check).toBe(true)
+  })
+
+  it('Should validate record type on run', async () => {
+    try {
+      await task.run({ metadata: 'not an object' })
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e) {
+      const error = e as Error
+      expect(error.message).toEqual('Invalid input on: metadata: Expected object, received string')
+    }
+  })
+
+  it('Should validate value types on run', async () => {
+    try {
+      await task.run({ metadata: { valid: 'string', invalid: { nested: 'object' } }})
+      // If we get here, the test should fail
+      expect('no error thrown').toBeUndefined()
+    } catch (e) {
+      const error = e as Error
+      expect(error.message).toContain('Invalid input on')
+      // The actual error message from Zod for this case
+      expect(error.message).toContain('metadata.invalid: Invalid input')
+    }
+  })
+
+  it('Should work with valid mixed record', async () => {
+    const validData = {
+      metadata: {
+        stringValue: 'text',
+        numberValue: 42,
+        booleanValue: true
+      }
+    }
+    const result = await task.run(validData)
+    expect(result).toEqual(validData)
+  })
+})

package/src/utils/mock.ts

@@ -0,0 +1,45 @@
+import { type WrappedBoundaryFunction, type Mode, type BoundaryRecord } from './boundary'
+
+/**
+ * Creates a wrapped boundary function from any function
+ * This is framework-agnostic and can be used with or without testing libraries like Jest
+ *
+ * @param fn The function to wrap as a boundary
+ * @param options Optional configuration for the mock boundary
+ * @returns A function wrapped as a WrappedBoundaryFunction
+ */
+export function createMockBoundary<T extends (...args: unknown[]) => unknown>(
+  fn: T,
+  options: {
+    getTape?: () => Array<BoundaryRecord>,
+    setTape?: (tape: Array<BoundaryRecord>) => void,
+    getMode?: () => Mode,
+    setMode?: (mode: Mode) => void,
+    getRunData?: () => Array<BoundaryRecord>
+  } = {}
+): WrappedBoundaryFunction {
+  // Use provided functions or create simple implementations
+  const mockGetTape = options.getTape || ((): BoundaryRecord[] => [])
+  const mockSetTape = options.setTape || ((_tape: BoundaryRecord[]): void => {})
+  const mockGetMode = options.getMode || ((): Mode => 'proxy')
+  const mockSetMode = options.setMode || ((_mode: Mode): void => {})
+  const mockGetRunData = options.getRunData || ((): BoundaryRecord[] => [])
+
+  // Empty functions for start/stop run
+  const mockStartRun = (): void => {}
+  const mockStopRun = (): void => {}
+
+  // Cast the function to a WrappedBoundaryFunction
+  const wrappedFn = fn as unknown as WrappedBoundaryFunction
+
+  // Add required methods to satisfy the interface
+  wrappedFn.getTape = mockGetTape
+  wrappedFn.setTape = mockSetTape
+  wrappedFn.getMode = mockGetMode
+  wrappedFn.setMode = mockSetMode
+  wrappedFn.startRun = mockStartRun
+  wrappedFn.stopRun = mockStopRun
+  wrappedFn.getRunData = mockGetRunData
+
+  return wrappedFn
+}