@pikku/core 0.12.67 → 0.12.70

package/src/wirings/workflow/pikku-workflow-service.test.ts

@@ -29,6 +29,77 @@ describe('pikku-workflow-service worker registration', () => {
   })
 })
 
+describe('pikku-workflow-service per-workflow queue warning', () => {
+  // Losing the per-workflow orchestrator queues is silent — dispatch just falls
+  // back to the single shared queue and one slow step starves every workflow
+  // behind it. These assert the misconfiguration is announced at wiring time.
+  const setup = (workflowNames: string[], perWorkflowQueues: string[] = []) => {
+    resetPikkuState()
+    const warnings: string[] = []
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: {
+        error: () => {},
+        info: () => {},
+        debug: () => {},
+        warn: (message: string) => warnings.push(message),
+      },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    for (const name of workflowNames) {
+      metaState[name] = {
+        name,
+        pikkuFuncId: name,
+        source: 'dsl',
+        graphHash: `${name}-hash`,
+      } as any
+    }
+
+    const queueMeta = pikkuState(null, 'queue', 'meta')
+    for (const queueName of perWorkflowQueues) {
+      queueMeta[queueName] = {
+        pikkuFuncId: queueName,
+        name: queueName,
+      } as any
+    }
+
+    return warnings
+  }
+
+  test('warns when workflows exist but no per-workflow orchestrator queue is registered', () => {
+    const warnings = setup(['someWorkflow'])
+
+    new InMemoryWorkflowService().wireQueueWorkers()
+
+    assert.ok(
+      warnings.some((w) => /no per-workflow orchestrator queues/.test(w)),
+      `expected a per-workflow queue warning, got: ${JSON.stringify(warnings)}`
+    )
+  })
+
+  test('does not warn when per-workflow orchestrator queues are present', () => {
+    const warnings = setup(['someWorkflow'], ['wf-orchestrator-some-workflow'])
+
+    new InMemoryWorkflowService().wireQueueWorkers()
+
+    assert.ok(
+      !warnings.some((w) => /no per-workflow orchestrator queues/.test(w)),
+      `expected no warning, got: ${JSON.stringify(warnings)}`
+    )
+  })
+
+  test('does not warn when the app registers no workflows at all', () => {
+    const warnings = setup([])
+
+    new InMemoryWorkflowService().wireQueueWorkers()
+
+    assert.ok(
+      !warnings.some((w) => /no per-workflow orchestrator queues/.test(w)),
+      `expected no warning, got: ${JSON.stringify(warnings)}`
+    )
+  })
+})
+
 describe('pikku-workflow-service run-level inline', () => {
   test('workflow runs inline (and queues nothing) when no queue service is configured', async () => {
     const ws = new InMemoryWorkflowService()
@@ -804,3 +875,58 @@ describe('pikku-workflow-service approval', () => {
     cleanup()
   })
 })
+
+describe('pikku-workflow-service run identity on failure', () => {
+  // A failing inline run throws before startWorkflow can return `{ runId }`,
+  // so a caller that wants to read the run back — its steps, which one failed,
+  // what it was called with — has nothing to read it by. `onRunCreated` fires
+  // as soon as the run exists, which is the only moment guaranteed to happen
+  // whether the run goes on to pass, fail, or suspend.
+  const runFailing = async (name: string) => {
+    resetPikkuState()
+    const ws = new InMemoryWorkflowService()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: { error() {}, info() {}, warn() {}, debug() {} },
+    } as any)
+
+    const metaState = pikkuState(null, 'workflows', 'meta')
+    metaState[name] = {
+      name,
+      pikkuFuncId: name,
+      source: 'scenario',
+      graphHash: `${name}-hash`,
+    } as any
+    pikkuState(null, 'function', 'meta')[name] = {
+      name,
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    addWorkflow(name, {
+      func: async () => {
+        throw new Error('the scenario blew up')
+      },
+    } as any)
+
+    const created: string[] = []
+    let error: any
+    try {
+      await ws.startWorkflow(name, {}, {} as any, {}, {
+        onRunCreated: (runId: string) => created.push(runId),
+      } as any)
+    } catch (e: any) {
+      error = e
+    }
+    return { ws, created, error }
+  }
+
+  test('reports the run id of a run that fails inline', async () => {
+    const { ws, created, error } = await runFailing('onRunCreatedFailing')
+
+    assert.equal(error?.message, 'the scenario blew up')
+    assert.equal(created.length, 1, 'the run existed, so its id must be known')
+    const run = await ws.getRun(created[0]!)
+    assert.equal(run?.status, 'failed')
+    assert.equal(run?.error?.message, 'the scenario blew up')
+  })
+})