Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test(web): exercise workflow actions against real stores (#44381)

Stephen Zhouc493a3b134e8
diff --git a/web/app/components/rag-pipeline/components/panel/test-run/preparation/__tests__/hooks.spec.ts b/web/app/components/rag-pipeline/components/panel/test-run/preparation/__tests__/hooks.spec.ts
index 7e8c792af2a..4c3e1515dea 100644
--- a/web/app/components/rag-pipeline/components/panel/test-run/preparation/__tests__/hooks.spec.ts
+++ b/web/app/components/rag-pipeline/components/panel/test-run/preparation/__tests__/hooks.spec.ts
@@ -1,8 +1,16 @@
-import type { DataSourceNodeType } from '@/app/components/workflow/nodes/data-source/types'
-import { renderHook } from '@testing-library/react'
-import { act } from 'react'
-import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
+import type { ReactNode } from 'react'
+import type { DataSourceNotionWorkspace, NotionPage } from '@/models/common'
+import type { CrawlResult, CrawlResultItem } from '@/models/datasets'
+import type { OnlineDriveFile } from '@/models/pipeline'
+import { act, renderHook } from '@testing-library/react'
+import { createElement } from 'react'
+import { createDataSourceStore } from '@/app/components/datasets/documents/create-from-pipeline/data-source/store'
+import { DataSourceContext } from '@/app/components/datasets/documents/create-from-pipeline/data-source/store/provider'
+import { createNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowCanvasHook } from '@/app/components/workflow/__tests__/workflow-test-env'
import { BlockEnum } from '@/app/components/workflow/types'
+import { CrawlStep } from '@/models/datasets'
+import { OnlineDriveFileType } from '@/models/pipeline'
import {
useDatasourceOptions,
useOnlineDocument,
@@ -11,146 +19,168 @@ import {
useWebsiteCrawl,
} from '../hooks'
-const mockNodes: Array<{ id: string; data: Partial<DataSourceNodeType> & { type: string } }> = []
-vi.mock('reactflow', () => ({
- useNodes: () => mockNodes,
-}))
-
-const mockDataSourceStoreGetState = vi.fn()
-vi.mock('@/app/components/datasets/documents/create-from-pipeline/data-source/store', () => ({
- useDataSourceStore: () => ({
- getState: mockDataSourceStoreGetState,
- }),
-}))
-
it('moves between datasource selection and document processing', () => {
const { result } = renderHook(() => useTestRunSteps())
+
expect(result.current.currentStep).toBe(1)
expect(result.current.steps.map((step) => step.value)).toEqual([
'dataSource',
'documentProcessing',
])
+
act(() => result.current.handleNextStep())
expect(result.current.currentStep).toBe(2)
+
act(() => result.current.handleBackStep())
expect(result.current.currentStep).toBe(1)
})
-describe('useDatasourceOptions', () => {
- beforeEach(() => {
- mockNodes.length = 0
- vi.clearAllMocks()
+it('keeps datasource options in sync with live canvas changes', () => {
+ const source = createNode({
+ id: 'source-1',
+ data: { type: BlockEnum.DataSource, title: 'Notion source' },
})
-
- it('should return empty options when no DataSource nodes', () => {
- mockNodes.push({ id: 'n1', data: { type: BlockEnum.LLM, title: 'LLM' } })
-
- const { result } = renderHook(() => useDatasourceOptions())
-
- expect(result.current).toEqual([])
+ const code = createNode({ id: 'code-1', data: { type: BlockEnum.Code, title: 'Code' } })
+ const anotherSource = createNode({
+ id: 'source-2',
+ data: { type: BlockEnum.DataSource, title: 'Drive source' },
+ })
+ const { result, setCanvas } = renderWorkflowCanvasHook(() => useDatasourceOptions(), {
+ nodes: [source, code],
})
- it('should filter out non-DataSource nodes', () => {
- mockNodes.push(
- { id: 'ds-1', data: { type: BlockEnum.DataSource, title: 'Source' } },
- { id: 'llm-1', data: { type: BlockEnum.LLM, title: 'LLM' } },
- { id: 'inset-e-1', data: { type: BlockEnum.End, title: 'End' } },
- )
+ expect(result.current).toEqual([{ label: 'Notion source', value: 'source-1', data: source.data }])
- const { result } = renderHook(() => useDatasourceOptions())
+ act(() => setCanvas({ nodes: [code, anotherSource] }))
+ expect(result.current).toEqual([
+ { label: 'Drive source', value: 'source-2', data: anotherSource.data },
+ ])
- expect(result.current).toEqual([
- { label: 'Source', value: 'ds-1', data: { type: BlockEnum.DataSource, title: 'Source' } },
- ])
- })
+ act(() => setCanvas({ nodes: [code] }))
+ expect(result.current).toEqual([])
})
-describe('useOnlineDocument', () => {
- it('should clear all online document data', () => {
- const mockSetDocumentsData = vi.fn()
- const mockSetSearchValue = vi.fn()
- const mockSetSelectedPagesId = vi.fn()
- const mockSetOnlineDocuments = vi.fn()
- const mockSetCurrentDocument = vi.fn()
-
- mockDataSourceStoreGetState.mockReturnValue({
- setDocumentsData: mockSetDocumentsData,
- setSearchValue: mockSetSearchValue,
- setSelectedPagesId: mockSetSelectedPagesId,
- setOnlineDocuments: mockSetOnlineDocuments,
- setCurrentDocument: mockSetCurrentDocument,
+const document: NotionPage = {
+ workspace_id: 'workspace-1',
+ page_id: 'page-1',
+ page_name: 'Architecture',
+ parent_id: 'root',
+ type: 'page',
+ page_icon: null,
+ is_bound: false,
+}
+const documentsData: DataSourceNotionWorkspace[] = [
+ {
+ workspace_id: 'workspace-1',
+ workspace_name: 'Engineering',
+ workspace_icon: null,
+ pages: [document],
+ },
+]
+const websitePage: CrawlResultItem = {
+ title: 'Guide',
+ source_url: 'https://example.com/guide',
+ markdown: '# Guide',
+ description: 'A product guide',
+}
+const crawlResult: CrawlResult = { data: [websitePage], time_consuming: 1 }
+const driveFile: OnlineDriveFile = {
+ id: 'file-1',
+ name: 'Guide.pdf',
+ type: OnlineDriveFileType.file,
+ size: 1024,
+}
+
+function createDataSourceWrapper(store: ReturnType<typeof createDataSourceStore>) {
+ return function DataSourceWrapper({ children }: { children: ReactNode }) {
+ return createElement(DataSourceContext, { value: store }, children)
+ }
+}
+
+describe('datasource preparation cleanup', () => {
+ it('clears online document state without disturbing unrelated datasource state', () => {
+ const store = createDataSourceStore()
+ store.setState({
+ currentCredentialId: 'credential-1',
+ documentsData,
+ searchValue: 'architecture',
+ selectedPagesId: new Set(['page-1']),
+ onlineDocuments: [document],
+ currentDocument: document,
+ })
+ store.getState().previewOnlineDocumentRef.current = document
+ const { result } = renderHook(() => useOnlineDocument(), {
+ wrapper: createDataSourceWrapper(store),
})
- const { result } = renderHook(() => useOnlineDocument())
+ act(() => result.current.clearOnlineDocumentData())
- act(() => {
- result.current.clearOnlineDocumentData()
+ expect(store.getState()).toMatchObject({
+ currentCredentialId: 'credential-1',
+ documentsData: [],
+ searchValue: '',
+ onlineDocuments: [],
+ currentDocument: undefined,
})
-
- expect(mockSetDocumentsData).toHaveBeenCalledWith([])
- expect(mockSetSearchValue).toHaveBeenCalledWith('')
- expect(mockSetSelectedPagesId).toHaveBeenCalledWith(new Set())
- expect(mockSetOnlineDocuments).toHaveBeenCalledWith([])
- expect(mockSetCurrentDocument).toHaveBeenCalledWith(undefined)
+ expect(store.getState().selectedPagesId).toEqual(new Set())
+ expect(store.getState().previewOnlineDocumentRef.current).toBeUndefined()
})
-})
-describe('useWebsiteCrawl', () => {
- it('should clear all website crawl data', () => {
- const mockSetStep = vi.fn()
- const mockSetCrawlResult = vi.fn()
- const mockSetWebsitePages = vi.fn()
- const mockSetPreviewIndex = vi.fn()
- const mockSetCurrentWebsite = vi.fn()
-
- mockDataSourceStoreGetState.mockReturnValue({
- setStep: mockSetStep,
- setCrawlResult: mockSetCrawlResult,
- setWebsitePages: mockSetWebsitePages,
- setPreviewIndex: mockSetPreviewIndex,
- setCurrentWebsite: mockSetCurrentWebsite,
+ it('clears website crawl state without disturbing unrelated datasource state', () => {
+ const store = createDataSourceStore()
+ store.setState({
+ currentCredentialId: 'credential-1',
+ step: CrawlStep.finished,
+ crawlResult,
+ websitePages: [websitePage],
+ currentWebsite: websitePage,
+ previewIndex: 0,
+ })
+ store.getState().previewWebsitePageRef.current = websitePage
+ const { result } = renderHook(() => useWebsiteCrawl(), {
+ wrapper: createDataSourceWrapper(store),
})
- const { result } = renderHook(() => useWebsiteCrawl())
+ act(() => result.current.clearWebsiteCrawlData())
- act(() => {
- result.current.clearWebsiteCrawlData()
+ expect(store.getState()).toMatchObject({
+ currentCredentialId: 'credential-1',
+ step: CrawlStep.init,
+ crawlResult: undefined,
+ websitePages: [],
+ currentWebsite: undefined,
+ previewIndex: -1,
})
-
- expect(mockSetStep).toHaveBeenCalledWith('init')
- expect(mockSetCrawlResult).toHaveBeenCalledWith(undefined)
- expect(mockSetCurrentWebsite).toHaveBeenCalledWith(undefined)
- expect(mockSetWebsitePages).toHaveBeenCalledWith([])
- expect(mockSetPreviewIndex).toHaveBeenCalledWith(-1)
+ expect(store.getState().previewWebsitePageRef.current).toBeUndefined()
})
-})
-describe('useOnlineDrive', () => {
- it('should clear all online drive data', () => {
- const mockSetOnlineDriveFileList = vi.fn()
- const mockSetBucket = vi.fn()
- const mockSetPrefix = vi.fn()
- const mockSetKeywords = vi.fn()
- const mockSetSelectedFileIds = vi.fn()
-
- mockDataSourceStoreGetState.mockReturnValue({
- setOnlineDriveFileList: mockSetOnlineDriveFileList,
- setBucket: mockSetBucket,
- setPrefix: mockSetPrefix,
- setKeywords: mockSetKeywords,
- setSelectedFileIds: mockSetSelectedFileIds,
+ it('clears online drive selection without disturbing unrelated datasource state', () => {
+ const store = createDataSourceStore()
+ store.setState({
+ currentCredentialId: 'credential-1',
+ breadcrumbs: ['Root', 'Guides'],
+ onlineDriveFileList: [driveFile],
+ bucket: 'documents',
+ prefix: ['guides'],
+ keywords: 'guide',
+ selectedFileIds: ['file-1'],
+ })
+ store.getState().previewOnlineDriveFileRef.current = driveFile
+ const { result } = renderHook(() => useOnlineDrive(), {
+ wrapper: createDataSourceWrapper(store),
})
- const { result } = renderHook(() => useOnlineDrive())
+ act(() => result.current.clearOnlineDriveData())
- act(() => {
- result.current.clearOnlineDriveData()
+ expect(store.getState()).toMatchObject({
+ currentCredentialId: 'credential-1',
+ breadcrumbs: ['Root', 'Guides'],
+ onlineDriveFileList: [],
+ bucket: '',
+ prefix: [],
+ keywords: '',
+ selectedFileIds: [],
})
-
- expect(mockSetOnlineDriveFileList).toHaveBeenCalledWith([])
- expect(mockSetBucket).toHaveBeenCalledWith('')
- expect(mockSetPrefix).toHaveBeenCalledWith([])
- expect(mockSetKeywords).toHaveBeenCalledWith('')
- expect(mockSetSelectedFileIds).toHaveBeenCalledWith([])
+ expect(store.getState().previewOnlineDriveFileRef.current).toBeUndefined()
})
})
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.spec.tsx
index 4c89b197564..e46dede3f6f 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.spec.tsx
@@ -1,103 +1,22 @@
-import type { ReactNode } from 'react'
+import type { NodeProps } from 'reactflow'
import type { InjectWorkflowStoreSliceFn } from '@/app/components/workflow/store'
-import type { CommonNodeType } from '@/app/components/workflow/types'
-import { screen, waitFor } from '@testing-library/react'
+import type { CommonNodeType, Edge } from '@/app/components/workflow/types'
+import { render, screen, waitFor, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { useEdges } from 'reactflow'
import { createWorkflowSlice } from '@/app/components/workflow-app/store/workflow/workflow-slice'
+import {
+ CANVAS_NODES_STATUS_NAME,
+ CanvasNodesCatalogProbe,
+} from '@/app/components/workflow/__tests__/canvas-nodes-catalog-probe'
+import { createNode } from '@/app/components/workflow/__tests__/fixtures'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { CUSTOM_NODE } from '@/app/components/workflow/constants'
import { BlockEnum } from '@/app/components/workflow/types'
+import { seedModelProviderQueries } from '@/test/console/model-provider'
+import { createConsoleQueryWrapper, seedAppDslVersion } from '@/test/console/query-data'
import { NodeSourceHandle, NodeTargetHandle } from '../node-handle'
-type MockHooksState = {
- availablePrevBlocks: BlockEnum[]
- availableNextBlocks: BlockEnum[]
- isChatflow: boolean
- isReadOnly: boolean
-}
-
-const { mockHandleNodeAdd, mockHooksState } = vi.hoisted(() => ({
- mockHandleNodeAdd: vi.fn(),
- mockHooksState: {
- availablePrevBlocks: [],
- availableNextBlocks: [],
- isChatflow: false,
- isReadOnly: false,
- } as MockHooksState,
-}))
-let autoOpen = false
-const render = (
- ui: React.ReactElement,
- options: Parameters<typeof renderWorkflowFlowComponent>[1] = {},
-) =>
- renderWorkflowFlowComponent(ui, {
- ...options,
- initialStoreState: {
- shouldAutoOpenStartNodeSelector: autoOpen,
- canvasReadOnly: mockHooksState.isReadOnly,
- },
- hooksStoreProps: {
- accessControl: {
- canEdit: true,
- canRun: true,
- canImportExportDSL: true,
- canReleaseAndVersion: true,
- },
- },
- })
-
-type HandleProps = {
- id?: string
- className?: string
- children?: ReactNode
- onClick?: () => void
-}
-
-vi.mock('reactflow', async (importOriginal) => ({
- ...(await importOriginal<typeof import('reactflow')>()),
- Handle: ({ id, className, children, onClick }: HandleProps) => (
- <div
- data-testid={`handle-${id ?? 'unknown'}`}
- data-handleid={id}
- className={className}
- role="button"
- tabIndex={0}
- onClick={onClick}
- onKeyDown={(event) => {
- if (event.key === 'Enter' || event.key === ' ') onClick?.()
- }}
- >
- {children}
- </div>
- ),
- Position: {
- Left: 'left',
- Right: 'right',
- },
-}))
-
-vi.mock('../../../../hooks/use-available-blocks', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../../../../hooks/use-available-blocks')>()
-
- return {
- ...actual,
- useAvailableBlocks: () => ({
- availablePrevBlocks: mockHooksState.availablePrevBlocks,
- availableNextBlocks: mockHooksState.availableNextBlocks,
- }),
- }
-})
-
-vi.mock('../../../../hooks/use-nodes-interactions', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../../../../hooks/use-nodes-interactions')>()
-
- return {
- ...actual,
- useNodesInteractions: () => ({
- handleNodeAdd: mockHandleNodeAdd,
- }),
- }
-})
-
vi.mock('@/service/use-plugins', () => ({
useFeaturedToolsRecommendations: () => ({ plugins: [], isLoading: false }),
useFeaturedTriggersRecommendations: () => ({ plugins: [], isLoading: false }),
@@ -126,197 +45,227 @@ vi.mock('@/app/components/plugins/marketplace/query', () => ({
useMarketplacePlugins: () => ({ data: undefined }),
}))
-const createNodeData = (overrides: Partial<CommonNodeType> = {}): CommonNodeType => ({
- type: BlockEnum.Code,
- title: 'Node',
- desc: '',
- selected: false,
- ...overrides,
-})
+function SourceHandleNode({ id, data }: NodeProps<CommonNodeType>) {
+ return (
+ <div role="group" aria-label={data.title}>
+ <span>{data.title}</span>
+ <NodeSourceHandle id={id} data={data} handleId="source-handle" />
+ </div>
+ )
+}
-const getAddNodeButton = () => screen.getByRole('button', { name: 'workflow.common.addBlock' })
-const queryAddNodeButton = () => screen.queryByRole('button', { name: 'workflow.common.addBlock' })
+function TargetHandleNode({ id, data }: NodeProps<CommonNodeType>) {
+ return (
+ <div role="group" aria-label={data.title}>
+ <span>{data.title}</span>
+ <NodeTargetHandle id={id} data={data} handleId="target-handle" />
+ </div>
+ )
+}
-const renderTargetHandle = (dataOverrides: Partial<CommonNodeType> = {}) => {
- return render(
- <NodeTargetHandle
- id="target-node"
- data={createNodeData(dataOverrides)}
- handleId="target-handle"
- nodeSelectorClassName="custom-selector"
- handleClassName="custom-target-handle"
- />,
- {
- injectWorkflowStoreSliceFn: createWorkflowSlice as InjectWorkflowStoreSliceFn,
- resource: {
- kind: 'app',
- appId: 'app-1',
- mode: mockHooksState.isChatflow ? 'advanced-chat' : 'workflow',
- },
- },
+function CanvasEdgesProbe() {
+ const edges = useEdges<Edge['data']>()
+ return (
+ <output aria-label="Canvas edges">
+ {edges
+ .map(
+ (edge) =>
+ `${edge.source}:${edge.sourceHandle ?? ''}->${edge.target}:${edge.targetHandle ?? ''}`,
+ )
+ .join(',')}
+ </output>
)
}
-const renderSourceHandle = (
- dataOverrides: Partial<CommonNodeType> = {},
- propsOverrides: Partial<React.ComponentProps<typeof NodeSourceHandle>> = {},
-) => {
- return render(
- <NodeSourceHandle
- id="source-node"
- data={createNodeData(dataOverrides)}
- handleId="source-handle"
- nodeSelectorClassName="custom-selector"
- handleClassName="custom-source-handle"
- {...propsOverrides}
- />,
+const getCanvasNodeIds = () =>
+ screen
+ .getByLabelText(CANVAS_NODES_STATUS_NAME, { selector: 'output' })
+ .textContent!.split(',')
+ .filter(Boolean)
+ .map((nodeId) => nodeId.replace(/\*$/, ''))
+
+function renderHandle({
+ side,
+ type = BlockEnum.Code,
+ readOnly = false,
+ autoOpen = false,
+ chatflow = false,
+ connected = false,
+}: {
+ side: 'source' | 'target'
+ type?: BlockEnum
+ readOnly?: boolean
+ autoOpen?: boolean
+ chatflow?: boolean
+ connected?: boolean
+}) {
+ const id = side === 'source' ? 'source-node' : 'target-node'
+ const title = side === 'source' ? 'Source node' : 'Target node'
+ const nodes = [
+ createNode({
+ id,
+ width: 240,
+ height: 80,
+ position: { x: side === 'source' ? 100 : 500, y: 100 },
+ data: {
+ type,
+ title,
+ ...(connected && side === 'target' ? { _connectedTargetHandleIds: ['target-handle'] } : {}),
+ },
+ }),
+ ]
+ const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '1.0.0' })
+ seedModelProviderQueries(queryClient)
+ seedAppDslVersion(queryClient, '1.0.0')
+
+ return renderWorkflowFlowComponent(
+ <>
+ <CanvasNodesCatalogProbe />
+ <CanvasEdgesProbe />
+ </>,
{
+ nodes,
+ edges: [],
+ queryClient,
+ resource: { kind: 'app', appId: 'app-1', mode: chatflow ? 'advanced-chat' : 'workflow' },
injectWorkflowStoreSliceFn: createWorkflowSlice as InjectWorkflowStoreSliceFn,
- resource: {
- kind: 'app',
- appId: 'app-1',
- mode: mockHooksState.isChatflow ? 'advanced-chat' : 'workflow',
+ initialStoreState: {
+ canvasReadOnly: readOnly,
+ shouldAutoOpenStartNodeSelector: autoOpen,
+ hasSelectedStartNode: true,
+ },
+ hooksStoreProps: { doSyncWorkflowDraft: async () => null },
+ reactFlowProps: {
+ fitView: false,
+ nodeTypes: {
+ [CUSTOM_NODE]: side === 'source' ? SourceHandleNode : TargetHandleNode,
+ },
},
},
)
}
-describe('node-handle', () => {
+describe('node handle insertion', () => {
beforeEach(() => {
vi.clearAllMocks()
-
- mockHooksState.availablePrevBlocks = [BlockEnum.Code]
- mockHooksState.availableNextBlocks = [BlockEnum.Code]
- mockHooksState.isChatflow = false
- mockHooksState.isReadOnly = false
-
- autoOpen = false
})
- // Target-side tests cover selector visibility, connection locking, and status rendering.
- describe('NodeTargetHandle', () => {
- it('should show the start tab when adding a node before the target node', async () => {
- const user = userEvent.setup()
+ it('inserts and routes a node after the source handle through the real selector', async () => {
+ const user = userEvent.setup()
+ renderHandle({ side: 'source' })
+ const source = await screen.findByRole('group', { name: 'Source node' })
+
+ await user.click(within(source).getByRole('button', { name: 'workflow.common.addBlock' }))
+ expect(screen.getByRole('tab', { name: 'workflow.tabs.start' })).toBeInTheDocument()
+ await user.click(await screen.findByRole('button', { name: 'workflow.blocks.code' }))
+
+ await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
+ const nodeIds = getCanvasNodeIds()
+ expect(nodeIds).toHaveLength(2)
+ const insertedNodeId = nodeIds.find((nodeId) => nodeId !== 'source-node')!
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent(
+ `source-node:source-handle->${insertedNodeId}:target`,
+ )
+ })
- renderTargetHandle()
+ it('inserts and routes a node before the target handle through the real selector', async () => {
+ const user = userEvent.setup()
+ renderHandle({ side: 'target' })
+ const target = await screen.findByRole('group', { name: 'Target node' })
+
+ await user.click(within(target).getByRole('button', { name: 'workflow.common.addBlock' }))
+ expect(screen.getByRole('tab', { name: 'workflow.tabs.start' })).toBeInTheDocument()
+ await user.click(await screen.findByRole('button', { name: 'workflow.blocks.code' }))
+
+ await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
+ const nodeIds = getCanvasNodeIds()
+ expect(nodeIds).toHaveLength(2)
+ const insertedNodeId = nodeIds.find((nodeId) => nodeId !== 'target-node')!
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent(
+ `${insertedNodeId}:source->target-node:target-handle`,
+ )
+ })
- await user.click(screen.getByTestId('handle-target-handle'))
+ it('does not offer insertion from a connected target handle', async () => {
+ renderHandle({ side: 'target', connected: true })
+ const target = await screen.findByRole('group', { name: 'Target node' })
- expect(screen.getByRole('tab', { name: 'workflow.tabs.start' })).toBeInTheDocument()
- })
+ expect(
+ within(target).queryByRole('button', { name: 'workflow.common.addBlock' }),
+ ).not.toBeInTheDocument()
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+ expect(getCanvasNodeIds()).toEqual(['target-node'])
+ })
- it('opens and closes the target selector from its handle', async () => {
+ it.each([
+ BlockEnum.Start,
+ BlockEnum.TriggerSchedule,
+ BlockEnum.TriggerWebhook,
+ BlockEnum.TriggerPlugin,
+ ])(
+ 'auto-opens an entry-node selector once for %s and resets the workflow flags',
+ async (type) => {
const user = userEvent.setup()
- renderTargetHandle()
- const handle = screen.getByTestId('handle-target-handle')
- await user.click(handle)
+ const { store } = renderHandle({ side: 'source', type, autoOpen: true })
+
expect(await screen.findByRole('dialog')).toBeInTheDocument()
+ expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(false)
+ expect(store.getState().hasSelectedStartNode).toBe(false)
+
await user.keyboard('{Escape}')
await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
- })
+ },
+ )
- it('should not render the target add trigger when the handle is already connected', async () => {
- const user = userEvent.setup()
- renderTargetHandle({
- _connectedTargetHandleIds: ['target-handle'],
- })
+ it('preserves the previous focus when the entry selector opens automatically', async () => {
+ const user = userEvent.setup()
+ render(<button type="button">Previous action</button>)
+ const previousAction = screen.getByRole('button', { name: 'Previous action' })
+ await user.click(previousAction)
- await user.click(screen.getByTestId('handle-target-handle'))
+ renderHandle({ side: 'source', type: BlockEnum.Start, autoOpen: true })
+ expect(await screen.findByRole('dialog')).toBeInTheDocument()
+ await user.keyboard('{Escape}')
- expect(queryAddNodeButton()).not.toBeInTheDocument()
- })
+ await waitFor(() => expect(previousAction).toHaveFocus())
})
- // Source-side tests cover selector opening paths, previous-node selection, and status styling.
- describe('NodeSourceHandle', () => {
- it('should show the start tab when adding a node after the source node', async () => {
- const user = userEvent.setup()
-
- renderSourceHandle()
-
- await user.click(screen.getByTestId('handle-source-handle'))
-
- expect(screen.getByRole('tab', { name: 'workflow.tabs.start' })).toBeInTheDocument()
+ it('skips auto-open for chatflow and resets only the request flag', () => {
+ const { store } = renderHandle({
+ side: 'source',
+ type: BlockEnum.Start,
+ autoOpen: true,
+ chatflow: true,
})
- it('opens and closes the source selector from its handle', async () => {
- const user = userEvent.setup()
- renderSourceHandle()
- const handle = screen.getByTestId('handle-source-handle')
- await user.click(handle)
- expect(await screen.findByRole('dialog')).toBeInTheDocument()
- await user.keyboard('{Escape}')
- await waitFor(() => expect(screen.queryByRole('dialog')).not.toBeInTheDocument())
- })
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+ expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(false)
+ expect(store.getState().hasSelectedStartNode).toBe(true)
})
- // Auto-open tests cover workflow start-trigger variants, chat-mode bypass, and store fallback paths.
- describe('NodeSourceHandle auto-open', () => {
- it('restores the previous focus when the start selector opens automatically', async () => {
- const user = userEvent.setup()
- render(<button type="button">Previous action</button>, {
- injectWorkflowStoreSliceFn: createWorkflowSlice as InjectWorkflowStoreSliceFn,
- resource: {
- kind: 'app',
- appId: 'app-1',
- mode: mockHooksState.isChatflow ? 'advanced-chat' : 'workflow',
- },
- })
- const previousAction = screen.getByRole('button', { name: 'Previous action' })
- await user.click(previousAction)
- autoOpen = true
-
- renderSourceHandle({ type: BlockEnum.Start })
- await screen.findByRole('dialog')
- await user.keyboard('{Escape}')
-
- await waitFor(() => expect(previousAction).toHaveFocus())
- })
-
- it.each([
- BlockEnum.Start,
- BlockEnum.TriggerSchedule,
- BlockEnum.TriggerWebhook,
- BlockEnum.TriggerPlugin,
- ])('should auto-open immediately for %s nodes', (type) => {
- autoOpen = true
-
- const { store } = renderSourceHandle({ type })
+ it('retains the auto-open request for a non-entry node', () => {
+ const { store } = renderHandle({ side: 'source', type: BlockEnum.Code, autoOpen: true })
- const addNodeButton = getAddNodeButton()
-
- expect(addNodeButton).toHaveAttribute('data-popup-open')
- expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(false)
- expect(store.getState().hasSelectedStartNode).toBe(false)
- })
-
- it('should skip source auto-open in chat mode and only reset the start selector flag', () => {
- mockHooksState.isChatflow = true
- autoOpen = true
-
- const { store } = renderSourceHandle({ type: BlockEnum.Start })
+ expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
+ expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(true)
+ expect(store.getState().hasSelectedStartNode).toBe(true)
+ })
- expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
- expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(false)
+ it('does not expose insertion controls or mutate the graph on a readonly canvas', async () => {
+ const { store } = renderHandle({
+ side: 'source',
+ type: BlockEnum.Start,
+ readOnly: true,
+ autoOpen: true,
})
+ const source = await screen.findByRole('group', { name: 'Source node' })
- it('should not auto-open when the node type is not a workflow entry node', () => {
- autoOpen = true
-
- const { store } = renderSourceHandle({ type: BlockEnum.Code })
-
- expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
- expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(true)
- })
- })
- it('does not offer insertion controls on a readonly canvas', async () => {
- const user = userEvent.setup()
- mockHooksState.isReadOnly = true
- autoOpen = true
- renderSourceHandle({ type: BlockEnum.Start })
- await user.click(screen.getByTestId('handle-source-handle'))
- expect(queryAddNodeButton()).not.toBeInTheDocument()
+ expect(
+ within(source).queryByRole('button', { name: 'workflow.common.addBlock' }),
+ ).not.toBeInTheDocument()
expect(screen.queryByRole('dialog')).not.toBeInTheDocument()
- expect(mockHandleNodeAdd).not.toHaveBeenCalled()
+ expect(getCanvasNodeIds()).toEqual(['source-node'])
+ expect(screen.getByLabelText('Canvas edges')).toBeEmptyDOMElement()
+ expect(store.getState().shouldAutoOpenStartNodeSelector).toBe(false)
})
})
diff --git a/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks.spec.ts b/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks.spec.ts
index 4339f2e661f..8bf3d8453a7 100644
--- a/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks.spec.ts
+++ b/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks.spec.ts
@@ -1,14 +1,21 @@
+import type { useWorkflowRun } from '../../../hooks/use-workflow-run'
+import type { Node } from '../../../types'
import { act } from '@testing-library/react'
import { createNode } from '../../../__tests__/fixtures'
-import { renderWorkflowFlowHook as renderHook } from '../../../__tests__/workflow-test-env'
-import { BlockEnum } from '../../../types'
+import { renderWorkflowCanvasHook } from '../../../__tests__/workflow-test-env'
+import { fullWorkflowAccessControl } from '../../../hooks-store'
+import { BlockEnum, WorkflowRunningStatus } from '../../../types'
import { useChat } from '../hooks'
-const mockHandleRun = vi.hoisted(() => vi.fn())
+type HandleRun = ReturnType<typeof useWorkflowRun>['handleRun']
+type RunCallbacks = NonNullable<Parameters<HandleRun>[1]>
+
+const mockHandleRun = vi.hoisted(() => vi.fn<HandleRun>())
const mockFetchInspectVars = vi.hoisted(() => vi.fn())
const mockInvalidAllLastRun = vi.hoisted(() => vi.fn())
const mockSubmitHumanInputForm = vi.hoisted(() => vi.fn())
const mockSseGet = vi.hoisted(() => vi.fn())
+
vi.mock('@/service/base', async (importOriginal) => ({
...(await importOriginal<typeof import('@/service/base')>()),
sseGet: (...args: unknown[]) => mockSseGet(...args),
@@ -24,75 +31,101 @@ vi.mock('@/service/workflow', async (importOriginal) => ({
submitHumanInputForm: (...args: unknown[]) => mockSubmitHumanInputForm(...args),
}))
-vi.mock('@/app/notifications', () => ({
- toast: {
- success: vi.fn(),
- error: vi.fn(),
- warning: vi.fn(),
- info: vi.fn(),
- },
-}))
-
-vi.mock('../../../hooks/use-workflow-run', () => ({
- useWorkflowRun: () => ({ handleRun: mockHandleRun }),
-}))
-
-vi.mock('../../../hooks/use-set-workflow-vars-with-value', () => ({
- useSetWorkflowVarsWithValue: () => ({ fetchInspectVars: mockFetchInspectVars }),
-}))
-
-const resetMocksAndWorkflowState = () => {
- vi.clearAllMocks()
-}
+const renderChat = (
+ options: {
+ canRun?: boolean
+ nodes?: Node[]
+ } = {},
+) =>
+ renderWorkflowCanvasHook(() => useChat({}), {
+ resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
+ nodes: options.nodes,
+ hooksStoreProps: {
+ handleRun: mockHandleRun,
+ fetchInspectVars: mockFetchInspectVars,
+ accessControl: { ...fullWorkflowAccessControl, canRun: options.canRun ?? true },
+ },
+ })
describe('useChat', () => {
beforeEach(() => {
- resetMocksAndWorkflowState()
+ vi.clearAllMocks()
})
- it('resumes the workflow event stream when switching to a sibling with pending human input', async () => {
- let sendCallbacks: {
- onWorkflowStarted: (payload: {
- workflow_run_id: string
- task_id: string
- conversation_id: string | null
- message_id: string
- }) => void
- onHumanInputRequired: (payload: { data: { node_id: string; form_token: string } }) => void
- onCompleted: (payload: boolean) => Promise<void>
- }
-
- mockHandleRun.mockImplementation((_params: unknown, callbacks: typeof sendCallbacks) => {
+ it('resumes a pending-human-input sibling and reflects the responding lifecycle', async () => {
+ let sendCallbacks: RunCallbacks | undefined
+ mockHandleRun.mockImplementation((_params, callbacks) => {
sendCallbacks = callbacks
})
-
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result, store } = renderChat()
act(() => {
- result.current.handleSend({ query: 'test' }, {})
+ result.current.handleSend({ query: 'Review this request' }, {})
})
+ expect(result.current.isResponding).toBe(true)
+ expect(result.current.chatList).toEqual([
+ expect.objectContaining({ content: 'Review this request', isAnswer: false }),
+ expect.objectContaining({ content: '', isAnswer: true }),
+ ])
+
act(() => {
- sendCallbacks.onWorkflowStarted({
+ sendCallbacks!.onWorkflowStarted?.({
workflow_run_id: 'workflow-run-1',
task_id: 'task-1',
- conversation_id: null,
+ event: 'workflow_started',
+ data: { id: 'workflow-run-1', workflow_id: 'workflow-1', created_at: 0 },
+ conversation_id: undefined,
message_id: 'message-1',
})
+ sendCallbacks!.onHumanInputRequired?.({
+ task_id: 'task-1',
+ workflow_run_id: 'workflow-run-1',
+ event: 'human_input_required',
+ data: {
+ form_id: 'form-1',
+ node_id: 'human-node',
+ node_title: 'Approval',
+ form_content: 'Approve this request',
+ inputs: [],
+ actions: [],
+ form_token: 'form-token',
+ resolved_default_values: {},
+ display_in_ui: true,
+ expiration_time: null,
+ },
+ })
})
-
act(() => {
- sendCallbacks.onHumanInputRequired({
- data: { node_id: 'human-node', form_token: 'form-token' },
+ store.setState({
+ workflowRunningData: {
+ task_id: 'task-1',
+ tracing: [],
+ result: {
+ status: WorkflowRunningStatus.Paused,
+ inputs_truncated: false,
+ process_data_truncated: false,
+ outputs_truncated: false,
+ },
+ },
})
})
-
await act(async () => {
- await sendCallbacks.onCompleted(false)
+ await sendCallbacks!.onCompleted?.(false)
})
+ expect(result.current.isResponding).toBe(false)
+ expect(result.current.chatList).toEqual([
+ expect.objectContaining({ content: 'Review this request', isAnswer: false }),
+ expect.objectContaining({
+ id: 'message-1',
+ workflow_run_id: 'workflow-run-1',
+ humanInputFormDataList: [
+ expect.objectContaining({ node_id: 'human-node', form_token: 'form-token' }),
+ ],
+ }),
+ ])
+
act(() => {
result.current.handleSwitchSibling('message-1', {})
})
@@ -102,13 +135,49 @@ describe('useChat', () => {
{},
expect.objectContaining({ onCompleted: expect.any(Function), onData: expect.any(Function) }),
)
+ const resumeCallbacks = mockSseGet.mock.lastCall![2] as RunCallbacks
+
+ act(() => {
+ resumeCallbacks.onWorkflowStarted?.({
+ workflow_run_id: 'workflow-run-1',
+ task_id: 'task-2',
+ event: 'workflow_started',
+ data: { id: 'workflow-run-1', workflow_id: 'workflow-1', created_at: 0 },
+ conversation_id: undefined,
+ message_id: 'message-1',
+ })
+ })
+ expect(result.current.isResponding).toBe(true)
+
+ act(() => {
+ store.setState({ workflowRunningData: undefined })
+ })
+ await act(async () => {
+ await resumeCallbacks.onCompleted?.(false)
+ })
+
+ expect(result.current.isResponding).toBe(false)
+ expect(mockFetchInspectVars).toHaveBeenCalledWith({})
+ expect(mockInvalidAllLastRun).toHaveBeenCalledOnce()
})
- it('submits human input forms through the workflow service', async () => {
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
+ it('does not create chat state or start a run without run permission', () => {
+ const { result } = renderChat({ canRun: false })
+
+ let accepted: boolean | undefined
+ act(() => {
+ accepted = result.current.handleSend({ query: 'Blocked request' }, {})
})
+ expect(accepted).toBe(false)
+ expect(result.current.isResponding).toBe(false)
+ expect(result.current.chatList).toEqual([])
+ expect(mockHandleRun).not.toHaveBeenCalled()
+ })
+
+ it('submits human input forms through the workflow service', async () => {
+ const { result } = renderChat()
+
await act(async () => {
await result.current.handleSubmitHumanInputForm('token-123', {
inputs: { field: 'value' },
@@ -127,11 +196,7 @@ describe('useChat', () => {
id: 'node-1',
data: { type: BlockEnum.HumanInput, title: 'Human Input' },
})
-
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- nodes: [node, createNode({ id: 'node-2' })],
- })
+ const { result } = renderChat({ nodes: [node, createNode({ id: 'node-2' })] })
expect(result.current.getHumanInputNodeData('node-1')).toMatchObject(node)
expect(result.current.getHumanInputNodeData('missing')).toBeUndefined()
diff --git a/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.spec.tsx b/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.spec.tsx
index 69e8c562b15..4864c71b315 100644
--- a/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.spec.tsx
+++ b/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.spec.tsx
@@ -1,107 +1,145 @@
+import type { NodeProps } from 'reactflow'
+import type { Edge, Node } from '../../types'
import { HotkeysProvider } from '@tanstack/react-hotkeys'
-import { act, fireEvent, screen } from '@testing-library/react'
+import { act, fireEvent, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { createPortal } from 'react-dom'
-import { ReactFlowProvider } from 'reactflow'
+import { ReactFlowProvider, useEdges, useNodes, useStoreApi, useViewport } from 'reactflow'
+import { seedModelProviderQueries } from '@/test/console/model-provider'
+import { createConsoleQueryWrapper, seedAppDslVersion } from '@/test/console/query-data'
+import {
+ CANVAS_NODES_STATUS_NAME,
+ CanvasNodesCatalogProbe,
+} from '../../__tests__/canvas-nodes-catalog-probe'
+import { createEdge, createNode } from '../../__tests__/fixtures'
import { renderWorkflowComponent } from '../../__tests__/workflow-test-env'
+import { CUSTOM_NODE } from '../../constants'
+import { BlockEnum, ControlMode } from '../../types'
import { WorkflowCanvas } from '../workflow-canvas'
-const actions = vi.hoisted(() => ({
- copy: vi.fn(),
- paste: vi.fn(),
- duplicate: vi.fn(),
- deleteNodes: vi.fn(),
- deleteEdge: vi.fn(),
- undo: vi.fn(),
- redo: vi.fn(),
- save: vi.fn(),
- organize: vi.fn(),
- hand: vi.fn(),
- pointer: vi.fn(),
- comment: vi.fn(),
- dim: vi.fn(),
- undim: vi.fn(),
- zoomTo: vi.fn(),
- fitView: vi.fn(),
- getZoom: vi.fn(() => 1),
- getNodes: vi.fn<() => { data: { _isBundled?: boolean } }[]>(() => []),
-}))
+const mockGetLayoutByELK = vi.hoisted(() => vi.fn())
-vi.mock('reactflow', async (importOriginal) => ({
- ...(await importOriginal<typeof import('reactflow')>()),
- useReactFlow: () => ({
- zoomTo: actions.zoomTo,
- fitView: actions.fitView,
- getZoom: actions.getZoom,
- getNodes: actions.getNodes,
- }),
-}))
-vi.mock('../../hooks/use-nodes-interactions', () => ({
- useNodesInteractions: () => ({
- handleNodesCopy: actions.copy,
- handleNodesPaste: actions.paste,
- handleNodesDuplicate: actions.duplicate,
- handleNodesDelete: actions.deleteNodes,
- handleHistoryBack: actions.undo,
- handleHistoryForward: actions.redo,
- dimOtherNodes: actions.dim,
- undimAllNodes: actions.undim,
- }),
-}))
-vi.mock('../../hooks/use-edges-interactions', () => ({
- useEdgesInteractions: () => ({ handleEdgeDelete: actions.deleteEdge }),
-}))
-vi.mock('../../hooks/use-nodes-sync-draft', () => ({
- useNodesSyncDraft: () => ({ handleSyncWorkflowDraft: actions.save }),
-}))
-vi.mock('../../hooks/use-workflow-organize', () => ({
- useWorkflowOrganize: () => ({ handleLayout: actions.organize }),
-}))
-vi.mock('../../hooks/use-workflow-panel-interactions', () => ({
- useWorkflowMoveMode: () => ({
- handleModeHand: actions.hand,
- handleModePointer: actions.pointer,
- handleModeComment: actions.comment,
- canUseCommentMode: true,
- }),
+vi.mock('../../utils/elk-layout', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('../../utils/elk-layout')>()),
+ getLayoutByELK: (...args: unknown[]) => mockGetLayoutByELK(...args),
}))
-function Canvas() {
+let flowStore: ReturnType<typeof useStoreApi>
+
+function WorkflowNode({ data }: NodeProps) {
+ return <span>{data.title as string}</span>
+}
+
+const nodeTypes = { [CUSTOM_NODE]: WorkflowNode }
+
+function CanvasEdgesProbe() {
+ const edges = useEdges()
+ return <output aria-label="Canvas edges">{edges.map((edge) => edge.id).join(',')}</output>
+}
+
+function CanvasStateProbe() {
+ const nodes = useNodes<{ _dimmed?: boolean }>()
+ const viewport = useViewport()
+ return (
+ <>
+ <output aria-label="Dimmed canvas nodes">
+ {nodes
+ .filter((node) => node.data._dimmed)
+ .map((node) => node.id)
+ .join(',')}
+ </output>
+ <output aria-label="Canvas node positions">
+ {nodes.map((node) => `${node.id}:${node.position.x}:${node.position.y}`).join(',')}
+ </output>
+ <output aria-label="Canvas viewport">{`${viewport.x}:${viewport.y}:${viewport.zoom}`}</output>
+ </>
+ )
+}
+
+function Canvas({ nodes, edges }: { nodes: Node[]; edges: Edge[] }) {
+ flowStore = useStoreApi()
return (
- <ReactFlowProvider>
- <WorkflowCanvas nodes={[]} edges={[]}>
+ <>
+ <WorkflowCanvas nodes={nodes} edges={edges} nodeTypes={nodeTypes} deleteKeyCode={null}>
<input aria-label="Node name" />
<textarea aria-label="Node prompt" />
<div contentEditable suppressContentEditableWarning role="textbox" aria-label="Note">
<span>Note content</span>
</div>
- <button onKeyDown={(event) => event.preventDefault()}>Handled by a local widget</button>
- {createPortal(<button>Popup action</button>, document.body)}
+ <button type="button" onKeyDown={(event) => event.preventDefault()}>
+ Handled by a local widget
+ </button>
+ {createPortal(<button type="button">Popup action</button>, document.body)}
</WorkflowCanvas>
- <button>Outside canvas</button>
- </ReactFlowProvider>
+ <CanvasNodesCatalogProbe />
+ <CanvasEdgesProbe />
+ <CanvasStateProbe />
+ <button type="button">Outside canvas</button>
+ </>
)
}
-function renderCanvas(platform: 'mac' | 'windows' = 'windows') {
- return renderWorkflowComponent(
+const selectedNode = (id = 'node-1') =>
+ createNode({
+ id,
+ width: 240,
+ height: 80,
+ selected: true,
+ ariaLabel: `Node ${id}`,
+ data: { type: BlockEnum.Code, title: `Node ${id}`, selected: true },
+ })
+
+function renderCanvas({
+ nodes = [selectedNode()],
+ edges = [],
+ readOnly = false,
+ platform = 'windows',
+}: {
+ nodes?: Node[]
+ edges?: Edge[]
+ readOnly?: boolean
+ platform?: 'mac' | 'windows'
+} = {}) {
+ const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '1.0.0' })
+ seedModelProviderQueries(queryClient)
+ seedAppDslVersion(queryClient, '1.0.0')
+ const sync = vi.fn(async () => null)
+ const rendered = renderWorkflowComponent(
<HotkeysProvider defaultOptions={{ hotkey: { platform } }}>
- <Canvas />
+ <ReactFlowProvider>
+ <Canvas nodes={nodes} edges={edges} />
+ </ReactFlowProvider>
</HotkeysProvider>,
+ {
+ queryClient,
+ initialStoreState: { canvasReadOnly: readOnly },
+ historyStore: { nodes, edges },
+ hooksStoreProps: { doSyncWorkflowDraft: sync },
+ },
)
+ return { ...rendered, sync }
}
function focusCanvas() {
- const canvas = screen.getByLabelText('app.types.workflow')
+ const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
act(() => canvas.focus())
return canvas
}
+const canvasNodeIds = () =>
+ screen
+ .getByLabelText(CANVAS_NODES_STATUS_NAME, { selector: 'output' })
+ .textContent!.split(',')
+ .filter(Boolean)
+
describe('Workflow canvas commands', () => {
- beforeEach(() => {
+ beforeEach(async () => {
vi.clearAllMocks()
- actions.getNodes.mockReturnValue([])
- actions.getZoom.mockReturnValue(1)
+ await navigator.clipboard.writeText('')
+ mockGetLayoutByELK.mockResolvedValue({
+ nodes: new Map(),
+ bounds: { minX: 0, minY: 0, maxX: 0, maxY: 0 },
+ })
})
afterEach(() => {
@@ -109,38 +147,40 @@ describe('Workflow canvas commands', () => {
})
it.each(['mac', 'windows'] as const)(
- 'runs graph actions only from its canvas on %s',
+ 'owns save and mode commands only while its canvas is focused on %s',
async (platform) => {
const user = userEvent.setup()
- renderCanvas(platform)
+ const { store, sync } = renderCanvas({ platform })
const mod = platform === 'mac' ? 'Meta' : 'Control'
focusCanvas()
- await user.keyboard(`{${mod}>}cvszy{/${mod}}{Delete}`)
- expect(actions.copy).toHaveBeenCalledTimes(1)
- expect(actions.paste).toHaveBeenCalledTimes(1)
- expect(actions.save).toHaveBeenCalledTimes(1)
- expect(actions.undo).toHaveBeenCalledTimes(1)
- expect(actions.redo).toHaveBeenCalledTimes(1)
- expect(actions.deleteNodes).toHaveBeenCalledTimes(1)
- expect(actions.deleteEdge).toHaveBeenCalledTimes(1)
+
+ await user.keyboard('c')
+ expect(store.getState().controlMode).toBe(ControlMode.Comment)
+ await user.keyboard('v')
+ expect(store.getState().controlMode).toBe(ControlMode.Pointer)
+ await user.keyboard(`h{${mod}>}s{/${mod}}`)
+ expect(store.getState().controlMode).toBe(ControlMode.Hand)
+ act(() => store.getState().flushPendingSync())
+ expect(sync).toHaveBeenCalledOnce()
await user.click(screen.getByRole('button', { name: 'Popup action' }))
- await user.keyboard(`{${mod}>}cvszy{/${mod}}{Delete}`)
+ await user.keyboard(`v{${mod}>}s{/${mod}}`)
await user.click(screen.getByRole('button', { name: 'Outside canvas' }))
- await user.keyboard(`{${mod}>}cvszy{/${mod}}{Delete}`)
- expect(actions.copy).toHaveBeenCalledTimes(1)
- expect(actions.save).toHaveBeenCalledTimes(1)
- expect(actions.undo).toHaveBeenCalledTimes(1)
- expect(actions.deleteNodes).toHaveBeenCalledTimes(1)
+ await user.keyboard(`c{${mod}>}s{/${mod}}`)
+ act(() => store.getState().flushPendingSync())
+
+ expect(store.getState().controlMode).toBe(ControlMode.Hand)
+ expect(sync).toHaveBeenCalledOnce()
},
)
it.each(['Node name', 'Node prompt', 'Note', 'Note content'])(
- 'leaves editor keys and native defaults to %s',
+ 'leaves editor shortcuts and native defaults to %s',
(name) => {
- renderCanvas()
+ const { store, sync } = renderCanvas()
const editor =
name === 'Note content' ? screen.getByText(name) : screen.getByRole('textbox', { name })
+
for (const key of ['s', 'z', 'c', 'v']) {
const event = new KeyboardEvent('keydown', {
key,
@@ -152,72 +192,70 @@ describe('Workflow canvas commands', () => {
fireEvent.keyUp(editor, { key, ctrlKey: true })
expect(event.defaultPrevented).toBe(false)
}
- const event = new KeyboardEvent('keydown', { key: 'Delete', bubbles: true, cancelable: true })
- fireEvent(editor, event)
- expect(event.defaultPrevented).toBe(false)
- expect(actions.save).not.toHaveBeenCalled()
- expect(actions.undo).not.toHaveBeenCalled()
- expect(actions.copy).not.toHaveBeenCalled()
- expect(actions.paste).not.toHaveBeenCalled()
- expect(actions.deleteNodes).not.toHaveBeenCalled()
+ const deletion = new KeyboardEvent('keydown', {
+ key: 'Delete',
+ bubbles: true,
+ cancelable: true,
+ })
+ fireEvent(editor, deletion)
+ expect(deletion.defaultPrevented).toBe(false)
+
+ act(() => store.getState().flushPendingSync())
+
+ expect(store.getState().controlMode).toBe(ControlMode.Pointer)
+ expect(canvasNodeIds()).toEqual(['node-1*'])
+ expect(store.getState().clipboardElements).toEqual([])
+ expect(sync).not.toHaveBeenCalled()
},
)
- it('ignores a claimed event, composition, and repeats until the key is released', async () => {
+ it('ignores locally claimed and composing events', async () => {
const user = userEvent.setup()
- renderCanvas()
+ const { store } = renderCanvas()
+
await user.click(screen.getByRole('button', { name: 'Handled by a local widget' }))
- await user.keyboard('{Control>}s{/Control}')
- expect(actions.save).not.toHaveBeenCalled()
+ await user.keyboard('h')
+ expect(store.getState().controlMode).toBe(ControlMode.Pointer)
const canvas = focusCanvas()
- fireEvent.keyDown(canvas, { key: 's', ctrlKey: true, isComposing: true })
- fireEvent.keyUp(canvas, { key: 's', ctrlKey: true })
- expect(actions.save).not.toHaveBeenCalled()
- const composingDelete = new KeyboardEvent('keydown', {
- key: 'Delete',
+ const composingMode = new KeyboardEvent('keydown', {
+ key: 'h',
isComposing: true,
bubbles: true,
cancelable: true,
})
- fireEvent(canvas, composingDelete)
- fireEvent.keyUp(canvas, { key: 'Delete' })
- expect(composingDelete.defaultPrevented).toBe(false)
- expect(actions.deleteNodes).not.toHaveBeenCalled()
- await user.keyboard('{Control>}{s>3/}{/Control}')
- expect(actions.save).toHaveBeenCalledTimes(1)
- await user.keyboard('{Control>}s{/Control}')
- expect(actions.save).toHaveBeenCalledTimes(2)
+ fireEvent(canvas, composingMode)
+
+ expect(composingMode.defaultPrevented).toBe(false)
+ expect(store.getState().controlMode).toBe(ControlMode.Pointer)
})
- it('consumes every owned repeat while performing discrete actions only once', () => {
+ it('consumes owned repeats while duplicating the selected node only once', async () => {
renderCanvas()
const canvas = focusCanvas()
- for (const key of ['s', 'd', 'o', 'c']) {
- for (const repeat of [false, true, true]) {
- const event = new KeyboardEvent('keydown', {
- key,
- ctrlKey: true,
- repeat,
- bubbles: true,
- cancelable: true,
- })
- fireEvent(canvas, event)
- expect(event.defaultPrevented).toBe(true)
- }
- fireEvent.keyUp(canvas, { key, ctrlKey: true })
+
+ for (const repeat of [false, true, true]) {
+ const event = new KeyboardEvent('keydown', {
+ key: 'd',
+ ctrlKey: true,
+ repeat,
+ bubbles: true,
+ cancelable: true,
+ })
+ fireEvent(canvas, event)
+ expect(event.defaultPrevented).toBe(true)
}
- expect(actions.save).toHaveBeenCalledTimes(1)
- expect(actions.duplicate).toHaveBeenCalledTimes(1)
- expect(actions.organize).toHaveBeenCalledTimes(1)
- expect(actions.copy).toHaveBeenCalledTimes(1)
+ fireEvent.keyUp(canvas, { key: 'd', ctrlKey: true })
+
+ await waitFor(() => expect(canvasNodeIds()).toHaveLength(2))
+ expect(new Set(canvasNodeIds()).size).toBe(2)
})
- it('does not consume unavailable editing commands while still allowing viewport zoom', async () => {
+ it('leaves editing commands unclaimed but still changes the real viewport on readonly canvas', async () => {
const user = userEvent.setup()
- const { store } = renderCanvas()
- act(() => store.setState({ canvasReadOnly: true }))
+ const { store, sync } = renderCanvas({ readOnly: true })
const canvas = focusCanvas()
+
for (const key of ['s', 'd', 'o', 'z']) {
const event = new KeyboardEvent('keydown', {
key,
@@ -236,74 +274,215 @@ describe('Workflow canvas commands', () => {
})
fireEvent(canvas, deletion)
expect(deletion.defaultPrevented).toBe(false)
- expect(actions.save).not.toHaveBeenCalled()
- expect(actions.deleteNodes).not.toHaveBeenCalled()
- expect(actions.duplicate).not.toHaveBeenCalled()
- expect(actions.organize).not.toHaveBeenCalled()
- expect(actions.undo).not.toHaveBeenCalled()
- await user.keyboard('{Control>}{=>3/}{/Control}')
- expect(actions.zoomTo).toHaveBeenCalledTimes(3)
+
+ act(() => store.getState().flushPendingSync())
+ expect(canvasNodeIds()).toEqual(['node-1*'])
+ expect(store.getState().clipboardElements).toEqual([])
+ expect(store.temporal.getState().pastStates).toEqual([])
+ expect(store.getState().controlMode).toBe(ControlMode.Pointer)
+ expect(sync).not.toHaveBeenCalled()
+
+ await user.keyboard('{Control>}={/Control}')
+ await waitFor(() =>
+ expect(screen.getByLabelText('Canvas viewport')).toHaveTextContent('0:0:1.1'),
+ )
+ expect(sync).not.toHaveBeenCalled()
})
- it('keeps graph history disabled while debug preview is open', async () => {
+ it('dims unrelated real nodes only while Shift is held with canvas focus', async () => {
+ const user = userEvent.setup()
+ const unrelatedNode = createNode({
+ id: 'node-2',
+ width: 240,
+ height: 80,
+ position: { x: 320, y: 0 },
+ data: { type: BlockEnum.Code, title: 'Node node-2', selected: false },
+ })
+ renderCanvas({ nodes: [selectedNode(), unrelatedNode] })
+ focusCanvas()
+
+ await user.keyboard('{Shift>}')
+ await waitFor(() =>
+ expect(screen.getByLabelText('Dimmed canvas nodes')).toHaveTextContent('node-2'),
+ )
+
+ act(() => screen.getByRole('textbox', { name: 'Node prompt' }).focus())
+ await waitFor(() => expect(screen.getByLabelText('Dimmed canvas nodes')).toBeEmptyDOMElement())
+ await user.keyboard('{/Shift}{Shift>}{/Shift}')
+ expect(screen.getByLabelText('Dimmed canvas nodes')).toBeEmptyDOMElement()
+ })
+
+ it('updates the real editable viewport and reaches the draft sync boundary', async () => {
+ const user = userEvent.setup()
+ const { store, sync } = renderCanvas()
+ focusCanvas()
+
+ await user.keyboard('{Control>}={/Control}')
+ await waitFor(() =>
+ expect(screen.getByLabelText('Canvas viewport')).toHaveTextContent('0:0:1.1'),
+ )
+ act(() => store.getState().flushPendingSync())
+
+ expect(sync).toHaveBeenCalledOnce()
+ })
+
+ it('organizes real canvas nodes through the owner and syncs the updated positions', async () => {
+ const user = userEvent.setup()
+ const secondNode = createNode({
+ id: 'node-2',
+ width: 240,
+ height: 80,
+ position: { x: 320, y: 0 },
+ data: { type: BlockEnum.Code, title: 'Node node-2', selected: false },
+ })
+ mockGetLayoutByELK.mockResolvedValueOnce({
+ nodes: new Map([
+ ['node-1', { x: 100, y: 120, width: 240, height: 80, layer: 0 }],
+ ['node-2', { x: 500, y: 120, width: 240, height: 80, layer: 1 }],
+ ]),
+ bounds: { minX: 100, minY: 120, maxX: 740, maxY: 200 },
+ })
+ const { store, sync } = renderCanvas({ nodes: [selectedNode(), secondNode] })
+ focusCanvas()
+
+ await user.keyboard('{Control>}o{/Control}')
+
+ await waitFor(() =>
+ expect(screen.getByLabelText('Canvas node positions')).toHaveTextContent(
+ 'node-1:100:120,node-2:500:120',
+ ),
+ )
+ await waitFor(() => {
+ act(() => store.getState().flushPendingSync())
+ expect(sync).toHaveBeenCalledOnce()
+ })
+ })
+
+ it('copies a selected real node to the clipboard and pastes a real clone', async () => {
const user = userEvent.setup()
const { store } = renderCanvas()
focusCanvas()
- act(() => store.setState({ showDebugAndPreviewPanel: true }))
- await user.keyboard('{Control>}zy{/Control}')
- expect(actions.undo).not.toHaveBeenCalled()
- expect(actions.redo).not.toHaveBeenCalled()
- act(() => store.setState({ showDebugAndPreviewPanel: false }))
- await user.keyboard('{Control>}zy{/Control}')
- expect(actions.undo).toHaveBeenCalledTimes(1)
- expect(actions.redo).toHaveBeenCalledTimes(1)
+
+ await user.keyboard('{Control>}c{/Control}')
+
+ expect(store.getState().clipboardElements.map((node) => node.id)).toEqual(['node-1'])
+ await waitFor(async () => {
+ const clipboard = JSON.parse(await navigator.clipboard.readText()) as {
+ nodes: Array<{ id: string }>
+ }
+ expect(clipboard.nodes.map((node) => node.id)).toEqual(['node-1'])
+ })
+
+ await user.keyboard('{Control>}v{/Control}')
+ await waitFor(() => expect(canvasNodeIds()).toHaveLength(2))
+ const pastedNodeIds = canvasNodeIds().map((nodeId) => nodeId.replace(/\*$/, ''))
+ expect(pastedNodeIds).toContain('node-1')
+ expect(new Set(pastedNodeIds).size).toBe(2)
})
- it('keeps layout and zoom bound to the canvas and saves the viewport', async () => {
+ it('uses real graph history and disables undo while debug preview is open', async () => {
const user = userEvent.setup()
- renderCanvas()
+ const retainedNode = createNode({
+ id: 'node-2',
+ width: 240,
+ height: 80,
+ position: { x: 320, y: 0 },
+ data: { type: BlockEnum.Code, title: 'Node node-2', selected: false },
+ })
+ const { store } = renderCanvas({ nodes: [selectedNode(), retainedNode] })
+ const canvas = focusCanvas()
+
+ await user.keyboard('{Delete}')
+ expect(canvasNodeIds()).toEqual(['node-2'])
+ await waitFor(() => expect(store.temporal.getState().pastStates).toHaveLength(1))
+
+ act(() => store.setState({ showDebugAndPreviewPanel: true }))
+ const blockedUndo = new KeyboardEvent('keydown', {
+ key: 'z',
+ ctrlKey: true,
+ bubbles: true,
+ cancelable: true,
+ })
+ fireEvent(canvas, blockedUndo)
+ fireEvent.keyUp(canvas, { key: 'z', ctrlKey: true })
+ expect(blockedUndo.defaultPrevented).toBe(false)
+ expect(canvasNodeIds()).toEqual(['node-2'])
+
+ act(() => store.setState({ showDebugAndPreviewPanel: false }))
+ await user.keyboard('{Control>}z{/Control}')
+ expect(canvasNodeIds()).toEqual(['node-1*', 'node-2'])
focusCanvas()
- await user.keyboard('{Control>}o1-={/Control}{Shift>}5{/Shift}')
- expect(actions.organize).toHaveBeenCalledTimes(1)
- expect(actions.fitView).toHaveBeenCalledTimes(1)
- expect(actions.zoomTo).toHaveBeenNthCalledWith(1, 0.9)
- expect(actions.zoomTo).toHaveBeenNthCalledWith(2, 1.1)
- expect(actions.zoomTo).toHaveBeenNthCalledWith(3, 0.5)
- expect(actions.save).toHaveBeenCalledTimes(4)
+ const redo = new KeyboardEvent('keydown', {
+ key: 'y',
+ ctrlKey: true,
+ bubbles: true,
+ cancelable: true,
+ })
+ fireEvent(canvas, redo)
+ fireEvent.keyUp(canvas, { key: 'y', ctrlKey: true })
+ expect(redo.defaultPrevented).toBe(true)
+ await waitFor(() => expect(canvasNodeIds()).toEqual(['node-2']))
})
- it('dims only while Shift is held with canvas focus and clears on focus loss', async () => {
+ it('deletes a selected edge without deleting unselected nodes', async () => {
const user = userEvent.setup()
- renderCanvas()
+ const nodes = [
+ createNode({
+ id: 'source',
+ width: 240,
+ height: 80,
+ data: { type: BlockEnum.Code, title: 'Source', selected: false },
+ }),
+ createNode({
+ id: 'target',
+ width: 240,
+ height: 80,
+ position: { x: 300, y: 0 },
+ data: { type: BlockEnum.Code, title: 'Target', selected: false },
+ }),
+ ]
+ renderCanvas({
+ nodes,
+ edges: [
+ createEdge({ id: 'selected-edge', source: 'source', target: 'target', selected: true }),
+ ],
+ })
focusCanvas()
- await user.keyboard('{Shift>}')
- expect(actions.dim).toHaveBeenCalledTimes(1)
- act(() => screen.getByRole('textbox', { name: 'Node prompt' }).focus())
- expect(actions.undim).toHaveBeenCalledTimes(1)
- await user.keyboard('{/Shift}{Shift>}{/Shift}')
- expect(actions.dim).toHaveBeenCalledTimes(1)
+
+ await user.keyboard('{Delete}')
+
+ expect(canvasNodeIds()).toEqual(['source', 'target'])
+ expect(screen.getByLabelText('Canvas edges')).toBeEmptyDOMElement()
})
- it('preserves text selection copying unless bundled nodes are selected', async () => {
+ it('preserves text selection copying unless the real canvas selection is bundled', async () => {
const user = userEvent.setup()
- renderCanvas()
+ const { store } = renderCanvas()
const canvas = focusCanvas()
const selection = document.getSelection()!
const range = document.createRange()
range.selectNodeContents(screen.getByText('Note content'))
selection.addRange(range)
+
await user.keyboard('{Control>}c{/Control}')
- expect(actions.copy).not.toHaveBeenCalled()
- actions.getNodes.mockReturnValue([{ data: { _isBundled: true } }])
- const event = new KeyboardEvent('keydown', {
+ expect(store.getState().clipboardElements).toEqual([])
+
+ act(() => {
+ const nodes = flowStore.getState().getNodes()
+ flowStore
+ .getState()
+ .setNodes(nodes.map((node) => ({ ...node, data: { ...node.data, _isBundled: true } })))
+ })
+ const bundledCopy = new KeyboardEvent('keydown', {
key: 'c',
ctrlKey: true,
bubbles: true,
cancelable: true,
})
- fireEvent(canvas, event)
+ fireEvent(canvas, bundledCopy)
fireEvent.keyUp(canvas, { key: 'c', ctrlKey: true })
- expect(event.defaultPrevented).toBe(true)
- expect(actions.copy).toHaveBeenCalledTimes(1)
+
+ expect(bundledCopy.defaultPrevented).toBe(true)
+ expect(store.getState().clipboardElements.map((node) => node.id)).toEqual(['node-1'])
})
})