@forgehive/task 0.1.5 → 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/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
+}