@pikku/core 0.12.52 → 0.12.53

package/src/wirings/workflow/dsl/workflow-dsl.types.ts

@@ -37,6 +37,20 @@ export interface WorkflowExpectEventuallyOptions extends WorkflowStepOptions {
   interval?: string | number
 }
 
+/** Options for workflow.expectError() */
+export interface WorkflowExpectErrorOptions extends WorkflowStepOptions {
+  /** Assert the error message matches (string = substring match). */
+  matches?: string | RegExp
+}
+
+/** Options for workflow.expectService() */
+export interface WorkflowExpectServiceOptions extends WorkflowStepOptions {
+  /** Assert a recorded call's first argument deep-equals this value. */
+  calledWith?: unknown
+  /** Assert the exact number of matching calls. Default: at least one. */
+  times?: number
+}
+
 /**
  * Type signature for workflow.do() RPC form - used by inspector
  */
@@ -381,6 +395,21 @@ export interface PikkuWorkflowWire {
     options?: WorkflowExpectEventuallyOptions
   ) => Promise<TOutput>
 
+  /** Error-path step (scenarios): succeeds only when the RPC throws; returns the message */
+  expectError: <TInput = any>(
+    stepName: string,
+    rpcName: string,
+    data: TInput,
+    options?: WorkflowExpectErrorOptions
+  ) => Promise<string>
+
+  /** Stub-assertion step (scenarios): asserts `service.method` was called on the target server */
+  expectService: (
+    stepName: string,
+    serviceMethod: string,
+    options?: WorkflowExpectServiceOptions
+  ) => Promise<void>
+
   /** Sleep for a duration */
   sleep: WorkflowWireSleep
 

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

@@ -60,6 +60,8 @@ import type {
   WorkflowServiceConfig,
   WorkflowStepOptions,
   WorkflowExpectEventuallyOptions,
+  WorkflowExpectErrorOptions,
+  WorkflowExpectServiceOptions,
 } from './workflow.types.js'
 import {
   continueGraph,
@@ -1099,12 +1101,6 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     })
   }
 
-  /**
-   * Start a new workflow run
-   * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
-   * @param options.inline - If true, execute workflow directly without queue service
-   * @param options.startNode - Starting node ID for graph workflows (from wire config)
-   */
   /**
    * Start a new workflow run
    * Automatically detects workflow type (DSL or graph) from meta and executes accordingly
@@ -2229,6 +2225,104 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         )
       },
 
+      expectError: async (
+        stepName: string,
+        rpcName: string,
+        data: any,
+        options?: WorkflowExpectErrorOptions
+      ) => {
+        this.verifyStepName(stepName)
+        const resolvedRpcName =
+          addonNamespace && !rpcName.includes(':')
+            ? `${addonNamespace}:${rpcName}`
+            : rpcName
+        return await this.inlineStep(
+          runId,
+          stepName,
+          async () => {
+            let result: any
+            try {
+              result = options?.actor
+                ? await options.actor.invoke(resolvedRpcName, data)
+                : await rpcService.rpcWithWire(resolvedRpcName, data, {})
+            } catch (e: any) {
+              const message = e?.message ?? String(e)
+              if (options?.matches) {
+                const matched =
+                  typeof options.matches === 'string'
+                    ? message.includes(options.matches)
+                    : options.matches.test(message)
+                if (!matched) {
+                  throw new Error(
+                    `[workflow] expectError '${stepName}' ('${resolvedRpcName}') threw, but the message did not match ${options.matches}: ${message}`
+                  )
+                }
+              }
+              return message
+            }
+            throw new Error(
+              `[workflow] expectError '${stepName}' ('${resolvedRpcName}') expected an error but the call succeeded: ${JSON.stringify(result)?.slice(0, 300)}`
+            )
+          },
+          options
+        )
+      },
+
+      expectService: async (
+        stepName: string,
+        serviceMethod: string,
+        options?: WorkflowExpectServiceOptions
+      ) => {
+        this.verifyStepName(stepName)
+        const [service, method] = serviceMethod.split('.')
+        if (!service || !method) {
+          throw new Error(
+            `[workflow] expectService '${stepName}' needs 'service.method', got '${serviceMethod}'`
+          )
+        }
+        await this.inlineStep(
+          runId,
+          stepName,
+          async () => {
+            const rpcName = 'console:getStubCalls'
+            const calls: Array<{
+              service: string
+              method: string
+              args: unknown[]
+            }> = options?.actor
+              ? await options.actor.invoke(rpcName, { service })
+              : await rpcService.rpcWithWire(rpcName, { service }, {})
+            const matching = (calls ?? []).filter(
+              (c) =>
+                c.service === service &&
+                c.method === method &&
+                (options?.calledWith === undefined ||
+                  JSON.stringify(c.args?.[0]) ===
+                    JSON.stringify(options.calledWith))
+            )
+            const expected = options?.times
+            const ok =
+              expected === undefined
+                ? matching.length > 0
+                : matching.length === expected
+            if (!ok) {
+              const seen =
+                (calls ?? [])
+                  .map(
+                    (c) =>
+                      `${c.service}.${c.method}(${JSON.stringify(c.args?.[0])?.slice(0, 120) ?? ''})`
+                  )
+                  .join('\n  ') || '(none)'
+              throw new Error(
+                `[workflow] expectService '${stepName}' expected ${expected ?? 'at least one'} call(s) to '${serviceMethod}'` +
+                  `${options?.calledWith !== undefined ? ` with ${JSON.stringify(options.calledWith)}` : ''}, found ${matching.length}. Recorded:\n  ${seen}`
+              )
+            }
+          },
+          options
+        )
+      },
+
       // Implement workflow.sleep()
       sleep: async (stepName: string, duration: string | number) => {
         this.verifyStepName(stepName)

package/src/wirings/workflow/workflow.types.ts

@@ -8,6 +8,8 @@ export type { WorkflowService } from '../../services/workflow-service.js'
 export type {
   WorkflowStepOptions,
   WorkflowExpectEventuallyOptions,
+  WorkflowExpectErrorOptions,
+  WorkflowExpectServiceOptions,
   WorkflowWireDoRPC,
   WorkflowWireDoInline,
   WorkflowWireSleep,