@pikku/inspector 0.12.75 → 0.12.81

package/src/add/rpc-type-cast.test.ts

@@ -1,123 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import { ErrorCode } from '../error-codes.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger() {
-  const criticals: Array<{ code: ErrorCode; message: string }> = []
-  const logger: InspectorLogger = {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }) => criticals.push({ code, message }),
-    critical: (code, message) => criticals.push({ code, message }),
-    hasCriticalErrors: () => criticals.length > 0,
-  }
-  return { logger, criticals }
-}
-
-async function runInspect(sourceCode: string) {
-  const tmpDir = await mkdtemp(join(tmpdir(), 'pikku-rpc-cast-test-'))
-  const file = join(tmpDir, 'funcs.ts')
-  await writeFile(file, sourceCode)
-  const { logger, criticals } = makeLogger()
-  try {
-    await inspect(logger, [file], { rootDir: tmpDir })
-  } finally {
-    await rm(tmpDir, { recursive: true, force: true })
-  }
-  return criticals
-}
-
-describe('RPC type-cast check — PKU940', () => {
-  test('flags rpc.invoke() with an as-cast on an argument', async () => {
-    const criticals = await runInspect(`
-declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
-export async function doWork() {
-  return rpc.invoke('someFunction', { id: 1 } as any)
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
-  })
-
-  test('flags rpc.invoke() with an angle-bracket cast on an argument', async () => {
-    const criticals = await runInspect(`
-declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
-export async function doWork() {
-  return rpc.invoke('someFunction', <any>{ id: 1 })
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
-  })
-
-  test('flags rpc.invoke() result cast with as any', async () => {
-    const criticals = await runInspect(`
-declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
-export async function doWork() {
-  return (rpc.invoke('someFunction', { id: 1 }) as any)
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
-  })
-
-  test('flags rpc.invoke() result cast with as never', async () => {
-    const criticals = await runInspect(`
-declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
-export async function doWork() {
-  return (rpc.invoke('someFunction', { id: 1 }) as never)
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.ok(hit, `Expected PKU940 but got: ${JSON.stringify(criticals)}`)
-  })
-
-  test('does not flag a clean rpc.invoke() call', async () => {
-    const criticals = await runInspect(`
-declare const rpc: { invoke: (name: string, data: unknown) => Promise<unknown> }
-export async function doWork() {
-  return rpc.invoke('someFunction', { id: 1 })
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.equal(
-      hit,
-      undefined,
-      `Expected no PKU940 but got: ${JSON.stringify(hit)}`
-    )
-  })
-
-  test('does not flag as-casts on unrelated calls', async () => {
-    const criticals = await runInspect(`
-declare function otherFn(data: unknown): Promise<unknown>
-export async function doWork() {
-  return otherFn({ id: 1 } as any)
-}
-`)
-    const hit = criticals.find(
-      (c) => c.code === ErrorCode.RPC_INVOCATION_TYPE_CAST
-    )
-    assert.equal(
-      hit,
-      undefined,
-      `Expected no PKU940 but got: ${JSON.stringify(hit)}`
-    )
-  })
-})

package/src/add/scenario-instrumentation.test.ts

@@ -1,89 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-import {
-  SCENARIO_INSTRUMENTATION_FUNCTIONS,
-  isScenarioInstrumentationFunction,
-} from './scenario-instrumentation.js'
-
-const silentLogger: InspectorLogger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  diagnostic: () => {},
-  critical: () => {},
-  hasCriticalErrors: () => false,
-}
-
-describe('scenario instrumentation', () => {
-  test('recognises the instrumentation names, including versioned ids', () => {
-    for (const name of SCENARIO_INSTRUMENTATION_FUNCTIONS) {
-      assert.ok(isScenarioInstrumentationFunction(name), name)
-      assert.ok(isScenarioInstrumentationFunction(`${name}@v2`), `${name}@v2`)
-    }
-    assert.ok(!isScenarioInstrumentationFunction('createUser'))
-    assert.ok(!isScenarioInstrumentationFunction(undefined))
-  })
-
-  test('a project still carrying the retired scaffold registers none of it', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-instr-'))
-    const file = join(rootDir, 'scenarios.gen.ts')
-
-    // What `scaffold.scenarios` used to write into the project. Whatever a
-    // project has checked in, none of it may reach the app's meta or RPC surface:
-    // `pikku dev` registers the real implementations itself.
-    await writeFile(
-      file,
-      [
-        "import { pikkuFunc } from '@pikku/core'",
-        'export const pikkuScenarioTakeLiveCoverage = pikkuFunc({',
-        "  tags: ['pikku'],",
-        '  expose: true,',
-        '  auth: true,',
-        '  func: async () => null,',
-        '})',
-        'export const pikkuScenarioResetStubs = pikkuFunc({',
-        "  tags: ['pikku'],",
-        '  expose: true,',
-        '  auth: true,',
-        '  func: async () => ({ enabled: true }),',
-        '})',
-        'export const createUser = pikkuFunc({',
-        '  expose: true,',
-        '  func: async () => ({ ok: true }),',
-        '})',
-      ].join('\n')
-    )
-
-    try {
-      const state = await inspect(silentLogger, [file], { rootDir })
-
-      for (const name of SCENARIO_INSTRUMENTATION_FUNCTIONS) {
-        assert.ok(
-          !(name in state.functions.meta),
-          `${name} must not be in the app function meta`
-        )
-        assert.ok(
-          !(name in state.rpc.internalMeta),
-          `${name} must not be in the internal RPC meta`
-        )
-        assert.ok(
-          !(name in state.rpc.exposedMeta),
-          `${name} must not be exposed`
-        )
-      }
-
-      // The application function in the same file is untouched — the drop is by
-      // name, not by file.
-      assert.ok(state.functions.meta['createUser'])
-      assert.strictEqual(state.rpc.exposedMeta['createUser'], 'createUser')
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/add/scenario-instrumentation.ts

@@ -1,42 +0,0 @@
-/**
- * The instrumentation RPCs `pikku scenario run` calls on the server it is
- * testing: snapshot/reset live coverage, and reset/read recorded stub calls.
- *
- * They are pikku's own, not the application's. They used to be scaffolded into
- * the project as ordinary `pikkuFunc`s, which made them indistinguishable from
- * application code — so they were registered in the app bootstrap, listed in the
- * app's function and RPC meta, and shipped, `expose: true`, in every deployed
- * bundle. A deployment has no use for them: coverage and stub inspection are
- * things you do to a development server.
- *
- * The inspector therefore ignores these names wherever it finds them, and
- * `pikku dev` registers the implementations itself. Ignoring by name (rather
- * than deleting the scaffold and requiring every project to regenerate) is what
- * keeps an existing project's checked-in `scenarios.gen.ts` from deploying.
- *
- * `pikkuScenarioGradeRun` was never scaffolded — it arrived after the split —
- * but it belongs here for the same reason: grading a run on demand, ignoring the
- * sample rate that governs live traffic, is a thing you do to a development
- * server, and the name is reserved so an application cannot claim it.
- */
-export const SCENARIO_INSTRUMENTATION_FUNCTIONS = [
-  'pikkuScenarioTakeLiveCoverage',
-  'pikkuScenarioResetLiveCoverage',
-  'pikkuScenarioResetStubs',
-  'pikkuScenarioGetStubCalls',
-  'pikkuScenarioGradeRun',
-] as const
-
-export type ScenarioInstrumentationFunction =
-  (typeof SCENARIO_INSTRUMENTATION_FUNCTIONS)[number]
-
-const names = new Set<string>(SCENARIO_INSTRUMENTATION_FUNCTIONS)
-
-/**
- * True for a scenario instrumentation function, by name. Versioned ids
- * (`name@v2`) are matched on their base so a project that bumps one is still
- * covered.
- */
-export const isScenarioInstrumentationFunction = (
-  name: string | undefined
-): boolean => (name ? names.has(name.split('@')[0]!) : false)

package/src/add/scenario-marker.test.ts

@@ -1,89 +0,0 @@
-/**
- * The `scenario` / `scenarioStep` markers in the *function* meta are what every
- * deployment boundary downstream reads: the codegen partition, the RPC meta
- * filter, the schema split and the deploy analyzer. Asserting them on a real
- * `pikkuScenario(...)` is what makes those filters mean anything — filters tested
- * against hand-written meta would keep passing if extraction stopped setting it.
- */
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-const logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  diagnostic: () => {},
-  critical: () => {},
-  hasCriticalErrors: () => false,
-} as unknown as InspectorLogger
-
-const STEPS = [
-  "import { pikkuScenarioStep } from '@pikku/core'",
-  'export const buysAnApple = pikkuScenarioStep({',
-  "  name: 'buysAnApple',",
-  "  description: 'buys an apple',",
-  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
-  '})',
-].join('\n')
-
-const APP = [
-  "import { pikkuFunc } from '@pikku/core'",
-  'export const createTodo = pikkuFunc({',
-  '  expose: true,',
-  '  func: async (_services, data: { title: string }) => ({ id: data.title }),',
-  '})',
-].join('\n')
-
-const SCENARIO = [
-  "import { pikkuScenario } from '@pikku/core/workflow'",
-  'export const shopFlow = pikkuScenario({',
-  "  title: 'Buys an apple',",
-  '  func: async (_services, _input, { scenario }: any) => {',
-  "    await scenario.when('buys an apple', 'buysAnApple', { qty: 1 })",
-  '    return { ok: true }',
-  '  },',
-  '})',
-].join('\n')
-
-describe('scenario markers in the function meta', () => {
-  test('a real pikkuScenario and pikkuScenarioStep are marked, an application function is not', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-marker-'))
-    const files = [
-      [join(rootDir, 'shop.steps.ts'), STEPS],
-      [join(rootDir, 'shop.scenario.ts'), SCENARIO],
-      [join(rootDir, 'todo.function.ts'), APP],
-    ] as const
-    await Promise.all(files.map(([path, source]) => writeFile(path, source)))
-
-    try {
-      const state = await inspect(
-        logger,
-        files.map(([path]) => path),
-        { rootDir }
-      )
-
-      const scenario = state.functions.meta['shopFlow']
-      assert.ok(scenario, 'the scenario body is a function and must have meta')
-      assert.equal(scenario.scenario, true)
-      assert.equal(scenario.scenarioStep, undefined)
-
-      const step = state.functions.meta['buysAnApple']
-      assert.ok(step)
-      assert.equal(step.scenarioStep, true)
-      assert.equal(step.scenario, undefined)
-
-      const app = state.functions.meta['createTodo']
-      assert.ok(app)
-      assert.equal(app.scenario, undefined)
-      assert.equal(app.scenarioStep, undefined)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/add/scenario-not-extractable.test.ts

@@ -1,159 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger(
-  criticals: Array<{ code: string; message: string }>
-): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }: any) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: any, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  } as InspectorLogger
-}
-
-const STEPS = [
-  "import { pikkuScenarioStep } from '@pikku/core'",
-  'export const buysAnApple = pikkuScenarioStep({',
-  "  name: 'buysAnApple',",
-  "  description: 'buys an apple',",
-  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
-  '})',
-].join('\n')
-
-const source = (wrapper: string, body: string[]) =>
-  [
-    `import { ${wrapper} } from '@pikku/core/workflow'`,
-    'declare const actors: Record<string, any>',
-    `export const shopFlow = ${wrapper}(async (_services, _input, { scenario, workflow }: any) => {`,
-    ...body.map((line) => `  ${line}`),
-    '  return { ok: true }',
-    '})',
-  ].join('\n')
-
-async function run(wrapper: string, body: string[]) {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-extract-'))
-  const stepsFile = join(rootDir, 'shop.steps.ts')
-  const scenarioFile = join(rootDir, 'shop.scenario.ts')
-  await writeFile(stepsFile, STEPS)
-  await writeFile(scenarioFile, source(wrapper, body))
-  const criticals: Array<{ code: string; message: string }> = []
-  const state = await inspect(
-    makeLogger(criticals),
-    [stepsFile, scenarioFile],
-    {
-      rootDir,
-    }
-  )
-  return {
-    state,
-    criticals,
-    cleanup: () => rm(rootDir, { recursive: true, force: true }),
-  }
-}
-
-/**
- * A scenario that fails DSL extraction silently registers with zero steps,
- * because the fallback path (`getWorkflowInvocations`) understands `do`/`sleep`
- * but not `step`/`given`/`when`/`then`. That is the PKU678 silent-drop class,
- * and for scenarios it must be loud.
- */
-describe('a scenario that cannot be extracted', () => {
-  test('a top-level try/catch is a PKU679 critical, not a silent zero-step scenario', async () => {
-    const { state, criticals, cleanup } = await run('pikkuScenario', [
-      'try {',
-      "  await scenario.given('buys an apple', 'buysAnApple', { qty: 1 }, { actor: actors.shopper })",
-      '} catch {}',
-    ])
-    try {
-      assert.equal(
-        state.workflows.meta.shopFlow,
-        undefined,
-        'an unextractable scenario must not register at all, rather than register empty'
-      )
-      assert.ok(
-        criticals.find((c) => c.code === 'PKU679'),
-        `expected a PKU679 critical for an unextractable scenario, got: ${JSON.stringify(criticals)}`
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('an extractable scenario raises no PKU679', async () => {
-    const { criticals, cleanup } = await run('pikkuScenario', [
-      "await scenario.given('buys an apple', 'buysAnApple', { qty: 1 }, { actor: actors.shopper })",
-    ])
-    try {
-      assert.equal(
-        criticals.filter((c) => c.code === 'PKU679').length,
-        0,
-        `a valid scenario must not raise PKU679, got: ${JSON.stringify(criticals)}`
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('a scenario that declares no input parameter is still extractable', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-noinput-'))
-    const scenarioFile = join(rootDir, 'fails.scenario.ts')
-    await writeFile(
-      scenarioFile,
-      [
-        "import { pikkuScenario } from '@pikku/core/workflow'",
-        'export const alwaysFails = pikkuScenario({',
-        "  title: 'Always fails (test fixture)',",
-        "  tags: ['scenario'],",
-        "  func: async () => { throw new Error('always fails') },",
-        '})',
-      ].join('\n')
-    )
-    const criticals: Array<{ code: string; message: string }> = []
-    const state = await inspect(makeLogger(criticals), [scenarioFile], {
-      rootDir,
-    })
-    try {
-      assert.ok(
-        state.workflows.meta.alwaysFails,
-        `a scenario that ignores its input must still register, got criticals: ${JSON.stringify(criticals)}`
-      )
-      assert.equal(
-        criticals.filter((c) => c.code === 'PKU679').length,
-        0,
-        `declaring no input parameter is legitimate, got: ${JSON.stringify(criticals)}`
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('a complex workflow still falls back quietly — only scenarios are strict', async () => {
-    const { criticals, cleanup } = await run('pikkuWorkflowComplexFunc', [
-      'try {',
-      "  await workflow.do('buy', 'buysAnApple', { qty: 1 })",
-      '} catch {}',
-    ])
-    try {
-      assert.equal(
-        criticals.filter((c) => c.code === 'PKU679').length,
-        0,
-        `pikkuWorkflowComplexFunc legitimately falls back to basic extraction, got: ${JSON.stringify(criticals)}`
-      )
-    } finally {
-      await cleanup()
-    }
-  })
-})

package/src/add/scenario-services.test.ts

@@ -1,103 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-function makeLogger(
-  criticals: Array<{ code: string; message: string }>
-): InspectorLogger {
-  return {
-    debug: () => {},
-    info: () => {},
-    warn: () => {},
-    error: () => {},
-    diagnostic: ({ code, message }) => {
-      criticals.push({ code, message })
-    },
-    critical: (code: any, message: string) => {
-      criticals.push({ code, message })
-    },
-    hasCriticalErrors: () => criticals.length > 0,
-  }
-}
-
-const stepFile = (dir: string) => join(dir, 'my.steps.ts')
-const stepSource = [
-  "import { pikkuSessionlessFunc } from '@pikku/core'",
-  'export const getTodos = pikkuSessionlessFunc({',
-  '  func: async ({ logger }) => [{ done: true }],',
-  '})',
-].join('\n')
-
-describe('scenarios may only destructure logger/config', () => {
-  test('a scenario destructuring a real service is a PKU673 critical', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-sc-svc-'))
-    const scenarioFile = join(rootDir, 'my.scenario.ts')
-    await writeFile(stepFile(rootDir), stepSource)
-    await writeFile(
-      scenarioFile,
-      [
-        "import { pikkuScenario } from '@pikku/core/workflow'",
-        'declare const actors: Record<string, any>',
-        'export const badFlow = pikkuScenario(async ({ kysely }: any, _input, { workflow }) => {',
-        "  await workflow.do('Read todos', 'getTodos', {}, { actor: actors.pm })",
-        '  return { ok: true }',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: string; message: string }> = []
-    try {
-      await inspect(makeLogger(criticals), [stepFile(rootDir), scenarioFile], {
-        rootDir,
-      })
-      const pku673 = criticals.find((c) => c.code === 'PKU673')
-      assert.ok(
-        pku673,
-        `expected a PKU673 critical for a scenario destructuring 'kysely', got: ${JSON.stringify(criticals)}`
-      )
-      assert.ok(
-        pku673.message.includes('kysely'),
-        `PKU673 should name the offending service, got: ${pku673.message}`
-      )
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-
-  test('a scenario destructuring only logger is allowed', async () => {
-    const rootDir = await mkdtemp(join(tmpdir(), 'pikku-sc-ok-'))
-    const scenarioFile = join(rootDir, 'my.scenario.ts')
-    await writeFile(stepFile(rootDir), stepSource)
-    await writeFile(
-      scenarioFile,
-      [
-        "import { pikkuScenario } from '@pikku/core/workflow'",
-        'declare const actors: Record<string, any>',
-        'export const goodFlow = pikkuScenario(async ({ logger }, _input, { workflow }) => {',
-        "  await workflow.do('Read todos', 'getTodos', {}, { actor: actors.pm })",
-        '  return { ok: true }',
-        '})',
-      ].join('\n')
-    )
-
-    const criticals: Array<{ code: string; message: string }> = []
-    try {
-      const state = await inspect(
-        makeLogger(criticals),
-        [stepFile(rootDir), scenarioFile],
-        { rootDir }
-      )
-      assert.ok(
-        !criticals.some((c) => c.code === 'PKU673'),
-        `logger is allowed in a scenario; got: ${JSON.stringify(criticals)}`
-      )
-      assert.equal((state.workflows.meta as any).goodFlow?.scenario, true)
-    } finally {
-      await rm(rootDir, { recursive: true, force: true })
-    }
-  })
-})

package/src/add/scenario-skip.test.ts

@@ -1,83 +0,0 @@
-/**
- * A scenario can declare why it is held out of a default run. The reason has to
- * reach the meta, because the runner reports skips from there — if it were
- * dropped in extraction the scenario would silently run anyway, which is the
- * opposite of what the author asked for.
- */
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { inspect } from '../inspector.js'
-import type { InspectorLogger } from '../types.js'
-
-const logger = {
-  debug: () => {},
-  info: () => {},
-  warn: () => {},
-  error: () => {},
-  diagnostic: () => {},
-  critical: () => {},
-  hasCriticalErrors: () => false,
-} as unknown as InspectorLogger
-
-const STEPS = [
-  "import { pikkuScenarioStep } from '@pikku/core'",
-  'export const buysAnApple = pikkuScenarioStep({',
-  "  name: 'buysAnApple',",
-  "  description: 'buys an apple',",
-  '  func: async ({ logger }, data: { qty: number }) => ({ ok: data.qty > 0 }),',
-  '})',
-].join('\n')
-
-const scenarioSource = (properties: string[]) =>
-  [
-    "import { pikkuScenario } from '@pikku/core/workflow'",
-    'export const shopFlow = pikkuScenario({',
-    ...properties.map((line) => `  ${line}`),
-    '  func: async (_services, _input, { scenario }: any) => {',
-    "    await scenario.when('buys an apple', 'buysAnApple', { qty: 1 })",
-    '    return { ok: true }',
-    '  },',
-    '})',
-  ].join('\n')
-
-async function inspectScenario(properties: string[]) {
-  const rootDir = await mkdtemp(join(tmpdir(), 'pikku-scenario-skip-'))
-  const stepsFile = join(rootDir, 'shop.steps.ts')
-  const scenarioFile = join(rootDir, 'shop.scenario.ts')
-  await writeFile(stepsFile, STEPS)
-  await writeFile(scenarioFile, scenarioSource(properties))
-  const state = await inspect(logger, [stepsFile, scenarioFile], { rootDir })
-  return {
-    meta: state.workflows.meta['shopFlow'] as any,
-    cleanup: () => rm(rootDir, { recursive: true, force: true }),
-  }
-}
-
-describe('scenario skip', () => {
-  test('a declared skip reason reaches the meta', async () => {
-    const { meta, cleanup } = await inspectScenario([
-      "title: 'Installs an addon',",
-      "skip: 'mutates the project — needs a fresh server',",
-    ])
-    try {
-      assert.equal(meta.skip, 'mutates the project — needs a fresh server')
-    } finally {
-      await cleanup()
-    }
-  })
-
-  test('a scenario that declares none carries none', async () => {
-    const { meta, cleanup } = await inspectScenario([
-      "title: 'Installs an addon',",
-    ])
-    try {
-      assert.equal(meta.skip, undefined)
-      assert.equal(meta.scenario, true)
-    } finally {
-      await cleanup()
-    }
-  })
-})