@outputai/core 0.14.0 → 0.14.1-next.2947341.0

package/src/worker/loader/workflows.spec.js

@@ -1,287 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-vi.mock( '#consts', () => ( {
-  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest',
-  ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
-  WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
-  WORKFLOW_CATALOG: 'catalog',
-  ACTIVITY_OPTIONS_FILENAME: '__activity_options.js',
-  WORKFLOW_OPTIONS_FILENAME: '__workflow_options.js'
-} ) );
-
-const { importComponentsMock, findWorkflowsInNodeModulesMock, matchFilesMock, writeFileInTempDirMock } = vi.hoisted( () => ( {
-  importComponentsMock: vi.fn(),
-  findWorkflowsInNodeModulesMock: vi.fn(),
-  matchFilesMock: vi.fn(),
-  writeFileInTempDirMock: vi.fn()
-} ) );
-
-const { workflowFileMatcherMock, workflowPathHasSharedMock } = vi.hoisted( () => ( {
-  workflowFileMatcherMock: vi.fn(),
-  workflowPathHasSharedMock: vi.fn()
-} ) );
-
-vi.mock( './tools.js', () => ( {
-  importComponents: importComponentsMock,
-  findWorkflowsInNodeModules: findWorkflowsInNodeModulesMock,
-  matchFiles: matchFilesMock,
-  writeFileInTempDir: writeFileInTempDirMock
-} ) );
-
-vi.mock( './matchers.js', () => ( {
-  staticMatchers: {
-    workflowFile: workflowFileMatcherMock,
-    workflowPathHasShared: workflowPathHasSharedMock
-  }
-} ) );
-
-describe( 'loadWorkflows', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    importComponentsMock.mockReset();
-    importComponentsMock.mockImplementation( async function *() {} );
-    findWorkflowsInNodeModulesMock.mockReset();
-    findWorkflowsInNodeModulesMock.mockReturnValue( [] );
-    matchFilesMock.mockReset();
-    matchFilesMock.mockReturnValue( [] );
-    writeFileInTempDirMock.mockReset();
-    writeFileInTempDirMock.mockImplementation( ( _, filename ) => `/tmp/${filename}` );
-    workflowPathHasSharedMock.mockReset();
-    workflowPathHasSharedMock.mockReturnValue( false );
-  } );
-
-  it( 'returns local workflows from importComponents with metadata spread onto each entry', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    const localFiles = [ { path: '/b/workflow.js', url: 'file:///b/workflow.js' } ];
-    matchFilesMock.mockReturnValueOnce( localFiles );
-
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'Flow1', description: 'd' }, path: '/b/workflow.js' };
-    } );
-
-    const { workflows, entrypoint, optionsFile } = await loadWorkflows( '/root' );
-    expect( workflows ).toEqual( [ { name: 'Flow1', description: 'd', path: '/b/workflow.js', external: false } ] );
-    expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
-    expect( optionsFile ).toBe( '/tmp/__workflow_options.js' );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, localFiles );
-    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
-    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/root' );
-  } );
-
-  it( 'calls matchFiles with rootDir and workflowFile matcher', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    const localFiles = [ { path: '/my/app/workflow.js', url: 'file:///my/app/workflow.js' } ];
-    const externalFiles = [ { path: '/my/app/node_modules/pkg/workflow.js', url: 'file:///my/app/node_modules/pkg/workflow.js' } ];
-    matchFilesMock.mockReturnValueOnce( localFiles );
-    findWorkflowsInNodeModulesMock.mockReturnValue( externalFiles );
-
-    await loadWorkflows( '/my/app' );
-
-    expect( matchFilesMock ).toHaveBeenCalledOnce();
-    expect( matchFilesMock ).toHaveBeenCalledWith( '/my/app', [ workflowFileMatcherMock ] );
-    expect( importComponentsMock ).toHaveBeenCalledTimes( 1 );
-    expect( importComponentsMock ).toHaveBeenNthCalledWith( 1, [ ...localFiles, ...externalFiles ] );
-    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
-    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledWith( '/my/app' );
-  } );
-
-  it( 'appends node_modules workflows after local ones and sets external: true', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'LocalFlow', description: 'local' }, path: '/my/app/workflows/wf/workflow.js' };
-      yield {
-        metadata: { name: '__sum_numbers', description: 'from catalog' },
-        path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js'
-      };
-    } );
-    findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js' } ] );
-
-    const { workflows } = await loadWorkflows( '/my/app' );
-    expect( workflows ).toEqual( [
-      { name: 'LocalFlow', description: 'local', path: '/my/app/workflows/wf/workflow.js', external: false },
-      {
-        name: '__sum_numbers',
-        description: 'from catalog',
-        path: '/my/app/node_modules/catalog_pkg/src/w/workflow.js',
-        external: true
-      }
-    ] );
-
-  } );
-
-  it( 'returns only external workflows when the project root has none', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'PkgFlow', description: 'pkg' }, path: '/proj/node_modules/a/w/workflow.js' };
-    } );
-    findWorkflowsInNodeModulesMock.mockReturnValue( [ { path: '/proj/node_modules/a/w/workflow.js' } ] );
-
-    const { workflows } = await loadWorkflows( '/proj' );
-    expect( workflows ).toEqual( [
-      {
-        name: 'PkgFlow',
-        description: 'pkg',
-        path: '/proj/node_modules/a/w/workflow.js',
-        external: true
-      }
-    ] );
-  } );
-
-  it( 'throws when a local workflow path is under a shared directory', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'Invalid' }, path: '/root/shared/workflow.js' };
-    } );
-    workflowPathHasSharedMock.mockReturnValueOnce( true );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow( 'Workflow directory can\'t be named "shared"' );
-    expect( findWorkflowsInNodeModulesMock ).toHaveBeenCalledOnce();
-    expect( workflowPathHasSharedMock ).toHaveBeenCalledWith( '/root/shared/workflow.js' );
-  } );
-
-  it( 'throws when a workflow name conflicts with an earlier workflow name', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'duplicate' }, path: '/root/a/workflow.js' };
-      yield { metadata: { name: 'duplicate' }, path: '/root/b/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow name "duplicate" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
-    );
-  } );
-
-  it( 'throws when a workflow name conflicts with an earlier alias', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/a/workflow.js' };
-      yield { metadata: { name: 'legacy' }, path: '/root/b/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow name "legacy" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
-    );
-  } );
-
-  it( 'throws when an alias conflicts with an earlier workflow name', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'alpha' }, path: '/root/a/workflow.js' };
-      yield { metadata: { name: 'beta', aliases: [ 'alpha' ] }, path: '/root/b/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow "beta" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
-    );
-  } );
-
-  it( 'throws when an alias conflicts with an earlier alias', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'alpha', aliases: [ 'shared_alias' ] }, path: '/root/a/workflow.js' };
-      yield { metadata: { name: 'beta', aliases: [ 'shared_alias' ] }, path: '/root/b/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow "beta" alias "shared_alias" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
-    );
-  } );
-
-  it( 'throws when an alias is identical to its workflow name', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'alpha', aliases: [ 'alpha' ] }, path: '/root/a/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow "alpha" alias "alpha" conflicts with another workflow or alias. Workflow names and aliases must be unique.'
-    );
-  } );
-
-  it( 'allows workflow names and aliases that only differ by case', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'Alpha', aliases: [ 'Legacy' ] }, path: '/root/a/workflow.js' };
-      yield { metadata: { name: 'alpha', aliases: [ 'legacy' ] }, path: '/root/b/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).resolves.toMatchObject( {
-      workflows: [
-        { name: 'Alpha', aliases: [ 'Legacy' ], path: '/root/a/workflow.js', external: false },
-        { name: 'alpha', aliases: [ 'legacy' ], path: '/root/b/workflow.js', external: false }
-      ]
-    } );
-  } );
-
-  it( 'throws when a workflow name is reserved for the internal catalog', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'catalog' }, path: '/root/catalog/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow name "catalog" is reserved for the internal catalog workflow.'
-    );
-  } );
-
-  it( 'throws when a workflow alias is reserved for the internal catalog', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'alpha', aliases: [ 'catalog' ] }, path: '/root/a/workflow.js' };
-    } );
-
-    await expect( loadWorkflows( '/root' ) ).rejects.toThrow(
-      'Workflow "alpha" alias "catalog" is reserved for the internal catalog workflow.'
-    );
-  } );
-
-  it( 'writes an entrypoint with workflows, aliases, and the catalog workflow', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield { metadata: { name: 'W', aliases: [ 'W_old', 'W_legacy' ] }, path: '/abs/wf.js' };
-    } );
-
-    const { entrypoint } = await loadWorkflows( '/root' );
-
-    expect( entrypoint ).toBe( '/tmp/__workflows_entrypoint.js' );
-    expect( writeFileInTempDirMock ).toHaveBeenCalledTimes( 2 );
-    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
-      calledFilename === '__workflows_entrypoint.js'
-    );
-    expect( filename ).toBe( '__workflows_entrypoint.js' );
-    expect( contents ).toContain( 'export { default as W } from \'/abs/wf.js\';' );
-    expect( contents ).toContain( 'export { default as W_old } from \'/abs/wf.js\';' );
-    expect( contents ).toContain( 'export { default as W_legacy } from \'/abs/wf.js\';' );
-    expect( contents ).toContain( 'export { default as catalog }' );
-  } );
-
-  it( 'writes trace options for workflow names, aliases, and the catalog workflow', async () => {
-    const { loadWorkflows } = await import( './workflows.js' );
-    importComponentsMock.mockImplementationOnce( async function *() {
-      yield {
-        metadata: { name: 'Traced', aliases: [ 'Traced_old' ] },
-        path: '/abs/traced.js'
-      };
-      yield {
-        metadata: { name: 'Untraced', aliases: [ 'Untraced_old' ], options: { disableTrace: true } },
-        path: '/abs/untraced.js'
-      };
-    } );
-
-    await loadWorkflows( '/root' );
-
-    const [ contents, filename ] = writeFileInTempDirMock.mock.calls.find( ( [ , calledFilename ] ) =>
-      calledFilename === '__workflow_options.js'
-    );
-    expect( filename ).toBe( '__workflow_options.js' );
-    expect( contents ).toBe( `export default ${JSON.stringify( {
-      Traced: { disableTrace: false },
-      Traced_old: { disableTrace: false },
-      Untraced: { disableTrace: true },
-      Untraced_old: { disableTrace: true },
-      catalog: { disableTrace: true }
-    }, undefined, 2 )};` );
-  } );
-} );

package/src/worker/log_hooks.spec.js

@@ -1,303 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  ACTIVITY_GET_TRACE_DESTINATIONS,
-  BusEventType,
-  LifecycleEvent,
-  WORKFLOW_CATALOG
-} from '#consts';
-
-const createLoggerMock = vi.hoisted( () => () => ( {
-  error: vi.fn(),
-  warn: vi.fn(),
-  info: vi.fn(),
-  http: vi.fn(),
-  verbose: vi.fn(),
-  debug: vi.fn(),
-  silly: vi.fn()
-} ) );
-const activityLogMock = vi.hoisted( () => createLoggerMock() );
-const workflowLogMock = vi.hoisted( () => createLoggerMock() );
-const createChildLoggerMock = vi.hoisted( () =>
-  vi.fn( name => ( name === 'Activity' ? activityLogMock : workflowLogMock ) )
-);
-
-const onHandlers = vi.hoisted( () => ( {} ) );
-const mainEventBusMock = vi.hoisted( () => ( {
-  on: vi.fn( ( eventType, handler ) => {
-    onHandlers[eventType] = handler;
-  } )
-} ) );
-const serializeErrorMock = vi.hoisted( () => vi.fn( error => ( {
-  name: error.name,
-  message: error.message
-} ) ) );
-
-vi.mock( '#logger', () => ( { createChildLogger: createChildLoggerMock } ) );
-vi.mock( '#bus', () => ( { mainEventBus: mainEventBusMock } ) );
-vi.mock( '#helpers/error_serializer', () => ( { serializeError: serializeErrorMock } ) );
-
-import './log_hooks.js';
-
-describe( 'log_hooks', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-  } );
-
-  describe( 'activity events', () => {
-    const activityInfo = {
-      activityId: 'act-1',
-      activityType: 'myWorkflow#myStep',
-      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
-      workflowType: 'myWorkflow'
-    };
-    const basePayload = {
-      activityInfo,
-      outputActivityKind: 'step'
-    };
-
-    it( 'ACTIVITY_START logs full message and second arg', () => {
-      onHandlers[BusEventType.ACTIVITY_START]( basePayload );
-
-      expect( activityLogMock.info ).toHaveBeenCalledTimes( 1 );
-      expect( activityLogMock.info ).toHaveBeenCalledWith(
-        'Started myWorkflow#myStep step',
-        {
-          event: LifecycleEvent.START,
-          activityId: 'act-1',
-          activityType: 'myWorkflow#myStep',
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1'
-        }
-      );
-    } );
-
-    it( 'ACTIVITY_START does not log trace destination activity', () => {
-      onHandlers[BusEventType.ACTIVITY_START]( {
-        ...basePayload,
-        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS }
-      } );
-
-      expect( activityLogMock.info ).not.toHaveBeenCalled();
-    } );
-
-    it( 'ACTIVITY_END logs full message and second arg', () => {
-      onHandlers[BusEventType.ACTIVITY_END]( { ...basePayload, duration: 42 } );
-
-      expect( activityLogMock.info ).toHaveBeenCalledTimes( 1 );
-      expect( activityLogMock.info ).toHaveBeenCalledWith(
-        'Ended myWorkflow#myStep step',
-        {
-          event: LifecycleEvent.END,
-          activityId: 'act-1',
-          activityType: 'myWorkflow#myStep',
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1'
-        }
-      );
-    } );
-
-    it( 'ACTIVITY_END does not log trace destination activity', () => {
-      onHandlers[BusEventType.ACTIVITY_END]( {
-        ...basePayload,
-        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS }
-      } );
-
-      expect( activityLogMock.info ).not.toHaveBeenCalled();
-    } );
-
-    it( 'ACTIVITY_ERROR logs full message and second arg', () => {
-      const err = new Error( 'step failed' );
-      err.name = 'ProviderError';
-      onHandlers[BusEventType.ACTIVITY_ERROR]( {
-        ...basePayload,
-        duration: 100,
-        error: err
-      } );
-
-      expect( activityLogMock.error ).toHaveBeenCalledTimes( 1 );
-      expect( activityLogMock.error ).toHaveBeenCalledWith(
-        'Error myWorkflow#myStep step: ProviderError',
-        {
-          event: LifecycleEvent.ERROR,
-          activityId: 'act-1',
-          activityType: 'myWorkflow#myStep',
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1',
-          error: { name: 'ProviderError', message: 'step failed' }
-        }
-      );
-      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
-    } );
-
-    it( 'ACTIVITY_ERROR does not log trace destination activity', () => {
-      onHandlers[BusEventType.ACTIVITY_ERROR]( {
-        ...basePayload,
-        activityInfo: { ...activityInfo, activityType: ACTIVITY_GET_TRACE_DESTINATIONS },
-        error: new Error( 'x' )
-      } );
-
-      expect( activityLogMock.error ).not.toHaveBeenCalled();
-    } );
-
-    it( 'ACTIVITY_LOG logs dynamic levels with metadata and serialized activity fields', () => {
-      onHandlers[BusEventType.ACTIVITY_LOG]( {
-        activityInfo,
-        level: 'debug',
-        message: 'activity detail',
-        metadata: {
-          custom: 'value',
-          workflowId: 'metadata-workflow-id'
-        }
-      } );
-
-      expect( activityLogMock.debug ).toHaveBeenCalledTimes( 1 );
-      expect( activityLogMock.debug ).toHaveBeenCalledWith( 'activity detail', {
-        custom: 'value',
-        activityId: 'act-1',
-        activityType: 'myWorkflow#myStep',
-        workflowId: 'wf-1',
-        workflowType: 'myWorkflow',
-        runId: 'run-1'
-      } );
-    } );
-
-    it( 'ACTIVITY_LOG accepts omitted metadata', () => {
-      onHandlers[BusEventType.ACTIVITY_LOG]( {
-        activityInfo,
-        level: 'info',
-        message: 'activity detail'
-      } );
-
-      expect( activityLogMock.info ).toHaveBeenCalledWith( 'activity detail', {
-        activityId: 'act-1',
-        activityType: 'myWorkflow#myStep',
-        workflowId: 'wf-1',
-        workflowType: 'myWorkflow',
-        runId: 'run-1'
-      } );
-    } );
-  } );
-
-  describe( 'workflow events', () => {
-    const workflowDetails = {
-      workflowId: 'wf-1',
-      workflowType: 'myWorkflow',
-      runId: 'run-1'
-    };
-    const basePayload = { workflowDetails };
-
-    it( 'WORKFLOW_START logs full message and second arg', () => {
-      onHandlers[BusEventType.WORKFLOW_START]( basePayload );
-
-      expect( workflowLogMock.info ).toHaveBeenCalledTimes( 1 );
-      expect( workflowLogMock.info ).toHaveBeenCalledWith(
-        'Started myWorkflow workflow',
-        {
-          event: LifecycleEvent.START,
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1'
-        }
-      );
-    } );
-
-    it( 'WORKFLOW_START does not log when workflowType is WORKFLOW_CATALOG', () => {
-      onHandlers[BusEventType.WORKFLOW_START]( {
-        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG }
-      } );
-
-      expect( workflowLogMock.info ).not.toHaveBeenCalled();
-    } );
-
-    it( 'WORKFLOW_END logs full message and second arg', () => {
-      onHandlers[BusEventType.WORKFLOW_END]( basePayload );
-
-      expect( workflowLogMock.info ).toHaveBeenCalledTimes( 1 );
-      expect( workflowLogMock.info ).toHaveBeenCalledWith(
-        'Ended myWorkflow workflow',
-        {
-          event: LifecycleEvent.END,
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1'
-        }
-      );
-    } );
-
-    it( 'WORKFLOW_END does not log when workflowType is WORKFLOW_CATALOG', () => {
-      onHandlers[BusEventType.WORKFLOW_END]( {
-        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG }
-      } );
-
-      expect( workflowLogMock.info ).not.toHaveBeenCalled();
-    } );
-
-    it( 'WORKFLOW_ERROR logs full message and second arg', () => {
-      const err = { name: 'TypeError', message: 'workflow boom' };
-      onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        ...basePayload,
-        duration: 150,
-        error: err
-      } );
-
-      expect( workflowLogMock.error ).toHaveBeenCalledTimes( 1 );
-      expect( workflowLogMock.error ).toHaveBeenCalledWith(
-        'Error myWorkflow workflow: TypeError',
-        {
-          event: LifecycleEvent.ERROR,
-          workflowId: 'wf-1',
-          workflowType: 'myWorkflow',
-          runId: 'run-1',
-          error: { name: 'TypeError', message: 'workflow boom' }
-        }
-      );
-      expect( serializeErrorMock ).toHaveBeenCalledWith( err, { dropKeys: [ 'stack' ] } );
-    } );
-
-    it( 'WORKFLOW_ERROR does not log when workflowType is WORKFLOW_CATALOG', () => {
-      onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        workflowDetails: { ...workflowDetails, workflowType: WORKFLOW_CATALOG },
-        error: new Error( 'x' )
-      } );
-
-      expect( workflowLogMock.error ).not.toHaveBeenCalled();
-    } );
-
-    it( 'WORKFLOW_LOG logs dynamic levels with metadata and serialized workflow fields', () => {
-      onHandlers[BusEventType.WORKFLOW_LOG]( {
-        workflowDetails,
-        level: 'warn',
-        message: 'workflow detail',
-        metadata: {
-          custom: 'value',
-          runId: 'metadata-run-id'
-        }
-      } );
-
-      expect( workflowLogMock.warn ).toHaveBeenCalledTimes( 1 );
-      expect( workflowLogMock.warn ).toHaveBeenCalledWith( 'workflow detail', {
-        custom: 'value',
-        workflowId: 'wf-1',
-        workflowType: 'myWorkflow',
-        runId: 'run-1'
-      } );
-    } );
-
-    it( 'WORKFLOW_LOG accepts omitted metadata', () => {
-      onHandlers[BusEventType.WORKFLOW_LOG]( {
-        workflowDetails,
-        level: 'info',
-        message: 'workflow detail'
-      } );
-
-      expect( workflowLogMock.info ).toHaveBeenCalledWith( 'workflow detail', {
-        workflowId: 'wf-1',
-        workflowType: 'myWorkflow',
-        runId: 'run-1'
-      } );
-    } );
-  } );
-} );