@pikku/core 0.12.106 → 0.12.111

package/src/wirings/workflow/scenario-expectations.test.ts

@@ -1,238 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { createScenarioRunner } from './pikku-scenario-service.js'
-import type { InMemoryWorkflowService } from '../../services/in-memory-workflow-service.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import type { ScenarioPersona } from '../../services/personas-service.js'
-
-const noopLogger = { error() {}, info() {}, warn() {}, debug() {} }
-
-const fakeActor = (
-  name: string,
-  handler: (rpcName: string, data: unknown) => Promise<unknown>
-): ScenarioPersona => ({
-  name,
-  email: `${name}@actors.local`,
-  invoke: async (rpcName: string, data: unknown) => handler(rpcName, data),
-  invokeRaw: async (rpcName: string, data: unknown) => ({
-    status: 200,
-    ok: true,
-    body: await handler(rpcName, data),
-  }),
-})
-
-const setup = async (ws: InMemoryWorkflowService) => {
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: noopLogger,
-  } as any)
-  const runId = await ws.createRun('scenarioTest', {}, true, 'hash', {
-    type: 'test',
-  } as any)
-  ws.registerInlineRun(runId)
-  return runId
-}
-
-const scenarioWire = async (rpcService: any = {}): Promise<{ wire: any }> => {
-  const { workflowService } = createScenarioRunner()
-  const ws = workflowService as InMemoryWorkflowService
-  const runId = await setup(ws)
-  return { wire: ws.createWorkflowWire('scenarioTest', runId, rpcService) }
-}
-
-describe('workflow.expectError', () => {
-  beforeEach(() => resetPikkuState())
-
-  test('returns the message when the call throws as expected', async () => {
-    const intruder = fakeActor('intruder', async () => {
-      throw new Error('Forbidden: not your todo')
-    })
-    const { wire } = await scenarioWire()
-
-    const message = await wire.expectError(
-      'intruder cannot delete',
-      'deleteTodo',
-      { todoId: 't1' },
-      { actor: intruder }
-    )
-
-    assert.equal(message, 'Forbidden: not your todo')
-  })
-
-  test('fails when the call succeeds instead of throwing', async () => {
-    const { wire } = await scenarioWire({
-      rpcWithWire: async () => ({ deleted: true }),
-    })
-
-    await assert.rejects(
-      wire.expectError('should have failed', 'deleteTodo', {}),
-      /expected an error but the call succeeded/
-    )
-  })
-
-  test('fails when the error message does not match', async () => {
-    const { wire } = await scenarioWire({
-      rpcWithWire: async () => {
-        throw new Error('database offline')
-      },
-    })
-
-    await assert.rejects(
-      wire.expectError(
-        'wrong reason',
-        'deleteTodo',
-        {},
-        { matches: /Forbidden/ }
-      ),
-      /did not match .*database offline/
-    )
-  })
-})
-
-describe('workflow.expectService', () => {
-  beforeEach(() => resetPikkuState())
-
-  const stubCalls = (
-    calls: Array<{ service: string; method: string; args: unknown[] }>
-  ) => ({
-    rpcWithWire: async (rpcName: string) => {
-      assert.equal(rpcName, 'pikkuScenarioGetStubCalls')
-      return calls
-    },
-  })
-
-  const oneEmail = () =>
-    stubCalls([{ service: 'email', method: 'send', args: [{ to: 'a@b.c' }] }])
-
-  test('passes when the service method was called', async () => {
-    const { wire } = await scenarioWire(oneEmail())
-
-    await wire.expectService('an email went out', 'email.send')
-  })
-
-  test('a call count that does not match names what was recorded', async () => {
-    const { wire } = await scenarioWire(oneEmail())
-
-    await assert.rejects(
-      wire.expectService('two emails', 'email.send', { times: 2 }),
-      /expected 2 call\(s\).*found 1.*email\.send/s
-    )
-  })
-
-  test('calledWith matches on the first argument', async () => {
-    const { wire } = await scenarioWire(oneEmail())
-
-    await wire.expectService('emailed the customer', 'email.send', {
-      calledWith: { to: 'a@b.c' },
-    })
-    await assert.rejects(
-      wire.expectService('emailed someone else', 'email.send', {
-        calledWith: { to: 'x@y.z' },
-      }),
-      /found 0/
-    )
-  })
-
-  test('a name that is not service.method is rejected outright', async () => {
-    const { wire } = await scenarioWire(stubCalls([]))
-
-    await assert.rejects(
-      wire.expectService('bad name', 'emailsend'),
-      /needs 'service\.method'/
-    )
-  })
-})
-
-describe('workflow.expectScore', () => {
-  beforeEach(() => resetPikkuState())
-
-  const grades = (grade: { score: number; reason?: string }) => ({
-    rpcWithWire: async (rpcName: string, data: any) => {
-      assert.equal(rpcName, 'pikkuScenarioGradeRun')
-      assert.equal(data.runId, 'run-1')
-      return grade
-    },
-  })
-
-  test('returns the grade when the score clears the bound', async () => {
-    const { wire } = await scenarioWire(grades({ score: 0.9 }))
-
-    const grade = await wire.expectScore('was brief', 'run-1', 'brevity', {
-      atLeast: 0.8,
-    })
-
-    assert.equal(grade.score, 0.9)
-  })
-
-  test('a scorer that graded zero fails without a bound being stated', async () => {
-    const { wire } = await scenarioWire(grades({ score: 0 }))
-
-    await assert.rejects(
-      wire.expectScore('was brief', 'run-1', 'brevity'),
-      /expected 'brevity' to grade run run-1 at least 0\.5, got 0/
-    )
-  })
-
-  test('the failure carries the reason the judge gave', async () => {
-    const { wire } = await scenarioWire(
-      grades({ score: 0.2, reason: 'It rambled for four paragraphs' })
-    )
-
-    await assert.rejects(
-      wire.expectScore('was brief', 'run-1', 'brevity', { atLeast: 0.8 }),
-      /It rambled for four paragraphs/
-    )
-  })
-
-  test('atMost fails a score that is too high', async () => {
-    const { wire } = await scenarioWire(grades({ score: 0.95 }))
-
-    await assert.rejects(
-      wire.expectScore('was not sycophantic', 'run-1', 'sycophancy', {
-        atLeast: 0,
-        atMost: 0.3,
-      }),
-      /between 0 and 0\.3, got 0\.95/
-    )
-  })
-
-  test('a grade that misses the bound is not re-rolled until it lands', async () => {
-    let graded = 0
-    const { wire } = await scenarioWire({
-      rpcWithWire: async () => {
-        graded += 1
-        return { score: 1 }
-      },
-    })
-
-    await assert.rejects(
-      wire.expectScore('was not sycophantic', 'run-1', 'sycophancy', {
-        atLeast: 0,
-        atMost: 0.3,
-      }),
-      /got 1/
-    )
-
-    // The whole point of a judge is that it is not deterministic. Six attempts
-    // at it is six chances for one to land inside the band, which grades the
-    // sampling rather than the run.
-    assert.equal(graded, 1)
-  })
-
-  test('a reference answer reaches the grader', async () => {
-    let seen: any
-    const { wire } = await scenarioWire({
-      rpcWithWire: async (_rpcName: string, data: any) => {
-        seen = data
-        return { score: 1 }
-      },
-    })
-
-    await wire.expectScore('matched the answer key', 'run-1', 'correctness', {
-      reference: 'Paris',
-    })
-
-    assert.equal(seen.reference, 'Paris')
-    assert.equal(seen.scorer, 'correctness')
-  })
-})

package/src/wirings/workflow/scenario-hooks.test.ts

@@ -1,259 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { createScenarioRunner } from './pikku-scenario-service.js'
-import { pikkuState, resetPikkuState } from '../../pikku-state.js'
-import { addWorkflow } from './dsl/workflow-runner.js'
-import type { ScenarioPersonas } from '../../services/personas-service.js'
-
-const noopLogger = {
-  error() {},
-  info() {},
-  warn() {},
-  debug() {},
-}
-
-const actors = {
-  admin: {
-    name: 'admin',
-    email: 'admin@actors.local',
-    invoke: async () => ({}),
-    invokeRaw: async () => ({ status: 200, ok: true, body: {} }),
-  },
-} as unknown as ScenarioPersonas
-
-type ScenarioHooks = {
-  before?: (services: any, data: any, wire: any) => Promise<void> | void
-  after?: (services: any, data: any, wire: any) => Promise<void> | void
-}
-
-const runScenario = async (
-  name: string,
-  config: ScenarioHooks & { func: (...args: any[]) => any },
-  { input = {}, source = 'scenario' as 'scenario' | 'dsl' } = {}
-) => {
-  const { workflowService: ws, scenarioService } = createScenarioRunner()
-
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: noopLogger,
-    marker: 'singleton',
-  } as any)
-
-  const metaState = pikkuState(null, 'workflows', 'meta')
-  metaState[name] = {
-    name,
-    pikkuFuncId: name,
-    source,
-    graphHash: `${name}-hash`,
-  } as any
-
-  const functionMetaState = pikkuState(null, 'function', 'meta')
-  functionMetaState[name] = {
-    name,
-    sessionless: true,
-    permissions: [],
-  } as any
-
-  addWorkflow(name, config as any)
-
-  let error: any
-  try {
-    await ws.startWorkflow(name, input, {} as any, {}, { actors })
-  } catch (e: any) {
-    error = e
-  }
-  const runs = await ws.listRuns({ workflowName: name })
-  const run = runs[0]
-  return { error, run, ws }
-}
-
-describe('scenario before/after hooks', () => {
-  beforeEach(() => resetPikkuState())
-
-  test('before runs, then the scenario, then after', async () => {
-    const order: string[] = []
-    await runScenario('hooksOrder', {
-      before: async () => {
-        order.push('before')
-      },
-      after: async () => {
-        order.push('after')
-      },
-      func: async () => {
-        order.push('func')
-        return { ok: true }
-      },
-    })
-    assert.deepEqual(order, ['before', 'func', 'after'])
-  })
-
-  test('after still runs when the scenario throws', async () => {
-    const order: string[] = []
-    const { error, run } = await runScenario('hooksAfterOnFailure', {
-      after: async () => {
-        order.push('after')
-      },
-      func: async () => {
-        order.push('func')
-        throw new Error('scenario blew up')
-      },
-    })
-    assert.deepEqual(order, ['func', 'after'])
-    assert.equal(error?.message, 'scenario blew up')
-    assert.equal(run?.status, 'failed')
-  })
-
-  test('before throwing skips the scenario but still runs after', async () => {
-    const order: string[] = []
-    const { error, run } = await runScenario('hooksBeforeThrows', {
-      before: async () => {
-        order.push('before')
-        throw new Error('setup failed')
-      },
-      after: async () => {
-        order.push('after')
-      },
-      func: async () => {
-        order.push('func')
-        return { ok: true }
-      },
-    })
-    assert.deepEqual(order, ['before', 'after'], 'the func must not run')
-    assert.match(String(error?.message), /setup failed/)
-    assert.equal(run?.status, 'failed')
-  })
-
-  test('after throwing fails a run that would otherwise have passed', async () => {
-    const { error, run } = await runScenario('hooksAfterThrows', {
-      after: async () => {
-        throw new Error('teardown failed')
-      },
-      func: async () => ({ ok: true }),
-    })
-    assert.match(String(error?.message), /teardown failed/)
-    assert.equal(run?.status, 'failed')
-  })
-
-  test('after throwing never masks the original failure', async () => {
-    const { error } = await runScenario('hooksAfterMasks', {
-      after: async () => {
-        throw new Error('teardown failed')
-      },
-      func: async () => {
-        throw new Error('the real failure')
-      },
-    })
-    assert.equal(
-      error?.message,
-      'the real failure',
-      'the scenario failure must be what the caller sees'
-    )
-    assert.match(
-      String((error as any)?.cause?.message),
-      /teardown failed/,
-      'the teardown failure must survive as the cause'
-    )
-  })
-
-  test('hooks receive the services, the input and the run actors', async () => {
-    const seen: any[] = []
-    await runScenario(
-      'hooksArgs',
-      {
-        before: async (services, data, wire) => {
-          seen.push({
-            marker: services.marker,
-            data,
-            actor: wire?.actors?.admin?.name,
-          })
-        },
-        after: async (services, data, wire) => {
-          seen.push({
-            marker: services.marker,
-            data,
-            actor: wire?.actors?.admin?.name,
-          })
-        },
-        func: async () => ({ ok: true }),
-      },
-      { input: { seed: 7 } }
-    )
-    assert.deepEqual(seen, [
-      { marker: 'singleton', data: { seed: 7 }, actor: 'admin' },
-      { marker: 'singleton', data: { seed: 7 }, actor: 'admin' },
-    ])
-  })
-
-  test('after reads what the body wrote to the scenario context', async () => {
-    // The reason the context exists: a hook's `data` is only ever the run's
-    // *input*, never what the body produced. The context is the channel the
-    // body writes that through, and it reaches the hook on the shared wire.
-    let seen: any
-    await runScenario('contextHandover', {
-      after: async (_services, _data, wire) => {
-        seen = { ...wire.scenario.context }
-      },
-      func: async (_services, _data, wire) => {
-        wire.scenario.context.projectId = 'p_1'
-        return { projectId: 'p_1' }
-      },
-    })
-    assert.deepEqual(seen, { projectId: 'p_1' })
-  })
-
-  test('after sees the context of a body that threw after writing it', async () => {
-    // The failing path is the one that matters — a passing run could have
-    // returned the ids instead.
-    let seen: any
-    const { error } = await runScenario('contextOnFailure', {
-      after: async (_services, _data, wire) => {
-        seen = { ...wire.scenario.context }
-      },
-      func: async (_services, _data, wire) => {
-        wire.scenario.context.projectId = 'p_2'
-        throw new Error('body blew up')
-      },
-    })
-    assert.equal(error?.message, 'body blew up')
-    assert.deepEqual(seen, { projectId: 'p_2' })
-  })
-
-  test('before, the body and after all share one context object', async () => {
-    let seen: any
-    await runScenario('contextShared', {
-      before: async (_services, _data, wire) => {
-        wire.scenario.context.seededBy = 'before'
-      },
-      after: async (_services, _data, wire) => {
-        seen = { ...wire.scenario.context }
-      },
-      func: async (_services, _data, wire) => {
-        assert.equal(wire.scenario.context.seededBy, 'before')
-        wire.scenario.context.addedBy = 'func'
-        return { ok: true }
-      },
-    })
-    assert.deepEqual(seen, { seededBy: 'before', addedBy: 'func' })
-  })
-
-  test('hooks are scenario-only — a plain DSL workflow never runs them', async () => {
-    const order: string[] = []
-    await runScenario(
-      'hooksNotForWorkflows',
-      {
-        before: async () => {
-          order.push('before')
-        },
-        after: async () => {
-          order.push('after')
-        },
-        func: async () => {
-          order.push('func')
-          return { ok: true }
-        },
-      },
-      { source: 'dsl' }
-    )
-    assert.deepEqual(order, ['func'])
-  })
-})

package/src/wirings/workflow/scenario-poll.test.ts

@@ -1,64 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { pollUntil } from './scenario-poll.js'
-
-describe('pollUntil', () => {
-  test('answers with the first attempt that produced something', async () => {
-    let attempts = 0
-    const found = await pollUntil(
-      () => {
-        attempts++
-        return attempts === 3 ? 'ready' : undefined
-      },
-      { intervalMs: 1 }
-    )
-
-    assert.equal(found, 'ready')
-    assert.equal(attempts, 3)
-  })
-
-  test('gives up at the deadline rather than looping forever', async () => {
-    const started = Date.now()
-    const found = await pollUntil(() => undefined, {
-      timeoutMs: 30,
-      intervalMs: 5,
-    })
-
-    assert.equal(found, undefined)
-    assert.ok(Date.now() - started < 1_000, 'returned promptly')
-  })
-
-  test('always attempts at least once, however short the deadline', async () => {
-    let attempts = 0
-    const found = await pollUntil(
-      () => {
-        attempts++
-        return 'immediate'
-      },
-      { timeoutMs: 0 }
-    )
-
-    assert.equal(attempts, 1)
-    assert.equal(found, 'immediate')
-  })
-
-  test('awaits an async attempt', async () => {
-    const found = await pollUntil(async () => 'awaited', { intervalMs: 1 })
-    assert.equal(found, 'awaited')
-  })
-
-  test('treats a falsy-but-defined answer as an answer', async () => {
-    let attempts = 0
-    const found = await pollUntil(
-      () => {
-        attempts++
-        return false
-      },
-      { timeoutMs: 50, intervalMs: 1 }
-    )
-
-    assert.equal(found, false)
-    assert.equal(attempts, 1)
-  })
-})

package/src/wirings/workflow/scenario-poll.ts

@@ -1,27 +0,0 @@
-export interface PollOptions {
-  timeoutMs?: number
-  intervalMs?: number
-}
-
-/**
- * Retries an assertion until it passes or the timeout runs out — for the
- * eventually-consistent parts of a scenario (a queued job, a projection).
- *
- * @example snippet: scenarioPolling
- */
-export const pollUntil = async <T>(
-  attempt: () => Promise<T | undefined> | T | undefined,
-  { timeoutMs = 15_000, intervalMs = 250 }: PollOptions = {}
-): Promise<T | undefined> => {
-  const deadline = Date.now() + timeoutMs
-  for (;;) {
-    const answer = await attempt()
-    if (answer !== undefined) {
-      return answer
-    }
-    if (Date.now() >= deadline) {
-      return undefined
-    }
-    await new Promise((done) => setTimeout(done, intervalMs))
-  }
-}