Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
11.9 KB
Raw Blame
// @vitest-environment jsdom
import React from 'react'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
import type {
  WorkflowRecipeResource,
  WorkflowRunArtifactsResult,
  WorkflowRunListItem,
  WorkflowRunsResult,
} from '../../../../src/types'
import type { WorkflowSummary } from '../../workflows.types'
import { useWorkflowController, useWorkflowRecentRuns } from '../domain/useWorkflowController'

const WORKFLOW: WorkflowSummary = {
  namespace: 'sandbox-recipes',
  name: 'stateful-workflow',
  status: 'Active',
  createdAt: '2026-05-18T00:00:00Z',
  triggerableByUser: true,
}

const WORKFLOW_RESOURCE: WorkflowRecipeResource = {
  metadata: {
    namespace: WORKFLOW.namespace,
    name: WORKFLOW.name,
    creationTimestamp: WORKFLOW.createdAt,
  },
  spec: {
    triggers: {
      onDemand: {
        allowedActors: ['user'],
      },
    },
    inputContract: {
      properties: {
        topic: {
          type: 'string',
          default: 'initial topic',
        },
      },
    },
  },
  status: {
    phase: WORKFLOW.status,
  },
}

type Deferred<T> = {
  promise: Promise<T>
  resolve: (value: T) => void
}

function createQueryClient() {
  return new QueryClient({
    defaultOptions: {
      queries: {
        retry: false,
      },
    },
  })
}

function createDeferred<T>(): Deferred<T> {
  let resolve!: (value: T) => void
  const promise = new Promise<T>(res => {
    resolve = res
  })
  return { promise, resolve }
}

function createRunsResult() {
  return {
    items: [
      {
        id: 'run-1',
        source: 'live',
        phase: 'Succeeded',
        triggeredAt: '2026-05-18T00:00:00Z',
        startedAt: '2026-05-18T00:00:01Z',
        completedAt: '2026-05-18T00:00:02Z',
        message: null,
        actor: null,
        executionRef: null,
      },
    ],
    count: 1,
  }
}

function installClerumHarness(
  options: {
    runsResult?: ReturnType<typeof createRunsResult> | Promise<ReturnType<typeof createRunsResult>>
  } = {}
) {
  const read = vi.fn(async () => WORKFLOW_RESOURCE)
  const runs = vi.fn(async () => options.runsResult ?? createRunsResult())
  const trigger = vi.fn(async () => undefined)

  Object.defineProperty(window, 'clerum', {
    configurable: true,
    writable: true,
    value: {
      workflows: {
        list: vi.fn(async () => ({ items: [WORKFLOW_RESOURCE], count: 1 })),
        read,
        runs,
        trigger,
        listRunArtifacts: vi.fn(async () => ({ artifacts: [] })),
      },
    },
  })

  return { read, runs, trigger }
}

function HookHarness() {
  const controller = useWorkflowController({ setStatus: vi.fn() })
  const topic = String(controller.workflowInputValues.topic ?? '')

  return (
    <div>
      <div data-testid="selected-workflow">{controller.selectedWorkflow?.name ?? 'none'}</div>
      <div data-testid="topic">{topic}</div>
      <div data-testid="run-count">{controller.workflowRuns.length}</div>
      <div data-testid="runs-loading">{String(controller.workflowRunsLoading)}</div>
      <button type="button" onClick={() => void controller.handleSelectWorkflow(WORKFLOW)}>
        Select workflow
      </button>
      <button
        type="button"
        onClick={() =>
          controller.setWorkflowInputValues({
            ...controller.workflowInputValues,
            topic: 'updated topic',
          })
        }
      >
        Update input
      </button>
      <button
        type="button"
        onClick={() => void controller.handleTriggerWorkflow(WORKFLOW.namespace, WORKFLOW.name)}
      >
        Trigger workflow
      </button>
    </div>
  )
}

function renderHarness(queryClient: QueryClient) {
  return render(
    <QueryClientProvider client={queryClient}>
      <HookHarness />
    </QueryClientProvider>
  )
}

describe('useWorkflowController', () => {
  afterEach(() => {
    cleanup()
    vi.restoreAllMocks()
    delete (window as { clerum?: unknown }).clerum
  })

  it('preserves selected workflow state across hook remounts without refetching detail or runs', async () => {
    const clerum = installClerumHarness()
    const queryClient = createQueryClient()
    const firstRender = renderHarness(queryClient)

    fireEvent.click(screen.getByRole('button', { name: 'Select workflow' }))

    await waitFor(() =>
      expect(screen.getByTestId('selected-workflow').textContent).toBe(WORKFLOW.name)
    )
    await waitFor(() => expect(screen.getByTestId('topic').textContent).toBe('initial topic'))
    await waitFor(() => expect(screen.getByTestId('run-count').textContent).toBe('1'))

    fireEvent.click(screen.getByRole('button', { name: 'Update input' }))
    await waitFor(() => expect(screen.getByTestId('topic').textContent).toBe('updated topic'))

    firstRender.unmount()
    renderHarness(queryClient)

    expect(screen.getByTestId('selected-workflow').textContent).toBe(WORKFLOW.name)
    expect(screen.getByTestId('topic').textContent).toBe('updated topic')
    expect(screen.getByTestId('run-count').textContent).toBe('1')
    expect(clerum.read).toHaveBeenCalledTimes(1)
    expect(clerum.runs).toHaveBeenCalledTimes(1)
  })

  it('keeps workflow runs loading while selected workflow runs have not resolved', async () => {
    const deferredRuns = createDeferred<ReturnType<typeof createRunsResult>>()
    installClerumHarness({ runsResult: deferredRuns.promise })
    const queryClient = createQueryClient()
    renderHarness(queryClient)

    fireEvent.click(screen.getByRole('button', { name: 'Select workflow' }))

    await waitFor(() =>
      expect(screen.getByTestId('selected-workflow').textContent).toBe(WORKFLOW.name)
    )
    expect(screen.getByTestId('runs-loading').textContent).toBe('true')
    expect(screen.getByTestId('run-count').textContent).toBe('0')

    await act(async () => {
      deferredRuns.resolve(createRunsResult())
    })

    await waitFor(() => expect(screen.getByTestId('runs-loading').textContent).toBe('false'))
    expect(screen.getByTestId('run-count').textContent).toBe('1')
  })

  it('passes raw input values to the direct workflow trigger path', async () => {
    const clerum = installClerumHarness()
    const queryClient = createQueryClient()
    renderHarness(queryClient)

    fireEvent.click(screen.getByRole('button', { name: 'Select workflow' }))
    await waitFor(() => expect(screen.getByTestId('topic').textContent).toBe('initial topic'))

    fireEvent.click(screen.getByRole('button', { name: 'Update input' }))
    await waitFor(() => expect(screen.getByTestId('topic').textContent).toBe('updated topic'))

    fireEvent.click(screen.getByRole('button', { name: 'Trigger workflow' }))

    await waitFor(() =>
      expect(clerum.trigger).toHaveBeenCalledWith(
        'sandbox-recipes',
        'stateful-workflow',
        { topic: 'updated topic' },
        expect.any(String)
      )
    )
  })
})

// A run item typed against the real IPC contract (WorkflowRunListItem), not a
// hand-faked shape of some other layer (T1): the stubs below stand in for
// `window.clerum.workflows.runs` / `listRunArtifacts`, whose declared output
// types are WorkflowRunsResult / WorkflowRunArtifactsResult.
function makeRun(id: string, overrides: Partial<WorkflowRunListItem> = {}): WorkflowRunListItem {
  return {
    id,
    source: 'live',
    phase: 'Succeeded',
    triggeredAt: '2026-05-18T00:00:00Z',
    startedAt: '2026-05-18T00:00:01Z',
    completedAt: '2026-05-18T00:00:02Z',
    message: null,
    actor: null,
    executionRef: { namespace: WORKFLOW.namespace, name: `exec-${id}` },
    ...overrides,
  }
}

describe('useWorkflowRecentRuns', () => {
  afterEach(() => {
    cleanup()
    vi.restoreAllMocks()
    delete (window as { clerum?: unknown }).clerum
  })

  function RecentRunsHarness({ withController = false }: { withController?: boolean }) {
    // The controller is only mounted for the trigger-refresh test; its trigger
    // path is what should invalidate the cell's (limit-5) runs query.
    const controller = useWorkflowController({ setStatus: vi.fn() })
    const recent = useWorkflowRecentRuns(WORKFLOW)
    return (
      <div>
        <div data-testid="latest-run">{recent.latestRun?.id ?? 'none'}</div>
        <div data-testid="run-count">{recent.runCount}</div>
        <div data-testid="latest-artifacts">
          {(recent.latestRun?.artifacts ?? []).map(a => a.name).join(',')}
        </div>
        {withController ? (
          <button
            type="button"
            onClick={() => void controller.handleTriggerWorkflow(WORKFLOW.namespace, WORKFLOW.name)}
          >
            Trigger
          </button>
        ) : null}
      </div>
    )
  }

  function renderRecentRuns(queryClient: QueryClient, withController = false) {
    return render(
      <QueryClientProvider client={queryClient}>
        <RecentRunsHarness withController={withController} />
      </QueryClientProvider>
    )
  }

  it('derives the latest run, enriches only it with artifacts, and reads runCount from data.count', async () => {
    const latest = makeRun('run-latest')
    const older = makeRun('run-older')
    // `count` (7) deliberately differs from items.length (2) to prove the cell
    // surfaces the server's total, not the fetched-window length.
    const runsResult: WorkflowRunsResult = { items: [latest, older], count: 7 }
    const artifactsResult: WorkflowRunArtifactsResult = {
      artifacts: [{ name: 'result.json', format: 'json', sizeBytes: 12, createdAt: 'x' }],
    }
    const runs = vi.fn(async () => runsResult)
    const listRunArtifacts = vi.fn(async () => artifactsResult)

    Object.defineProperty(window, 'clerum', {
      configurable: true,
      writable: true,
      value: { workflows: { runs, listRunArtifacts } },
    })

    renderRecentRuns(createQueryClient())

    await waitFor(() => expect(screen.getByTestId('latest-run').textContent).toBe('run-latest'))
    expect(screen.getByTestId('run-count').textContent).toBe('7')
    await waitFor(() =>
      expect(screen.getByTestId('latest-artifacts').textContent).toBe('result.json')
    )

    // Only the latest run is enriched — never the older sibling.
    expect(listRunArtifacts).toHaveBeenCalledTimes(1)
    expect(listRunArtifacts).toHaveBeenCalledWith(WORKFLOW.namespace, WORKFLOW.name, 'run-latest')
    expect(listRunArtifacts).not.toHaveBeenCalledWith(
      WORKFLOW.namespace,
      WORKFLOW.name,
      'run-older'
    )
  })

  it('refreshes the recent-runs cell after a trigger without a manual Refresh', async () => {
    const before = makeRun('run-before')
    const after = makeRun('run-after')
    // The trigger flips the runs response; the cell must pick up `run-after`
    // because the trigger invalidates the RECENT_RUNS_LIMIT key it reads (FIX 1).
    let triggered = false
    const runs = vi.fn(async () =>
      triggered
        ? ({ items: [after, before], count: 2 } as WorkflowRunsResult)
        : ({ items: [before], count: 1 } as WorkflowRunsResult)
    )
    const listRunArtifacts = vi.fn(async () => ({ artifacts: [] }) as WorkflowRunArtifactsResult)
    const trigger = vi.fn(async () => {
      triggered = true
      return undefined
    })

    Object.defineProperty(window, 'clerum', {
      configurable: true,
      writable: true,
      value: {
        workflows: {
          list: vi.fn(async () => ({ items: [WORKFLOW_RESOURCE], count: 1 })),
          read: vi.fn(async () => WORKFLOW_RESOURCE),
          runs,
          listRunArtifacts,
          trigger,
        },
      },
    })

    renderRecentRuns(createQueryClient(), true)

    await waitFor(() => expect(screen.getByTestId('latest-run').textContent).toBe('run-before'))

    fireEvent.click(screen.getByRole('button', { name: 'Trigger' }))

    await waitFor(() => expect(trigger).toHaveBeenCalled())
    // The observable result: the cell now shows the newly created run.
    await waitFor(() => expect(screen.getByTestId('latest-run').textContent).toBe('run-after'))
    expect(screen.getByTestId('run-count').textContent).toBe('2')
  })
})