@pikku/core 0.12.107 → 0.12.111

package/src/services/in-memory-workflow-service.test.ts

@@ -1,430 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert'
-import { InMemoryWorkflowService } from './in-memory-workflow-service.js'
-import { getQueueWorkers } from '../wirings/queue/queue-runner.js'
-import { pikkuState, resetPikkuState } from '../pikku-state.js'
-
-let service: InMemoryWorkflowService
-
-beforeEach(() => {
-  service = new InMemoryWorkflowService()
-})
-
-describe('InMemoryWorkflowService', () => {
-  describe('createRun', () => {
-    test('should create a run and return a UUID', async () => {
-      const runId = await service.createRun(
-        'test-workflow',
-        { key: 'val' },
-        true,
-        'hash1',
-        { type: 'test' } as any
-      )
-      assert.ok(runId)
-      assert.strictEqual(typeof runId, 'string')
-    })
-
-    test('should store the run with correct properties', async () => {
-      const runId = await service.createRun(
-        'my-workflow',
-        { input: 1 },
-        false,
-        'hash2',
-        { type: 'http' } as any
-      )
-      const run = await service.getRun(runId)
-      assert.ok(run)
-      assert.strictEqual(run.workflow, 'my-workflow')
-      assert.strictEqual(run.status, 'running')
-      assert.deepStrictEqual(run.input, { input: 1 })
-      assert.strictEqual(run.inline, false)
-      assert.strictEqual(run.graphHash, 'hash2')
-    })
-
-    test('should initialize empty step history and run state', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const history = await service.getRunHistory(runId)
-      assert.deepStrictEqual(history, [])
-      const state = await service.getRunState(runId)
-      assert.deepStrictEqual(state, {})
-    })
-
-    test('should persist deterministic planned steps metadata', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any, {
-        deterministic: true,
-        plannedSteps: [{ stepName: 'Step 1' }, { stepName: 'Step 2' }],
-      })
-
-      const run = await service.getRun(runId)
-      assert.strictEqual(run?.deterministic, true)
-      assert.deepStrictEqual(run?.plannedSteps, [
-        { stepName: 'Step 1' },
-        { stepName: 'Step 2' },
-      ])
-    })
-  })
-
-  describe('getRun', () => {
-    test('should return null for non-existent run', async () => {
-      const run = await service.getRun('non-existent')
-      assert.strictEqual(run, null)
-    })
-  })
-
-  describe('updateRunStatus', () => {
-    test('should update run status', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      await service.updateRunStatus(runId, 'succeeded', { result: 'done' })
-      const run = await service.getRun(runId)
-      assert.strictEqual(run!.status, 'succeeded')
-      assert.deepStrictEqual(run!.output, { result: 'done' })
-    })
-
-    test('should update run with error', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const error = { name: 'Error', message: 'Failed' }
-      await service.updateRunStatus(runId, 'failed', undefined, error)
-      const run = await service.getRun(runId)
-      assert.strictEqual(run!.status, 'failed')
-      assert.deepStrictEqual(run!.error, error)
-    })
-
-    test('should handle non-existent run gracefully', async () => {
-      await service.updateRunStatus('non-existent', 'failed')
-    })
-  })
-
-  describe('step lifecycle', () => {
-    test('should insert a step in pending state', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', 'rpcFunc', {
-        data: 1,
-      })
-      assert.strictEqual(step.status, 'pending')
-      assert.strictEqual(step.attemptCount, 1)
-      assert.ok(step.stepId)
-    })
-
-    test('should store step options', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(
-        runId,
-        'step1',
-        null,
-        {},
-        { retries: 3, retryDelay: 1000 }
-      )
-      assert.strictEqual(step.retries, 3)
-      assert.strictEqual(step.retryDelay, 1000)
-    })
-
-    test('should transition step to running', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      await service.setStepRunning(step.stepId)
-      const updated = await service.getStepState(runId, 'step1')
-      assert.strictEqual(updated.status, 'running')
-      assert.ok(updated.runningAt)
-    })
-
-    test('should transition step to scheduled', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      await service.setStepScheduled(step.stepId)
-      const updated = await service.getStepState(runId, 'step1')
-      assert.strictEqual(updated.status, 'scheduled')
-      assert.ok(updated.scheduledAt)
-    })
-
-    test('should transition step to succeeded with result', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      await service.setStepResult(step.stepId, { output: 'done' })
-      const updated = await service.getStepState(runId, 'step1')
-      assert.strictEqual(updated.status, 'succeeded')
-      assert.deepStrictEqual(updated.result, { output: 'done' })
-      assert.ok(updated.succeededAt)
-    })
-
-    test('should transition step to failed with error', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      const error = new Error('step failed')
-      await service.setStepError(step.stepId, error)
-      const updated = await service.getStepState(runId, 'step1')
-      assert.strictEqual(updated.status, 'failed')
-      assert.strictEqual(updated.error!.message, 'step failed')
-      assert.ok(updated.failedAt)
-    })
-
-    test('should throw for non-existent step', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      await assert.rejects(
-        () => service.getStepState(runId, 'non-existent'),
-        /Step not found/
-      )
-    })
-  })
-
-  describe('retry attempts', () => {
-    test('should create a retry attempt with incremented count', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(
-        runId,
-        'step1',
-        'rpc',
-        {},
-        { retries: 2 }
-      )
-      await service.setStepError(step.stepId, new Error('fail'))
-      const retry = await service.createRetryAttempt(step.stepId, 'pending')
-      assert.strictEqual(retry.attemptCount, 2)
-      assert.strictEqual(retry.status, 'pending')
-    })
-
-    test('should set running status on retry if specified', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      await service.setStepError(step.stepId, new Error('fail'))
-      const retry = await service.createRetryAttempt(step.stepId, 'running')
-      assert.strictEqual(retry.status, 'running')
-      assert.ok(retry.runningAt)
-    })
-
-    test('should throw for non-existent step retry', async () => {
-      await assert.rejects(
-        () => service.createRetryAttempt('non-existent', 'pending'),
-        { message: 'Step not found: non-existent' }
-      )
-    })
-
-    test('should add retry to history', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'step1', null, {})
-      await service.setStepError(step.stepId, new Error('fail'))
-      await service.createRetryAttempt(step.stepId, 'pending')
-      const history = await service.getRunHistory(runId)
-      assert.strictEqual(history.length, 2)
-    })
-  })
-
-  describe('run state', () => {
-    test('should update and get run state', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      await service.updateRunState(runId, 'counter', 5)
-      await service.updateRunState(runId, 'status', 'active')
-      const state = await service.getRunState(runId)
-      assert.deepStrictEqual(state, { counter: 5, status: 'active' })
-    })
-
-    test('should return empty object for non-existent run state', async () => {
-      const state = await service.getRunState('non-existent')
-      assert.deepStrictEqual(state, {})
-    })
-  })
-
-  describe('graph state', () => {
-    test('should track completed and failed nodes', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step1 = await service.insertStepState(runId, 'node1', null, {})
-      await service.setStepResult(step1.stepId, 'ok')
-      const step2 = await service.insertStepState(
-        runId,
-        'node2',
-        null,
-        {},
-        { retries: 0 }
-      )
-      await service.setStepError(step2.stepId, new Error('fail'))
-
-      const state = await service.getCompletedGraphState(runId)
-      assert.deepStrictEqual(state.completedNodeIds, ['node1'])
-      assert.deepStrictEqual(state.failedNodeIds, ['node2'])
-    })
-
-    test('should not count failed step as terminal if retries remain', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(
-        runId,
-        'node1',
-        null,
-        {},
-        { retries: 2 }
-      )
-      await service.setStepError(step.stepId, new Error('fail'))
-
-      const state = await service.getCompletedGraphState(runId)
-      assert.deepStrictEqual(state.failedNodeIds, [])
-    })
-
-    test('should get node results', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step1 = await service.insertStepState(runId, 'node1', null, {})
-      await service.setStepResult(step1.stepId, { value: 42 })
-      await service.insertStepState(runId, 'node2', null, {})
-
-      const results = await service.getNodeResults(runId, ['node1', 'node2'])
-      assert.deepStrictEqual(results, { node1: { value: 42 } })
-    })
-  })
-
-  describe('branch keys', () => {
-    test('should set and track branch keys', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'branch-node', null, {})
-      await service.setBranchKey(runId, 'branch-node', 'left')
-
-      const state = await service.getCompletedGraphState(runId)
-      assert.strictEqual(state.branchKeys['branch-node'], 'left')
-    })
-
-    test('should set branch taken by stepId', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      const step = await service.insertStepState(runId, 'node1', null, {})
-      await service.setBranchTaken(step.stepId, 'right')
-
-      const state = await service.getCompletedGraphState(runId)
-      assert.strictEqual(state.branchKeys['node1'], 'right')
-    })
-  })
-
-  describe('workflow versions', () => {
-    test('should upsert and get workflow version', async () => {
-      const graph = { nodes: ['a', 'b'] }
-      await service.upsertWorkflowVersion('myWf', 'hash1', graph, 'source-code')
-
-      const version = await service.getWorkflowVersion('myWf', 'hash1')
-      assert.deepStrictEqual(version, { graph, source: 'source-code' })
-    })
-
-    test('should return null for non-existent version', async () => {
-      const version = await service.getWorkflowVersion('unknown', 'unknown')
-      assert.strictEqual(version, null)
-    })
-  })
-
-  describe('locking', () => {
-    test('withRunLock should execute function directly', async () => {
-      const result = await service.withRunLock('run1', async () => 'result')
-      assert.strictEqual(result, 'result')
-    })
-
-    test('withStepLock should execute function directly', async () => {
-      const result = await service.withStepLock('run1', 'step1', async () => 42)
-      assert.strictEqual(result, 42)
-    })
-  })
-
-  describe('close', () => {
-    test('should clear all internal state', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      await service.insertStepState(runId, 'step1', null, {})
-      await service.updateRunState(runId, 'key', 'val')
-      await service.upsertWorkflowVersion('wf', 'h', {}, 'src')
-
-      await service.close()
-
-      assert.strictEqual(await service.getRun(runId), null)
-      const history = await service.getRunHistory(runId)
-      assert.deepStrictEqual(history, [])
-      const state = await service.getRunState(runId)
-      assert.deepStrictEqual(state, {})
-      const version = await service.getWorkflowVersion('wf', 'h')
-      assert.strictEqual(version, null)
-    })
-  })
-
-  describe('run history', () => {
-    test('should track step insertions in history', async () => {
-      const runId = await service.createRun('wf', {}, true, 'h', {} as any)
-      await service.insertStepState(runId, 'step1', null, {})
-      await service.insertStepState(runId, 'step2', null, {})
-
-      const history = await service.getRunHistory(runId)
-      assert.strictEqual(history.length, 2)
-      assert.strictEqual(history[0].stepName, 'step1')
-      assert.strictEqual(history[1].stepName, 'step2')
-    })
-
-    test('should return empty array for non-existent run', async () => {
-      const history = await service.getRunHistory('non-existent')
-      assert.deepStrictEqual(history, [])
-    })
-  })
-
-  describe('queue worker registration', () => {
-    test('wireQueueWorkers registers workflow queues added after construction', () => {
-      const stepQueue = 'wf-step-regression-enrich'
-      const orchQueue = 'wf-orchestrator-regression-onboarding'
-
-      const ws = new InMemoryWorkflowService()
-
-      const queueMeta = pikkuState(null, 'queue', 'meta')
-      queueMeta[stepQueue] = {
-        name: stepQueue,
-        pikkuFuncId: 'pikkuWorkflowWorker:regressionEnrich',
-      }
-      queueMeta[orchQueue] = {
-        name: orchQueue,
-        pikkuFuncId: 'pikkuWorkflowOrchestrator:regressionOnboarding',
-      }
-
-      assert.strictEqual(getQueueWorkers().has(stepQueue), false)
-      assert.strictEqual(getQueueWorkers().has(orchQueue), false)
-
-      ws.wireQueueWorkers()
-
-      assert.strictEqual(getQueueWorkers().has(stepQueue), true)
-      assert.strictEqual(getQueueWorkers().has(orchQueue), true)
-    })
-
-    test('shared-groups leaves per-workflow queues unconsumed', () => {
-      const orchQueue = 'wf-orchestrator-shared-strategy-check'
-
-      const queueMeta = pikkuState(null, 'queue', 'meta')
-      queueMeta[orchQueue] = {
-        name: orchQueue,
-        pikkuFuncId: 'pikkuWorkflowOrchestrator:sharedStrategyCheck',
-      }
-
-      const ws = new InMemoryWorkflowService({
-        queueStrategy: 'shared-groups',
-      })
-      ws.wireQueueWorkers()
-
-      // The whole point: one set of pollers, not one per workflow.
-      assert.strictEqual(getQueueWorkers().has(orchQueue), false)
-      assert.strictEqual(
-        getQueueWorkers().has('pikku-workflow-orchestrator'),
-        true
-      )
-    })
-
-    test('shared-groups caps how much of the shared queue one workflow takes', () => {
-      // registerWorkflowFunc is first-write-wins, so start from clean state
-      // rather than inheriting the shared queues an earlier test registered.
-      resetPikkuState()
-      const ws = new InMemoryWorkflowService({
-        queueStrategy: 'shared-groups',
-        queueConcurrency: 20,
-        queueGroupConcurrency: 3,
-      })
-      ws.wireQueueWorkers()
-
-      const worker = getQueueWorkers().get('pikku-workflow-orchestrator')
-      assert.deepStrictEqual(worker?.config, {
-        batchSize: 20,
-        groupConcurrency: 3,
-      })
-    })
-
-    test('per-workflow (the default) leaves the shared queues unconstrained', () => {
-      resetPikkuState()
-      const ws = new InMemoryWorkflowService()
-      ws.wireQueueWorkers()
-
-      const worker = getQueueWorkers().get('pikku-workflow-orchestrator')
-      assert.strictEqual(worker?.config, undefined)
-    })
-  })
-})