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): replace workflow owner doubles with real canvas behavior (#44590)

Stephen Zhou1ee9fb4e83a1
diff --git a/web/app/components/workflow/__tests__/workflow-browser-test-env.tsx b/web/app/components/workflow/__tests__/workflow-browser-test-env.tsx
index dad3f864e3b..73244e36a56 100644
--- a/web/app/components/workflow/__tests__/workflow-browser-test-env.tsx
+++ b/web/app/components/workflow/__tests__/workflow-browser-test-env.tsx
@@ -1,28 +1,24 @@
import type { ReactElement } from 'react'
+import type { WorkflowProviderOptions } from './workflow-test-providers'
import { ReactFlowProvider } from 'reactflow'
-import { afterEach, beforeEach, expect, vi } from 'vite-plus/test'
import { render } from 'vitest-browser-react'
import { consoleQuery } from '@/service/console'
import { seedModelProviderQueries } from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import { seedToolProviders } from '@/test/console/tool-providers'
-import { createAppDetailFixture } from '@/test/fixtures/app'
-import { WorkflowContext } from '../context'
-import { EditorResourceScope } from '../editor-resource/provider'
-import { HooksStoreContext } from '../hooks-store/provider'
-import { createHooksStore, fullWorkflowAccessControl } from '../hooks-store/store'
-import { createWorkflowStore } from '../store/workflow'
+import { fullWorkflowAccessControl } from '../hooks-store/store'
+import { createStoresFromOptions, createWorkflowWrapper } from './workflow-test-providers'
-const unexpectedFetch = vi.fn<typeof fetch>(() => new Promise(() => {}))
-beforeEach(() => vi.stubGlobal('fetch', unexpectedFetch))
-afterEach(() => {
- vi.unstubAllGlobals()
- expect(unexpectedFetch).not.toHaveBeenCalled()
-})
-
-// Browser fixtures keep their own canvas geometry and tab order, sharing real editor providers.
-export async function renderWorkflowBrowserComponent(ui: ReactElement) {
- const { queryClient, wrapper: Wrapper } = createConsoleQueryWrapper({ appDslVersion: '0.6.0' })
+// Browser fixtures own their geometry, interactions and network guards explicitly.
+export async function renderWorkflowBrowserComponent(
+ ui: ReactElement,
+ options: WorkflowProviderOptions = {},
+) {
+ const { queryClient: defaultClient } = createConsoleQueryWrapper({
+ appDslVersion: '0.6.0',
+ systemFeatures: { enable_collaboration_mode: false },
+ })
+ const queryClient = options.queryClient ?? defaultClient
seedModelProviderQueries(queryClient)
queryClient.setQueryData(consoleQuery.workspaces.current.triggers.get.queryKey({ input: {} }), [])
queryClient.setQueryData(consoleQuery.rag.pipelines.recommendedPlugins.get.queryKey(), {
@@ -36,31 +32,19 @@ export async function renderWorkflowBrowserComponent(ui: ReactElement) {
workflowTools: [],
mcpTools: [],
})
- const input = { input: { params: { app_id: 'app-1' } } }
- queryClient.setQueryData(
- consoleQuery.apps.byAppId.get.queryKey(input),
- createAppDetailFixture({ id: 'app-1', mode: 'workflow' }),
- )
- for (const endpoint of [
- consoleQuery.apps.byAppId.workflows.draft.systemVariables.get,
- consoleQuery.apps.byAppId.workflows.draft.conversationVariables.get,
- ])
- queryClient.setQueryData(endpoint.queryKey(input), { items: [] })
- const store = createWorkflowStore({})
- const hooksStore = createHooksStore({
- accessControl: fullWorkflowAccessControl,
- doSyncWorkflowDraft: async () => undefined,
+ const stores = createStoresFromOptions({
+ ...options,
+ hooksStoreProps: {
+ accessControl: fullWorkflowAccessControl,
+ doSyncWorkflowDraft: async () => undefined,
+ ...options.hooksStoreProps,
+ },
})
+ const Wrapper = createWorkflowWrapper(stores, options.historyStore, queryClient, options.resource)
const screen = await render(
<Wrapper>
- <EditorResourceScope resource={{ kind: 'app', appId: 'app-1', mode: 'workflow' }}>
- <WorkflowContext value={store}>
- <HooksStoreContext value={hooksStore}>
- <ReactFlowProvider>{ui}</ReactFlowProvider>
- </HooksStoreContext>
- </WorkflowContext>
- </EditorResourceScope>
+ <ReactFlowProvider>{ui}</ReactFlowProvider>
</Wrapper>,
)
- return { ...screen, store }
+ return { ...screen, ...stores }
}
diff --git a/web/app/components/workflow/__tests__/workflow-test-env.tsx b/web/app/components/workflow/__tests__/workflow-test-env.tsx
index a7d380db872..e49d060d87e 100644
--- a/web/app/components/workflow/__tests__/workflow-test-env.tsx
+++ b/web/app/components/workflow/__tests__/workflow-test-env.tsx
@@ -1,34 +1,9 @@
/**
* Workflow test environment — composable providers + render helpers.
*
- * ## Quick start (hook)
- *
- * ```ts
- * import { resetReactFlowMockState, rfState } from '../../__tests__/reactflow-mock-state'
- * import { renderWorkflowHook } from '../../__tests__/workflow-test-env'
- *
- * // Mock ReactFlow (one line, only needed when the hook imports reactflow)
- * vi.mock('reactflow', async () =>
- * (await import('../../__tests__/reactflow-mock-state')).createReactFlowModuleMock(),
- * )
- *
- * it('example', () => {
- * resetReactFlowMockState()
- * rfState.nodes = [{ id: 'n1', position: { x: 0, y: 0 }, data: {} }]
- *
- * const { result, store } = renderWorkflowHook(
- * () => useMyHook(),
- * {
- * initialStoreState: { workflowRunningData: {...} },
- * hooksStoreProps: { doSyncWorkflowDraft: vi.fn() },
- * },
- * )
- *
- * result.current.doSomething()
- * expect(store.getState().someValue).toBe(expected)
- * expect(rfState.setNodes).toHaveBeenCalled()
- * })
- * ```
+ * Use renderWorkflowCanvasHook for graph-reading hooks and seed nodes/edges in options.
+ * Use renderWorkflowFlowComponent when the contract needs a mounted ReactFlow canvas.
+ * Assert resulting graph, workflow store or DOM state; keep owner hooks real.
*
* ## Quick start (component)
*
@@ -66,31 +41,21 @@ import type {
RenderOptions,
RenderResult,
} from '@testing-library/react'
-import type { EditorResource } from '../editor-resource/resource'
-import type { Shape as HooksStoreShape } from '../hooks-store/store'
-import type { InjectWorkflowStoreSliceFn, Shape } from '../store/workflow'
-import type { WorkflowHistoryState } from '../store/workflow/history-slice'
import type { Edge, Node, WorkflowRunningData } from '../types'
-import { QueryClient } from '@tanstack/react-query'
+import type { StoreInstances, WorkflowProviderOptions } from './workflow-test-providers'
import * as React from 'react'
import ReactFlow, { ReactFlowProvider, useStoreApi } from 'reactflow'
-import { consoleQuery } from '@/service/console'
-import { seedAccountProfileQuery } from '@/test/console/account-profile'
-import { createQueryClientWrapper } from '@/test/console/query-client'
-import {
- seedAppDetail,
- seedAppDslVersion,
- seedKnowledgeFsFeatures,
- seedSystemFeatures,
-} from '@/test/console/query-data'
import { render, renderHook } from '@/test/console/render'
-import { createAppDetailFixture } from '@/test/fixtures/app'
-import { WorkflowContext } from '../context'
-import { EditorResourceScope } from '../editor-resource/provider'
-import { HooksStoreContext } from '../hooks-store/provider'
-import { createHooksStore } from '../hooks-store/store'
-import { createWorkflowStore } from '../store/workflow'
import { WorkflowRunningStatus } from '../types'
+import {
+ createTestWorkflowStore as createProviderWorkflowStore,
+ createStoresFromOptions,
+ createWorkflowWrapper,
+} from './workflow-test-providers'
+
+export function createTestWorkflowStore(...args: Parameters<typeof createProviderWorkflowStore>) {
+ return createProviderWorkflowStore(...args)
+}
// Re-exports are in a separate non-JSX file to avoid react-refresh warnings.
// Import directly from the individual modules:
@@ -113,128 +78,6 @@ export function baseRunningData(overrides: Record<string, unknown> = {}) {
} as WorkflowRunningData
}
-// ---------------------------------------------------------------------------
-// Store creation helpers
-// ---------------------------------------------------------------------------
-
-type WorkflowStore = ReturnType<typeof createWorkflowStore>
-type HooksStore = ReturnType<typeof createHooksStore>
-
-export function createTestWorkflowStore(
- initialState?: Partial<Shape>,
- injectWorkflowStoreSliceFn?: InjectWorkflowStoreSliceFn,
-): WorkflowStore {
- const store = createWorkflowStore({ injectWorkflowStoreSliceFn })
- if (initialState) store.setState(initialState)
- return store
-}
-
-function createTestHooksStore(props?: Partial<HooksStoreShape>): HooksStore {
- const store = createHooksStore(props ?? {})
- if (props) store.setState(props)
- return store
-}
-
-// ---------------------------------------------------------------------------
-// Shared provider options & wrapper factory
-// ---------------------------------------------------------------------------
-
-type HistoryStoreConfig = {
- nodes?: Node[]
- edges?: Edge[]
-}
-
-type WorkflowProviderOptions = {
- injectWorkflowStoreSliceFn?: InjectWorkflowStoreSliceFn
- resource?: EditorResource
- initialStoreState?: Partial<Shape>
- hooksStoreProps?: Partial<HooksStoreShape>
- historyStore?: HistoryStoreConfig
- queryClient?: QueryClient
-}
-
-type StoreInstances = {
- store: WorkflowStore
- hooksStore?: HooksStore
-}
-
-function createStoresFromOptions(options: WorkflowProviderOptions): StoreInstances {
- const store = createTestWorkflowStore(
- options.initialStoreState,
- options.injectWorkflowStoreSliceFn,
- )
- const hooksStore = createTestHooksStore(options.hooksStoreProps)
- return { store, hooksStore }
-}
-
-function createWorkflowWrapper(
- stores: StoreInstances,
- historyConfig?: HistoryStoreConfig,
- externalQueryClient?: QueryClient,
- resource: EditorResource = { kind: 'app', appId: 'app-1', mode: 'workflow' },
-) {
- if (historyConfig) {
- stores.store.temporal.getState().pause()
- stores.store.getState().setWorkflowHistory(createTestWorkflowHistoryState(historyConfig))
- stores.store.temporal.getState().clear()
- stores.store.temporal.getState().resume()
- }
-
- const queryClient =
- externalQueryClient ??
- new QueryClient({
- defaultOptions: {
- queries: {
- retry: false,
- gcTime: Infinity,
- staleTime: Infinity,
- },
- },
- })
- if (!externalQueryClient) seedSystemFeatures(queryClient)
- // The node catalog reads KnowledgeFS availability; keep it unavailable unless a suite seeds it.
- if (!externalQueryClient) seedKnowledgeFsFeatures(queryClient)
- if (!externalQueryClient) seedAppDslVersion(queryClient)
- if (!externalQueryClient) seedAccountProfileQuery(queryClient)
- if (resource.kind === 'app') {
- const input = { input: { params: { app_id: resource.appId } } }
- for (const endpoint of [
- consoleQuery.apps.byAppId.workflows.draft.systemVariables.get,
- consoleQuery.apps.byAppId.workflows.draft.conversationVariables.get,
- ]) {
- const variableKey = endpoint.queryKey(input)
- if (!queryClient.getQueryData(variableKey))
- queryClient.setQueryData(variableKey, { items: [] })
- }
- const key = consoleQuery.apps.byAppId.get.queryKey({
- input: { params: { app_id: resource.appId } },
- })
- if (!queryClient.getQueryData(key))
- seedAppDetail(
- queryClient,
- createAppDetailFixture({ id: resource.appId, mode: resource.mode }),
- )
- }
- const QueryClientWrapper = createQueryClientWrapper(queryClient)
-
- return ({ children }: { children: React.ReactNode }) => {
- let inner: React.ReactNode = children
-
- if (stores.hooksStore) {
- inner = React.createElement(HooksStoreContext.Provider, { value: stores.hooksStore }, inner)
- }
-
- return React.createElement(
- QueryClientWrapper,
- null,
- React.createElement(EditorResourceScope, {
- resource,
- children: React.createElement(WorkflowContext.Provider, { value: stores.store }, inner),
- }),
- )
- }
-}
-
// ---------------------------------------------------------------------------
// renderWorkflowHook — composable hook renderer
// ---------------------------------------------------------------------------
@@ -558,18 +401,3 @@ export function renderNodeComponent<T extends Record<string, unknown>>(
rest,
)
}
-
-// ---------------------------------------------------------------------------
-// WorkflowHistoryStore test helper
-// ---------------------------------------------------------------------------
-
-function createTestWorkflowHistoryState(config: HistoryStoreConfig): WorkflowHistoryState {
- const nodes = config.nodes ?? []
- const edges = config.edges ?? []
- return {
- nodes,
- edges,
- workflowHistoryEvent: undefined,
- workflowHistoryEventMeta: undefined,
- }
-}
diff --git a/web/app/components/workflow/__tests__/workflow-test-providers.tsx b/web/app/components/workflow/__tests__/workflow-test-providers.tsx
new file mode 100644
index 00000000000..c3776a6d451
--- /dev/null
+++ b/web/app/components/workflow/__tests__/workflow-test-providers.tsx
@@ -0,0 +1,149 @@
+import type { ReactNode } from 'react'
+import type { EditorResource } from '../editor-resource/resource'
+import type { Shape as HooksStoreShape } from '../hooks-store/store'
+import type { InjectWorkflowStoreSliceFn, Shape } from '../store/workflow'
+import type { WorkflowHistoryState } from '../store/workflow/history-slice'
+import type { Edge, Node } from '../types'
+import { QueryClient } from '@tanstack/react-query'
+import { consoleQuery } from '@/service/console'
+import { seedAccountProfileQuery } from '@/test/console/account-profile'
+import { createQueryClientWrapper } from '@/test/console/query-client'
+import {
+ seedAppDetail,
+ seedAppDslVersion,
+ seedKnowledgeFsFeatures,
+ seedSystemFeatures,
+} from '@/test/console/query-data'
+import { createAppDetailFixture } from '@/test/fixtures/app'
+import { WorkflowContext } from '../context'
+import { EditorResourceScope } from '../editor-resource/provider'
+import { HooksStoreContext } from '../hooks-store/provider'
+import { createHooksStore } from '../hooks-store/store'
+import { createWorkflowStore } from '../store/workflow'
+
+// Provider construction shared by RTL and Browser Mode; importing it registers no test hooks.
+type WorkflowStore = ReturnType<typeof createWorkflowStore>
+type HooksStore = ReturnType<typeof createHooksStore>
+
+export function createTestWorkflowStore(
+ initialState?: Partial<Shape>,
+ injectWorkflowStoreSliceFn?: InjectWorkflowStoreSliceFn,
+): WorkflowStore {
+ const store = createWorkflowStore({ injectWorkflowStoreSliceFn })
+ if (initialState) store.setState(initialState)
+ return store
+}
+
+function createTestHooksStore(props?: Partial<HooksStoreShape>): HooksStore {
+ const store = createHooksStore(props ?? {})
+ if (props) store.setState(props)
+ return store
+}
+
+// ---------------------------------------------------------------------------
+// Shared provider options & wrapper factory
+// ---------------------------------------------------------------------------
+
+type HistoryStoreConfig = {
+ nodes?: Node[]
+ edges?: Edge[]
+}
+
+export type WorkflowProviderOptions = {
+ injectWorkflowStoreSliceFn?: InjectWorkflowStoreSliceFn
+ resource?: EditorResource
+ initialStoreState?: Partial<Shape>
+ hooksStoreProps?: Partial<HooksStoreShape>
+ historyStore?: HistoryStoreConfig
+ queryClient?: QueryClient
+}
+
+export type StoreInstances = {
+ store: WorkflowStore
+ hooksStore?: HooksStore
+}
+
+export function createStoresFromOptions(options: WorkflowProviderOptions): StoreInstances {
+ const store = createTestWorkflowStore(
+ options.initialStoreState,
+ options.injectWorkflowStoreSliceFn,
+ )
+ const hooksStore = createTestHooksStore(options.hooksStoreProps)
+ return { store, hooksStore }
+}
+
+export function createWorkflowWrapper(
+ stores: StoreInstances,
+ historyConfig?: HistoryStoreConfig,
+ externalQueryClient?: QueryClient,
+ resource: EditorResource = { kind: 'app', appId: 'app-1', mode: 'workflow' },
+) {
+ if (historyConfig) {
+ stores.store.temporal.getState().pause()
+ stores.store.getState().setWorkflowHistory(createTestWorkflowHistoryState(historyConfig))
+ stores.store.temporal.getState().clear()
+ stores.store.temporal.getState().resume()
+ }
+
+ const queryClient =
+ externalQueryClient ??
+ new QueryClient({
+ defaultOptions: {
+ queries: {
+ retry: false,
+ gcTime: Infinity,
+ staleTime: Infinity,
+ },
+ },
+ })
+ if (!externalQueryClient) seedSystemFeatures(queryClient)
+ // The node catalog reads KnowledgeFS availability; keep it unavailable unless a suite seeds it.
+ if (!externalQueryClient) seedKnowledgeFsFeatures(queryClient)
+ if (!externalQueryClient) seedAppDslVersion(queryClient)
+ if (!externalQueryClient) seedAccountProfileQuery(queryClient)
+ if (resource.kind === 'app') {
+ const input = { input: { params: { app_id: resource.appId } } }
+ for (const endpoint of [
+ consoleQuery.apps.byAppId.workflows.draft.systemVariables.get,
+ consoleQuery.apps.byAppId.workflows.draft.conversationVariables.get,
+ ]) {
+ const variableKey = endpoint.queryKey(input)
+ if (!queryClient.getQueryData(variableKey))
+ queryClient.setQueryData(variableKey, { items: [] })
+ }
+ const key = consoleQuery.apps.byAppId.get.queryKey({
+ input: { params: { app_id: resource.appId } },
+ })
+ if (!queryClient.getQueryData(key))
+ seedAppDetail(
+ queryClient,
+ createAppDetailFixture({ id: resource.appId, mode: resource.mode }),
+ )
+ }
+ const QueryClientWrapper = createQueryClientWrapper(queryClient)
+
+ return ({ children }: { children: ReactNode }) => (
+ <QueryClientWrapper>
+ <EditorResourceScope resource={resource}>
+ <WorkflowContext value={stores.store}>
+ {stores.hooksStore ? (
+ <HooksStoreContext value={stores.hooksStore}>{children}</HooksStoreContext>
+ ) : (
+ children
+ )}
+ </WorkflowContext>
+ </EditorResourceScope>
+ </QueryClientWrapper>
+ )
+}
+
+function createTestWorkflowHistoryState(config: HistoryStoreConfig): WorkflowHistoryState {
+ const nodes = config.nodes ?? []
+ const edges = config.edges ?? []
+ return {
+ nodes,
+ edges,
+ workflowHistoryEvent: undefined,
+ workflowHistoryEventMeta: undefined,
+ }
+}
diff --git a/web/app/components/workflow/hooks/__tests__/use-inspect-vars-crud-common.spec.ts b/web/app/components/workflow/hooks/__tests__/use-inspect-vars-crud-common.spec.ts
index 36747a4fd3f..7cb15acdc97 100644
--- a/web/app/components/workflow/hooks/__tests__/use-inspect-vars-crud-common.spec.ts
+++ b/web/app/components/workflow/hooks/__tests__/use-inspect-vars-crud-common.spec.ts
@@ -1,9 +1,10 @@
import type { SchemaDefinitionItemResponse } from '@dify/contracts/api/console/spec/types.gen'
import type { VarInInspect } from '@/types/workflow'
import { act, waitFor } from '@testing-library/react'
-import { createNode } from '../../__tests__/fixtures'
-import { renderWorkflowFlowHook } from '../../__tests__/workflow-test-env'
-import { BlockEnum, VarType } from '../../types'
+import { useStoreApi } from 'reactflow'
+import { createEdge, createNode } from '../../__tests__/fixtures'
+import { renderWorkflowCanvasHook } from '../../__tests__/workflow-test-env'
+import { BlockEnum, NodeRunningStatus, VarType } from '../../types'
import { useInspectVarsCrudCommon } from '../use-inspect-vars-crud-common'
const mockResetInspectorVar = vi.hoisted(() => vi.fn())
@@ -13,8 +14,6 @@ const mockFetchNodeInspectVars = vi.hoisted(() => vi.fn())
const mockDoDeleteAllInspectorVars = vi.hoisted(() => vi.fn())
const mockInvalidateConversationVarValues = vi.hoisted(() => vi.fn())
const mockInvalidateSysVarValues = vi.hoisted(() => vi.fn())
-const mockHandleCancelNodeSuccessStatus = vi.hoisted(() => vi.fn())
-const mockHandleEdgeCancelRunningStatus = vi.hoisted(() => vi.fn())
const schemaTypeDefinitions: SchemaDefinitionItemResponse[] = [
{
@@ -54,18 +53,6 @@ vi.mock('@/service/workflow', () => ({
fetchNodeInspectVars: (...args: unknown[]) => mockFetchNodeInspectVars(...args),
}))
-vi.mock('../use-nodes-interactions-without-sync', () => ({
- useNodesInteractionsWithoutSync: () => ({
- handleCancelNodeSuccessStatus: mockHandleCancelNodeSuccessStatus,
- }),
-}))
-
-vi.mock('../use-edges-interactions-without-sync', () => ({
- useEdgesInteractionsWithoutSync: () => ({
- handleEdgeCancelRunningStatus: mockHandleEdgeCancelRunningStatus,
- }),
-}))
-
const createInspectVar = (overrides: Partial<VarInInspect> = {}): VarInInspect => ({
id: 'var-1',
type: 'node',
@@ -92,6 +79,8 @@ const nodes = [
title: 'Code',
desc: '',
outputs: { answer: { type: VarType.string } },
+ _runningStatus: NodeRunningStatus.Succeeded,
+ _waitingRun: true,
},
}),
]
@@ -102,7 +91,7 @@ describe('useInspectVarsCrudCommon', () => {
})
it('invalidates cached system vars without refetching node values for system selectors', async () => {
- const { result } = renderWorkflowFlowHook(() => useInspectVarsCrudCommon(), {
+ const { result } = renderWorkflowCanvasHook(() => useInspectVarsCrudCommon(), {
nodes,
initialStoreState: {
dataSourceList: [],
@@ -120,7 +109,7 @@ describe('useInspectVarsCrudCommon', () => {
it('fetches node inspect vars, preserves output values, and marks the node as fetched', async () => {
mockFetchNodeInspectVars.mockResolvedValue([createInspectVar()])
- const { result, store } = renderWorkflowFlowHook(() => useInspectVarsCrudCommon(), {
+ const { result, store } = renderWorkflowCanvasHook(() => useInspectVarsCrudCommon(), {
nodes,
initialStoreState: {
dataSourceList: [],
@@ -131,7 +120,7 @@ describe('useInspectVarsCrudCommon', () => {
type: BlockEnum.Code,
title: 'Code',
desc: '',
- } as never,
+ },
nodeType: BlockEnum.Code,
title: 'Code',
vars: [],
@@ -165,24 +154,39 @@ describe('useInspectVarsCrudCommon', () => {
it('deletes all inspect vars, invalidates cached values, and clears edge running state', async () => {
mockDoDeleteAllInspectorVars.mockResolvedValue(undefined)
- const { result, store } = renderWorkflowFlowHook(() => useInspectVarsCrudCommon(), {
- nodes,
- initialStoreState: {
- nodesWithInspectVars: [
- {
- nodeId: 'node-1',
- nodePayload: {
- type: BlockEnum.Code,
- title: 'Code',
- desc: '',
- } as never,
- nodeType: BlockEnum.Code,
- title: 'Code',
- vars: [createInspectVar()],
- },
+ const { result, store } = renderWorkflowCanvasHook(
+ () => ({ ...useInspectVarsCrudCommon(), flow: useStoreApi() }),
+ {
+ nodes: [...nodes, createNode({ id: 'target' })],
+ edges: [
+ createEdge({
+ id: 'edge',
+ source: 'node-1',
+ target: 'target',
+ data: {
+ _sourceRunningStatus: NodeRunningStatus.Succeeded,
+ _targetRunningStatus: NodeRunningStatus.Running,
+ _waitingRun: true,
+ },
+ }),
],
+ initialStoreState: {
+ nodesWithInspectVars: [
+ {
+ nodeId: 'node-1',
+ nodePayload: {
+ type: BlockEnum.Code,
+ title: 'Code',
+ desc: '',
+ },
+ nodeType: BlockEnum.Code,
+ title: 'Code',
+ vars: [createInspectVar()],
+ },
+ ],
+ },
},
- })
+ )
await act(async () => {
await result.current.deleteAllInspectorVars()
@@ -191,13 +195,27 @@ describe('useInspectVarsCrudCommon', () => {
expect(mockDoDeleteAllInspectorVars).toHaveBeenCalledTimes(1)
expect(mockInvalidateConversationVarValues).toHaveBeenCalledTimes(1)
expect(mockInvalidateSysVarValues).toHaveBeenCalledTimes(1)
- expect(mockHandleEdgeCancelRunningStatus).toHaveBeenCalledTimes(1)
+ expect(result.current.flow.getState().edges).toMatchObject([
+ {
+ id: 'edge',
+ source: 'node-1',
+ target: 'target',
+ data: {
+ _sourceRunningStatus: undefined,
+ _targetRunningStatus: undefined,
+ _waitingRun: false,
+ },
+ },
+ ])
expect(store.getState().nodesWithInspectVars).toEqual([])
})
it.each(['variable', 'node'] as const)(
'keeps inspected values when %s deletion fails and removes them only after success',
async (target) => {
- const { result, store } = renderWorkflowFlowHook(() => useInspectVarsCrudCommon(), { nodes })
+ const { result, store } = renderWorkflowCanvasHook(
+ () => ({ ...useInspectVarsCrudCommon(), flow: useStoreApi() }),
+ { nodes },
+ )
act(() =>
result.current.appendNodeInspectVars(
'node-1',
@@ -205,6 +223,10 @@ describe('useInspectVarsCrudCommon', () => {
[createNode({ id: 'node-1', data: { type: BlockEnum.Code } })],
),
)
+ expect(result.current.flow.getState().getNodes()[0]?.data).toMatchObject({
+ _runningStatus: undefined,
+ _waitingRun: false,
+ })
const deleteRequest =
target === 'variable' ? mockDeleteInspectVar : mockDeleteNodeInspectorVars
const deleteValues = () =>
@@ -225,7 +247,10 @@ describe('useInspectVarsCrudCommon', () => {
)
it('removes a variable reset with no historical value and preserves neighboring schemas', async () => {
- const { result, store } = renderWorkflowFlowHook(() => useInspectVarsCrudCommon(), { nodes })
+ const { result, store } = renderWorkflowCanvasHook(
+ () => ({ ...useInspectVarsCrudCommon(), flow: useStoreApi() }),
+ { nodes },
+ )
const neighbor = createInspectVar({ id: 'var-2', name: 'other', schemaType: '' })
act(() =>
result.current.appendNodeInspectVars(
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.browser.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.browser.spec.tsx
index 49c82203407..51298532083 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.browser.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/node-handle.browser.spec.tsx
@@ -1,22 +1,14 @@
-import type { ReactElement, RefObject } from 'react'
+import type { RefObject } from 'react'
import type { Connection, NodeProps } from 'reactflow'
import type { CommonNodeType, OnSelectBlock } from '../../../../types'
import type { HumanInputNodeType } from '../../../human-input/types'
import { useRef, useState } from 'react'
-import ReactFlow, { ReactFlowProvider, useReactFlow } from 'reactflow'
+import ReactFlow, { useReactFlow, useStoreApi } from 'reactflow'
import { page, userEvent } from 'vite-plus/test/browser'
-import { render as renderBrowser } from 'vitest-browser-react'
-import { consoleQuery } from '@/service/console'
-import { QueryClientTestProvider } from '@/test/console/query-provider'
-import { createAppDetailFixture } from '@/test/fixtures/app'
-import { createTestQueryClient } from '@/test/query-client'
-import { WorkflowContext } from '../../../../context'
+import { CanvasNodesCatalogProbe } from '../../../../__tests__/canvas-nodes-catalog-probe'
+import { renderWorkflowBrowserComponent as render } from '../../../../__tests__/workflow-browser-test-env'
import CustomEdge from '../../../../custom-edge'
-import { EditorResourceScope } from '../../../../editor-resource/provider'
-import { HooksStoreContext } from '../../../../hooks-store/provider'
-import { createHooksStore } from '../../../../hooks-store/store'
import { useWorkflowControlScale } from '../../../../hooks/use-workflow-control-scale'
-import { createWorkflowStore } from '../../../../store/workflow'
import { BlockEnum } from '../../../../types'
import HumanInputNode from '../../../human-input/node'
import { UserActionButtonType } from '../../../human-input/types'
@@ -24,32 +16,14 @@ import { NodeSourceHandle, NodeTargetHandle } from '../node-handle'
import 'reactflow/dist/style.css'
import '../../../../style.css'
-const render = (ui: ReactElement) => {
- const queryClient = createTestQueryClient()
- queryClient.setQueryData(
- consoleQuery.apps.byAppId.get.queryKey({ input: { params: { app_id: 'app-1' } } }),
- createAppDetailFixture({ id: 'app-1', mode: 'workflow' }),
- )
- return renderBrowser(
- <QueryClientTestProvider queryClient={queryClient}>
- <EditorResourceScope resource={{ kind: 'app', appId: 'app-1', mode: 'workflow' }}>
- {ui}
- </EditorResourceScope>
- </QueryClientTestProvider>,
- )
-}
-
-const { handleNodeAdd } = vi.hoisted(() => ({ handleNodeAdd: vi.fn() }))
+const unexpectedFetch = vi.fn<typeof fetch>(() => new Promise(() => {}))
+beforeEach(() => vi.stubGlobal('fetch', unexpectedFetch))
+afterEach(() => {
+ vi.unstubAllGlobals()
+ expect(unexpectedFetch).not.toHaveBeenCalled()
+})
+let flow: ReturnType<typeof useStoreApi>
-vi.mock('../../../../hooks/use-available-blocks', () => ({
- useAvailableBlocks: () => ({
- availablePrevBlocks: [BlockEnum.Code],
- availableNextBlocks: [BlockEnum.Code],
- }),
-}))
-vi.mock('../../../../hooks/use-nodes-interactions', () => ({
- useNodesInteractions: () => ({ handleNodeAdd }),
-}))
// Search results are outside the handle's hit testing and connection contract.
vi.mock('../../../../block-selector/tabs', () => ({
BlockSelectorPanels: ({
@@ -68,10 +42,6 @@ vi.mock('../../../../block-selector/tabs', () => ({
),
}))
-beforeEach(() => {
- vi.clearAllMocks()
-})
-
function HandleNode({ id, data }: NodeProps<CommonNodeType>) {
return (
<div role="group" aria-label={data.title} className="group" style={{ width: 160, height: 80 }}>
@@ -134,12 +104,14 @@ function Canvas({
showEdge?: boolean
humanInput?: boolean
}) {
+ flow = useStoreApi()
const containerRef = useRef<HTMLDivElement>(null)
const { setViewport } = useReactFlow()
const [connection, setConnection] = useState<Connection | null>(null)
useWorkflowControlScale(containerRef)
return (
<>
+ <CanvasNodesCatalogProbe />
{[1, 0.25].map((zoom) => (
<button key={zoom} type="button" onClick={() => setViewport({ x: 0, y: 0, zoom })}>
Zoom {zoom * 100}%
@@ -187,26 +159,12 @@ function Canvas({
)
}
-function Fixture(props: { initialZoom?: number; showEdge?: boolean; humanInput?: boolean }) {
- const [store] = useState(() => createWorkflowStore({}))
- const [hooksStore] = useState(() => createHooksStore({}))
- return (
- <WorkflowContext value={store}>
- <HooksStoreContext.Provider value={hooksStore}>
- <ReactFlowProvider>
- <Canvas {...props} />
- </ReactFlowProvider>
- </HooksStoreContext.Provider>
- </WorkflowContext>
- )
-}
-
it.each([1, 0.25])(
'keeps real handles clickable at their edges and draggable at zoom %s',
async (zoom) => {
// Native hit testing under both ReactFlow and control transforms is not represented by DOM unit tests.
await page.viewport(1100, 700)
- const screen = await render(<Fixture />)
+ const screen = await render(<Canvas />)
await screen.getByRole('button', { name: `Zoom ${zoom * 100}%` }).click()
await expect.element(screen.getByRole('group', { name: 'Source node' })).toBeInTheDocument()
await expect.element(screen.getByRole('group', { name: 'Target node' })).toBeInTheDocument()
@@ -255,7 +213,7 @@ it.each([1, 0.25])(
it('keeps a saved connection anchored to the port centers when initialized at 25% zoom', async () => {
await page.viewport(1100, 700)
- const screen = await render(<Fixture initialZoom={0.25} showEdge />)
+ const screen = await render(<Canvas initialZoom={0.25} showEdge />)
await expect.element(screen.getByRole('group', { name: 'Source node' })).toBeInTheDocument()
await expect.element(screen.getByRole('group', { name: 'Target node' })).toBeInTheDocument()
const source = screen
@@ -296,7 +254,7 @@ it('adds and connects the intended human input branch at 25% zoom', async () =>
// The production branch rows are closer than 24 screen pixels at this zoom.
// Native hit testing must route clicks and drags to the selected branch, not its neighbor.
await page.viewport(1100, 700)
- const screen = await render(<Fixture initialZoom={0.25} humanInput />)
+ const screen = await render(<Canvas initialZoom={0.25} humanInput />)
const sourceNode = screen.getByRole('group', { name: 'Human input node' })
await expect.element(sourceNode).toBeInTheDocument()
await expect.element(screen.getByRole('group', { name: 'Target node' })).toBeInTheDocument()
@@ -314,10 +272,14 @@ it('adds and connects the intended human input branch at 25% zoom', async () =>
)
await source.click()
await screen.getByRole('button', { name: 'Add code node' }).click()
- expect(handleNodeAdd).toHaveBeenLastCalledWith(
- { nodeType: BlockEnum.Code, pluginDefaultValue: undefined },
- { prevNodeId: 'source', prevNodeSourceHandle: handleId },
- )
+ const inserted = flow
+ .getState()
+ .getNodes()
+ .filter((node) => !['source', 'target'].includes(node.id))
+ expect(inserted).toHaveLength(['approve', 'reject', '__timeout'].indexOf(handleId) + 1)
+ const edge = flow.getState().edges.find((edge) => edge.sourceHandle === handleId)!
+ expect(edge).toMatchObject({ source: 'source', targetHandle: 'target' })
+ expect(inserted.find((node) => node.id === edge.target)?.data.type).toBe(BlockEnum.Code)
await expect
.element(screen.getByRole('textbox', { name: 'Find a node' }))
.not.toBeInTheDocument()
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.browser.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.browser.spec.tsx
index 3576c737351..27d7c912aae 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.browser.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.browser.spec.tsx
@@ -9,6 +9,13 @@ import { NoteTheme } from '@/app/components/workflow/note-node/types'
import { BlockEnum } from '@/app/components/workflow/types'
import 'reactflow/dist/style.css'
+const unexpectedFetch = vi.fn<typeof fetch>(() => new Promise(() => {}))
+beforeEach(() => vi.stubGlobal('fetch', unexpectedFetch))
+afterEach(() => {
+ vi.unstubAllGlobals()
+ expect(unexpectedFetch).not.toHaveBeenCalled()
+})
+
// Editing and persistence are independent of the Note's rendered resize affordance.
vi.mock('../../../../note-node/note-editor', () => ({
NoteEditorContextProvider: ({ children }: { children: ReactNode }) => children,
diff --git a/web/app/components/workflow/nodes/_base/components/next-step/__tests__/item.browser.spec.tsx b/web/app/components/workflow/nodes/_base/components/next-step/__tests__/item.browser.spec.tsx
index 3d27667ea04..19e72a5455f 100644
--- a/web/app/components/workflow/nodes/_base/components/next-step/__tests__/item.browser.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/next-step/__tests__/item.browser.spec.tsx
@@ -6,6 +6,13 @@ import { renderWorkflowBrowserComponent as render } from '@/app/components/workf
import { BlockEnum } from '@/app/components/workflow/types'
import Item from '../item'
+const unexpectedFetch = vi.fn<typeof fetch>(() => new Promise(() => {}))
+beforeEach(() => vi.stubGlobal('fetch', unexpectedFetch))
+afterEach(() => {
+ vi.unstubAllGlobals()
+ expect(unexpectedFetch).not.toHaveBeenCalled()
+})
+
function SelectedNodes() {
const nodes = useNodes<CommonNodeType>()
return (
diff --git a/web/app/components/workflow/nodes/data-source/hooks/__tests__/use-before-run-form.spec.tsx b/web/app/components/workflow/nodes/data-source/hooks/__tests__/use-before-run-form.spec.tsx
index 2e6aa81e76b..1da6db16a17 100644
--- a/web/app/components/workflow/nodes/data-source/hooks/__tests__/use-before-run-form.spec.tsx
+++ b/web/app/components/workflow/nodes/data-source/hooks/__tests__/use-before-run-form.spec.tsx
@@ -2,11 +2,14 @@ import type { WorkflowRunNodeExecutionResponse } from '@dify/contracts/api/conso
import type { ReactNode } from 'react'
import type { CustomRunFormProps, DataSourceNodeType } from '../../types'
import type { DataSourceShape } from '@/app/components/datasets/documents/create-from-pipeline/data-source/store'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import { act, renderHook, waitFor } from '@testing-library/react'
-import { ReactFlowProvider } from 'reactflow'
+import type { Shape as HooksStore } from '@/app/components/workflow/hooks-store/store'
+import { QueryClient } from '@tanstack/react-query'
+import { act, waitFor } from '@testing-library/react'
+import { useStoreApi } from 'reactflow'
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, NodeRunningStatus } from '@/app/components/workflow/types'
import { DatasourceType } from '@/models/pipeline'
import { consoleQuery } from '@/service/console'
@@ -14,7 +17,11 @@ import { createDeferred } from '@/test/deferred'
import { TransferMethod } from '@/types/app'
import useBeforeRunForm from '../use-before-run-form'
-const mocks = vi.hoisted(() => ({ run: vi.fn(), inspect: vi.fn(), update: vi.fn(), sync: vi.fn() }))
+const mocks = vi.hoisted(() => ({
+ run: vi.fn(),
+ inspect: vi.fn(),
+ sync: vi.fn<HooksStore['doSyncWorkflowDraft']>(),
+}))
vi.mock('@/service/console', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/service/console')>()
@@ -30,13 +37,6 @@ vi.mock('@/service/workflow', async (importOriginal) => ({
...(await importOriginal<typeof import('@/service/workflow')>()),
fetchNodeInspectVars: mocks.inspect,
}))
-vi.mock('../../../../hooks/use-node-data-update', () => ({
- useNodeDataUpdate: () => ({ handleNodeDataUpdate: mocks.update }),
-}))
-vi.mock('../../../../hooks/use-nodes-sync-draft', () => ({
- useNodesSyncDraft: () => ({ handleSyncWorkflowDraft: mocks.sync }),
-}))
-
const createData = (overrides: Partial<DataSourceNodeType> = {}): DataSourceNodeType => ({
title: 'Datasource',
desc: '',
@@ -158,14 +158,26 @@ function setup(props = createProps(), selection: Partial<DataSourceShape> = {})
})
client.setQueryData(lastRunKey, { id: 'last-run-1', status: 'succeeded' })
const wrapper = ({ children }: { children: ReactNode }) => (
- <QueryClientProvider client={client}>
- <ReactFlowProvider>
- <DataSourceContext.Provider value={store}>{children}</DataSourceContext.Provider>
- </ReactFlowProvider>
- </QueryClientProvider>
+ <DataSourceContext value={store}>{children}</DataSourceContext>
+ )
+ let flow: ReturnType<typeof useStoreApi>
+ const rendered = renderWorkflowCanvasHook(
+ (props: CustomRunFormProps) => {
+ flow = useStoreApi()
+ return useBeforeRunForm(props)
+ },
+ {
+ initialProps: props,
+ wrapper,
+ queryClient: client,
+ resource: props.resource,
+ nodes: [createNode({ id: props.nodeId, data: props.payload })],
+ hooksStoreProps: { doSyncWorkflowDraft: mocks.sync },
+ },
)
return {
- ...renderHook(useBeforeRunForm, { initialProps: props, wrapper }),
+ ...rendered,
+ nodeData: () => flow.getState().getNodes()[0]!.data,
store,
props,
client,
@@ -177,14 +189,14 @@ beforeEach(() => {
vi.resetAllMocks()
mocks.run.mockResolvedValue({ id: 'run-1', status: NodeRunningStatus.Succeeded })
mocks.inspect.mockResolvedValue([])
- mocks.sync.mockImplementation((_sync, _skipRefresh, callbacks) => callbacks.onSuccess())
+ mocks.sync.mockImplementation(async (_skipRefresh, callbacks) => callbacks?.onSuccess?.())
})
describe('data source single run', () => {
it.each(selections)(
'reacts to selection changes and sends the $type payload',
async ({ type, state, info }) => {
- const { result, store, props } = setup(
+ const { result, store, props, nodeData } = setup(
createProps({ payload: createData({ provider_type: type }) }),
)
expect(result.current.startRunBtnDisabled).toBe(true)
@@ -204,18 +216,15 @@ describe('data source single run', () => {
},
})
expect(mocks.inspect).toHaveBeenCalledWith(props.resource, props.nodeId)
- expect(props.appendNodeInspectVars).toHaveBeenCalledWith(props.nodeId, [], [])
+ expect(props.appendNodeInspectVars).toHaveBeenCalledWith(
+ props.nodeId,
+ [],
+ [expect.objectContaining({ id: props.nodeId })],
+ )
expect(props.setIsRunAfterSingleRun).toHaveBeenCalledWith(true)
- expect(mocks.update).toHaveBeenNthCalledWith(1, {
- id: props.nodeId,
- data: expect.objectContaining({ _singleRunningStatus: NodeRunningStatus.Running }),
- })
- expect(mocks.update).toHaveBeenLastCalledWith({
- id: props.nodeId,
- data: expect.objectContaining({
- _singleRunningStatus: NodeRunningStatus.Succeeded,
- _isSingleRun: false,
- }),
+ expect(nodeData()).toMatchObject({
+ _singleRunningStatus: NodeRunningStatus.Succeeded,
+ _isSingleRun: false,
})
},
)
@@ -232,11 +241,12 @@ describe('data source single run', () => {
it('waits for draft synchronization and exposes pending state until the run settles', async () => {
const pending = createDeferred<WorkflowRunNodeExecutionResponse>()
mocks.run.mockReturnValue(pending.promise)
- mocks.sync.mockImplementation(() => undefined)
- const { result, props } = setup(createProps(), { localFileList: localFiles })
+ mocks.sync.mockImplementation(async () => undefined)
+ const { result, props, nodeData } = setup(createProps(), { localFileList: localFiles })
act(() => result.current.handleRunWithSyncDraft())
expect(mocks.run).not.toHaveBeenCalled()
- act(() => mocks.sync.mock.calls[0]![2].onSuccess())
+ expect(nodeData()._singleRunningStatus).toBe(NodeRunningStatus.Running)
+ act(() => mocks.sync.mock.calls[0]![1]?.onSuccess?.())
await waitFor(() => expect(result.current.isPending).toBe(true))
await act(async () => pending.resolve({ id: 'run-1', status: NodeRunningStatus.Succeeded }))
await waitFor(() => expect(props.onSuccess).toHaveBeenCalledOnce())
@@ -245,18 +255,15 @@ describe('data source single run', () => {
it('marks a rejected request failed, invalidates last run and refreshes default error outputs', async () => {
mocks.run.mockRejectedValue(new Error('Run failed'))
- const { result, props, client, lastRunKey } = setup(createProps(), {
+ const { result, props, client, lastRunKey, nodeData } = setup(createProps(), {
localFileList: localFiles,
})
act(() => result.current.handleRunWithSyncDraft())
await waitFor(() => expect(props.appendNodeInspectVars).toHaveBeenCalledOnce())
expect(client.getQueryState(lastRunKey)?.isInvalidated).toBe(true)
- expect(mocks.update).toHaveBeenLastCalledWith({
- id: props.nodeId,
- data: expect.objectContaining({
- _singleRunningStatus: NodeRunningStatus.Failed,
- _isSingleRun: false,
- }),
+ expect(nodeData()).toMatchObject({
+ _singleRunningStatus: NodeRunningStatus.Failed,
+ _isSingleRun: false,
})
expect(props.onSuccess).not.toHaveBeenCalled()
})
@@ -266,7 +273,7 @@ describe('data source single run', () => {
async (outcome) => {
const pending = createDeferred<WorkflowRunNodeExecutionResponse>()
mocks.run.mockReturnValue(pending.promise)
- const { result, props, rerender, client, lastRunKey } = setup(createProps(), {
+ const { result, props, rerender, client, lastRunKey, nodeData } = setup(createProps(), {
localFileList: localFiles,
})
act(() => result.current.handleRunWithSyncDraft())
@@ -277,7 +284,7 @@ describe('data source single run', () => {
else pending.resolve({ id: 'run-1', status: NodeRunningStatus.Succeeded })
})
await waitFor(() => expect(result.current.isPending).toBe(false))
- expect(mocks.update).toHaveBeenCalledTimes(1)
+ expect(nodeData()._singleRunningStatus).toBe(NodeRunningStatus.Running)
expect(mocks.inspect).not.toHaveBeenCalled()
expect(props.onSuccess).not.toHaveBeenCalled()
expect(client.getQueryState(lastRunKey)?.isInvalidated).toBe(outcome === 'failed')
diff --git a/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.browser.spec.tsx b/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.browser.spec.tsx
index 1e2355c0ece..b67b1929c53 100644
--- a/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.browser.spec.tsx
+++ b/web/app/components/workflow/shortcuts/__tests__/workflow-canvas.browser.spec.tsx
@@ -1,142 +1,57 @@
import type { ContextMenuActions } from '@langgenius/dify-ui/context-menu'
-import type { ReactElement } from 'react'
-import type { Edge, Node, NodeProps } from 'reactflow'
-import type { StoreApi } from 'zustand'
+import type { NodeProps } from 'reactflow'
+import type { Edge, Node } from '../../types'
import { ContextMenu, ContextMenuTrigger } from '@langgenius/dify-ui/context-menu'
import { detectPlatform } from '@tanstack/react-hotkeys'
import { useRef, useState } from 'react'
import { createPortal } from 'react-dom'
-import { Handle, Position, ReactFlowProvider, useStore as useReactFlowStore } from 'reactflow'
+import { Handle, Position, useStore as useReactFlowStore, useStoreApi } from 'reactflow'
import { page, userEvent } from 'vite-plus/test/browser'
-import { render as renderBrowser } from 'vitest-browser-react'
-import { createStore, useStore } from 'zustand'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
-import { seedToolProviders } from '@/test/console/tool-providers'
-import { WorkflowContext } from '../../context'
+import { CanvasNodesCatalogProbe } from '../../__tests__/canvas-nodes-catalog-probe'
+import { createEdge, createNode } from '../../__tests__/fixtures'
+import { renderWorkflowBrowserComponent as render } from '../../__tests__/workflow-browser-test-env'
import { EdgeContextmenu } from '../../edge-contextmenu'
+import { useEdgesInteractions } from '../../hooks/use-edges-interactions'
import { useNodeKeyboardInteractions } from '../../hooks/use-node-keyboard-interactions'
+import { useNodesInteractions } from '../../hooks/use-nodes-interactions'
+import { useSelectionInteractions } from '../../hooks/use-selection-interactions'
import { NodeActionsDropdown } from '../../node-actions-menu'
import { NodeActionsContextMenuContent } from '../../node-actions-menu/context-menu-content'
import VarReferenceVars from '../../nodes/_base/components/variable/var-reference-vars'
import { NoteEditor, NoteEditorContextProvider } from '../../note-node/note-editor'
import NoteOperator from '../../note-node/note-editor/toolbar/operator'
import { SelectionContextmenu } from '../../selection-contextmenu'
-import { createWorkflowStore } from '../../store/workflow'
-import { BlockEnum, VarType } from '../../types'
+import { BlockEnum, ControlMode, VarType } from '../../types'
import { WorkflowCanvas } from '../workflow-canvas'
import 'reactflow/dist/style.css'
-function render(ui: ReactElement) {
- const { queryClient, wrapper: Wrapper } = createConsoleQueryWrapper()
- seedToolProviders(queryClient, { workflowTools: [] })
- return renderBrowser(<Wrapper>{ui}</Wrapper>)
-}
-
-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(),
-}))
-
-vi.mock('../../hooks/use-nodes-interactions', () => ({
- useNodesInteractions: () => ({
- handleNodesCopy: actions.copy,
- handleNodesPaste: actions.paste,
- handleNodesDuplicate: actions.duplicate,
- handleNodesDelete: actions.deleteNodes,
- handleNodeDelete: actions.deleteNodes,
- handleHistoryBack: actions.undo,
- handleHistoryForward: actions.redo,
- dimOtherNodes: actions.dim,
- undimAllNodes: actions.undim,
- }),
-}))
-vi.mock('../../hooks/use-edges-interactions', () => ({
- useEdgesInteractions: () => ({
- handleEdgeDelete: actions.deleteEdge,
- handleEdgeDeleteById: actions.deleteEdge,
- }),
-}))
-vi.mock('../../hooks/use-nodes-sync-draft', () => ({
- useNodesSyncDraft: () => ({ handleSyncWorkflowDraft: actions.save }),
-}))
-vi.mock('../../hooks/use-workflow', () => ({
- useNodesReadOnly: () => ({ nodesReadOnly: false, getNodesReadOnly: () => false }),
-}))
-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('../../hooks-store', () => ({
- useHooksStore: (selector: (state: { accessControl: { canRun: boolean } }) => unknown) =>
- selector({ accessControl: { canRun: false } }),
-}))
-vi.mock('../../hooks/use-nodes-meta-data', () => ({
- useNodeMetaData: () => ({
- isTypeFixed: true,
- isSingleton: false,
- isUndeletable: false,
- description: 'Test node',
- author: 'Dify',
- }),
-}))
-vi.mock('../../node-actions-menu/change-block-popup', () => ({ ChangeBlockPopup: () => null }))
+vi.mock('next/navigation', () => ({ useRouter: () => ({ push: vi.fn() }) }))
-vi.mock('@/context/permission-state', async () => {
- const { createPermissionStateModuleMock } = await import('@/test/console/state-fixture')
- return createPermissionStateModuleMock(() => ({ workspacePermissionKeys: [] }))
+const unexpectedFetch = vi.fn<typeof fetch>(() => new Promise(() => {}))
+beforeEach(() => vi.stubGlobal('fetch', unexpectedFetch))
+afterEach(() => {
+ vi.unstubAllGlobals()
+ expect(unexpectedFetch).not.toHaveBeenCalled()
})
-vi.mock('@/app/components/snippets/hooks/use-create-snippet-from-selection', () => ({
- useCreateSnippetFromSelection: () => ({
- createSnippetDialog: null,
- handleOpenCreateSnippet: () => {},
- isCreateSnippetDialogOpen: false,
- }),
-}))
-vi.mock('../../hooks/use-workflow-history', () => ({
- WorkflowHistoryEvent: { NodeDragStop: 'NodeDragStop' },
- useWorkflowHistory: () => ({ saveStateToHistory: () => {} }),
-}))
-function NodeWithMenu({ id }: NodeProps) {
+function NodeWithMenu({ id, data }: NodeProps) {
return (
<div className="nodrag nopan">
Workflow node
- <NodeActionsDropdown
- id={id}
- data={{ type: BlockEnum.Code, title: 'Workflow node', desc: '' }}
- showHelpLink={false}
- />
+ <NodeActionsDropdown id={id} data={data} showHelpLink={false} />
</div>
)
}
-function NoteWithMenu() {
+function NoteWithMenu({ id }: NodeProps) {
+ const { handleNodesCopy, handleNodesDuplicate, handleNodeDelete } = useNodesInteractions()
return (
<div className="nodrag nopan">
Note node
<NoteOperator
- onCopy={actions.copy}
- onDuplicate={actions.duplicate}
- onDelete={actions.deleteNodes}
+ onCopy={() => handleNodesCopy(id)}
+ onDuplicate={() => handleNodesDuplicate(id)}
+ onDelete={() => handleNodeDelete(id)}
showAuthor={false}
onShowAuthorChange={() => {}}
/>
@@ -144,301 +59,316 @@ function NoteWithMenu() {
)
}
const nodeTypes = { menu: NodeWithMenu, note: NoteWithMenu }
-
-const initialNodes: Node[] = [
- { id: 'node', position: { x: 350, y: 150 }, data: { label: 'Workflow node' } },
+const initialNodes = [
+ createNode({
+ id: 'node',
+ type: 'default',
+ ariaLabel: 'Workflow node',
+ position: { x: 350, y: 150 },
+ data: { label: 'Workflow node' },
+ }),
+ // Keep a nonempty snapshot for redo; the known empty-canvas redo bug is outside this batch.
+ createNode({
+ id: 'anchor',
+ type: 'default',
+ ariaLabel: 'Anchor node',
+ position: { x: 730, y: 430 },
+ data: { label: 'Anchor node' },
+ }),
]
-type GraphState = { nodes: Node[]; edges: Edge[] }
-const createGraph = () => createStore<GraphState>(() => ({ nodes: initialNodes, edges: [] }))
+let flow: ReturnType<typeof useStoreApi>
+const graphNodes = () => flow.getState().getNodes()
+const graphEdges = () => flow.getState().edges
+const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
+const undo = () => userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+const redo = () => userEvent.keyboard(`{${mod}>}{Shift>}z{/Shift}{/${mod}}`)
+
+// Advance the production history debounce explicitly, without relying on CI wall-clock speed.
+async function recordHistory(action: () => Promise<unknown>) {
+ vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'Date'] })
+ try {
+ await action()
+ await vi.advanceTimersByTimeAsync(600)
+ } finally {
+ vi.useRealTimers()
+ }
+}
-function Canvas({
- graph,
- contextMenuType,
-}: {
- graph?: StoreApi<GraphState>
+type CanvasProps = {
+ nodes?: Node[]
+ edges?: Edge[]
contextMenuType?: 'node' | 'edge' | 'selection'
-}) {
+}
+function Canvas({ nodes = initialNodes, edges = [], contextMenuType }: CanvasProps) {
+ flow = useStoreApi()
+ const { handleSelectionStart, handleSelectionChange, handleSelectionContextMenu } =
+ useSelectionInteractions()
const contextMenuActionsRef = useRef<ContextMenuActions>(null)
- const [defaultGraph] = useState(createGraph)
- const nodes = useStore(graph ?? defaultGraph, (state) => state.nodes)
- const edges = useStore(graph ?? defaultGraph, (state) => state.edges)
- const [store] = useState(() => createWorkflowStore({}))
+ const { handleNodeSelect } = useNodesInteractions()
+ const { handleEdgeContextMenu } = useEdgesInteractions()
+ const onKeyDownCapture = useNodeKeyboardInteractions(handleNodeSelect)
return (
- <WorkflowContext value={store}>
- <ReactFlowProvider>
- <ContextMenu actionsRef={contextMenuActionsRef}>
- <ContextMenuTrigger render={<div style={{ width: 800, height: 500 }} />}>
- <WorkflowCanvas
- nodes={nodes}
- edges={edges}
- nodeTypes={nodeTypes}
- selectionOnDrag={contextMenuType === 'selection'}
- panOnDrag={contextMenuType !== 'selection'}
- onSelectionContextMenu={() =>
- store.setState({ contextMenuTarget: { type: 'selection' } })
- }
- onEdgeContextMenu={(_, edge) =>
- store.setState({ contextMenuTarget: { type: 'edge', edgeId: edge.id } })
- }
+ <>
+ <ContextMenu actionsRef={contextMenuActionsRef}>
+ <ContextMenuTrigger render={<div style={{ width: 800, height: 500 }} />}>
+ <WorkflowCanvas
+ defaultNodes={nodes}
+ defaultEdges={edges}
+ nodeTypes={nodeTypes}
+ onNodeClick={(_, node) => handleNodeSelect(node.id)}
+ deleteKeyCode={null}
+ onKeyDownCapture={onKeyDownCapture}
+ selectionOnDrag={contextMenuType === 'selection'}
+ panOnDrag={contextMenuType !== 'selection'}
+ onSelectionStart={handleSelectionStart}
+ onSelectionChange={handleSelectionChange}
+ onSelectionContextMenu={handleSelectionContextMenu}
+ selectionKeyCode={null}
+ multiSelectionKeyCode={null}
+ onEdgeContextMenu={handleEdgeContextMenu}
+ >
+ <textarea
+ aria-label="Node prompt"
+ style={{ position: 'absolute', zIndex: 5, top: 20, left: 20 }}
+ />
+ <div
+ style={{
+ position: 'absolute',
+ zIndex: 5,
+ top: 80,
+ left: 20,
+ width: 240,
+ minHeight: 80,
+ }}
>
- <textarea
- aria-label="Node prompt"
- style={{ position: 'absolute', zIndex: 5, top: 20, left: 20 }}
- />
- <div
- style={{
- position: 'absolute',
- zIndex: 5,
- top: 80,
- left: 20,
- width: 240,
- minHeight: 80,
- }}
- >
- <NoteEditorContextProvider>
- <NoteEditor containerElement={null} />
- </NoteEditorContextProvider>
- </div>
- {createPortal(<button>Popup action</button>, document.body)}
- </WorkflowCanvas>
- </ContextMenuTrigger>
- {contextMenuType === 'node' ? (
- nodes.length > 0 && (
- <NodeActionsContextMenuContent
- id="node"
- data={{ type: BlockEnum.Code, title: 'Workflow node', desc: '' }}
- onClose={() => contextMenuActionsRef.current?.close()}
- showHelpLink={false}
- />
- )
- ) : contextMenuType === 'selection' ? (
- <SelectionContextmenu onClose={() => contextMenuActionsRef.current?.close()} />
- ) : contextMenuType === 'edge' ? (
- <EdgeContextmenu onClose={() => contextMenuActionsRef.current?.close()} />
- ) : null}
- </ContextMenu>
- <input aria-label="Outside canvas input" />
- </ReactFlowProvider>
- </WorkflowContext>
+ <NoteEditorContextProvider>
+ <NoteEditor containerElement={null} />
+ </NoteEditorContextProvider>
+ </div>
+ {createPortal(<button>Popup action</button>, document.body)}
+ </WorkflowCanvas>
+ </ContextMenuTrigger>
+ {contextMenuType === 'node' ? (
+ <NodeActionsContextMenuContent
+ id="node"
+ data={initialNodes[0]!.data}
+ onClose={() => contextMenuActionsRef.current?.close()}
+ showHelpLink={false}
+ />
+ ) : contextMenuType === 'edge' ? (
+ <EdgeContextmenu onClose={() => contextMenuActionsRef.current?.close()} />
+ ) : contextMenuType === 'selection' ? (
+ <SelectionContextmenu onClose={() => contextMenuActionsRef.current?.close()} />
+ ) : null}
+ </ContextMenu>
+ <input aria-label="Outside canvas input" />
+ <CanvasNodesCatalogProbe />
+ </>
)
}
-
-beforeEach(() => {
- vi.resetAllMocks()
-})
-
-it('admits and releases keyboard focus while keeping character shortcuts inside the canvas', async () => {
- // Native Tab navigation and shifted printable keys establish the focused-component boundary.
+async function setup(props: CanvasProps = {}, commentMode = false) {
await page.viewport(1000, 700)
+ const { queryClient } = createConsoleQueryWrapper({
+ appDslVersion: '0.6.0',
+ systemFeatures: { enable_collaboration_mode: commentMode },
+ })
+ // Draft persistence is supplied by the owning editor; graph mutations and history stay real.
+ const save = vi.fn(async () => undefined)
const screen = await render(
<>
<button>Before canvas</button>
- <Canvas />
+ <Canvas {...props} />
</>,
+ {
+ queryClient,
+ initialStoreState: { controlMode: ControlMode.Hand },
+ hooksStoreProps: { doSyncWorkflowDraft: save },
+ historyStore: { nodes: props.nodes ?? initialNodes, edges: props.edges ?? [] },
+ },
)
+ return { ...screen, save }
+}
+
+it('admits and releases keyboard focus while keeping mode and zoom shortcuts inside the canvas', async () => {
+ const screen = await setup({}, true)
const before = screen.getByRole('button', { name: 'Before canvas' })
const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
const node = screen.getByRole('button', { name: 'Workflow node' })
-
- await userEvent.keyboard('{Tab}')
+ await userEvent.tab()
await expect.element(before).toHaveFocus()
- await userEvent.keyboard('{Tab}')
+ await userEvent.tab()
await expect.element(canvas).toHaveFocus()
- await userEvent.keyboard('vhc')
- expect(actions.pointer).toHaveBeenCalledOnce()
- expect(actions.hand).toHaveBeenCalledOnce()
- expect(actions.comment).toHaveBeenCalledOnce()
-
- const initialWidth = node.element().getBoundingClientRect().width
- expect(initialWidth).toBeGreaterThan(0)
+ const width = node.element().getBoundingClientRect().width
+ expect(width).toBeGreaterThan(0)
await userEvent.keyboard('{Shift>}[Digit5]{/Shift}')
- await expect
- .poll(() => node.element().getBoundingClientRect().width)
- .toBeCloseTo(initialWidth / 2)
+ await expect.poll(() => node.element().getBoundingClientRect().width).toBeCloseTo(width / 2)
await userEvent.keyboard('{Shift>}[Digit1]{/Shift}')
- await expect.poll(() => node.element().getBoundingClientRect().width).toBeCloseTo(initialWidth)
-
- await userEvent.keyboard('{Shift>}{Tab}{/Shift}')
+ await expect.poll(() => node.element().getBoundingClientRect().width).toBeCloseTo(width)
+ for (const [key, mode] of [
+ ['v', ControlMode.Pointer],
+ ['h', ControlMode.Hand],
+ ['c', ControlMode.Comment],
+ ] as const) {
+ await userEvent.keyboard(key)
+ expect(screen.store.getState().controlMode).toBe(mode)
+ }
+ await userEvent.keyboard('v')
+ expect(screen.store.getState().controlMode).toBe(ControlMode.Pointer)
+ await userEvent.tab({ shift: true })
await expect.element(before).toHaveFocus()
- await userEvent.keyboard('vhc{Shift>}[Digit5]{/Shift}')
- expect(node.element().getBoundingClientRect().width).toBeCloseTo(initialWidth)
-
+ await userEvent.keyboard('hc{Shift>}[Digit5]{/Shift}')
+ expect(screen.store.getState().controlMode).toBe(ControlMode.Pointer)
+ expect(node.element().getBoundingClientRect().width).toBeCloseTo(width)
await screen.getByRole('textbox', { name: 'workflow.nodes.note.editor.label' }).click()
- await userEvent.keyboard('vhc')
- expect(actions.pointer).toHaveBeenCalledOnce()
- expect(actions.hand).toHaveBeenCalledOnce()
- expect(actions.comment).toHaveBeenCalledOnce()
+ await userEvent.keyboard('hc')
+ expect(screen.store.getState().controlMode).toBe(ControlMode.Pointer)
})
-it('acquires canvas focus from pane and node clicks while preserving native editor undo', async () => {
- // Native focus, React Flow pointer handling, and textarea undo cannot be proved by synthetic key events.
- await page.viewport(1000, 700)
- const screen = await render(<Canvas />)
+it('acquires canvas focus from clicks while leaving native editor undo and outside shortcuts alone', async () => {
+ const screen = await setup()
const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
await canvas.click({ position: { x: 650, y: 400 } })
await expect.element(canvas).toHaveFocus()
await userEvent.keyboard(`{${mod}>}s{/${mod}}`)
- expect(actions.save).toHaveBeenCalledTimes(1)
-
+ screen.store.getState().flushPendingSync()
+ expect(screen.save).toHaveBeenCalledOnce()
const node = screen.getByRole('button', { name: 'Workflow node' })
await node.click()
await expect.element(node).toHaveFocus()
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
- expect(actions.undo).toHaveBeenCalledTimes(1)
-
const prompt = screen.getByRole('textbox', { name: 'Node prompt' })
await prompt.click()
await userEvent.keyboard('Draft text')
await expect.element(prompt).toHaveValue('Draft text')
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await undo()
await expect.element(prompt).toHaveValue('')
- expect(actions.undo).toHaveBeenCalledTimes(1)
-
+ expect(graphNodes().map((node) => node.id)).toEqual(['node', 'anchor'])
+ expect(screen.store.temporal.getState().pastStates).toHaveLength(0)
await screen.getByRole('button', { name: 'Popup action' }).click()
await userEvent.keyboard(`{${mod}>}s{/${mod}}`)
- expect(actions.save).toHaveBeenCalledTimes(1)
-
+ screen.store.getState().flushPendingSync()
+ expect(screen.save).toHaveBeenCalledOnce()
await canvas.click({ position: { x: 650, y: 400 } })
- await expect.element(canvas).toHaveFocus()
await userEvent.keyboard(`{${mod}>}s{/${mod}}`)
- expect(actions.save).toHaveBeenCalledTimes(2)
+ screen.store.getState().flushPendingSync()
+ expect(screen.save).toHaveBeenCalledTimes(2)
})
-it('keeps canvas focus when delete, undo, or redo removes the focused node', async () => {
- await page.viewport(1000, 700)
- const graph = createGraph()
- actions.deleteNodes.mockImplementation(() => graph.setState({ nodes: [] }))
- actions.undo.mockImplementation(() => graph.setState({ nodes: initialNodes }))
- actions.redo.mockImplementation(() => graph.setState({ nodes: [] }))
- const screen = await render(<Canvas graph={graph} />)
+it('keeps canvas focus when real deletion and redo remove the focused node', async () => {
+ const screen = await setup()
const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
const node = screen.getByRole('button', { name: 'Workflow node' })
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
-
- await node.click()
- await userEvent.keyboard('{Delete}')
- await expect.element(node).not.toBeInTheDocument()
- await expect.element(canvas).toHaveFocus()
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
- await expect.element(node).toBeInTheDocument()
-
await node.click()
- await userEvent.keyboard(`{${mod}>}{Shift>}z{/Shift}{/${mod}}`)
+ await recordHistory(() => userEvent.keyboard('{Delete}'))
await expect.element(node).not.toBeInTheDocument()
await expect.element(canvas).toHaveFocus()
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ expect(graphNodes().map((node) => node.id)).toEqual(['anchor'])
+ await undo()
await expect.element(node).toBeInTheDocument()
-
- actions.undo.mockImplementation(() => graph.setState({ nodes: [] }))
- actions.redo.mockImplementation(() => graph.setState({ nodes: initialNodes }))
await node.click()
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await redo()
await expect.element(node).not.toBeInTheDocument()
await expect.element(canvas).toHaveFocus()
- await userEvent.keyboard(`{${mod}>}{Shift>}z{/Shift}{/${mod}}`)
+ await undo()
await expect.element(node).toBeInTheDocument()
})
-it('lets the production Note editor own text history', async () => {
- await page.viewport(1000, 700)
- const screen = await render(<Canvas />)
+it('lets the production Note editor own text undo and redo', async () => {
+ const screen = await setup()
const note = screen.getByRole('textbox', { name: 'workflow.nodes.note.editor.label' })
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
await note.click()
await userEvent.keyboard('Note text')
await expect.element(note).toHaveTextContent('Note text')
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await undo()
await expect.element(note).toBeEmptyDOMElement()
- expect(actions.undo).not.toHaveBeenCalled()
- await userEvent.keyboard(`{${mod}>}{Shift>}z{/Shift}{/${mod}}`)
+ await redo()
await expect.element(note).toHaveTextContent('Note text')
- expect(actions.redo).not.toHaveBeenCalled()
+ expect(graphNodes().map((node) => node.id)).toEqual(['node', 'anchor'])
+ expect(screen.store.temporal.getState().pastStates).toHaveLength(0)
})
-it.each(['menu', 'note'])(
- 'returns to canvas history after the %s menu deletes its own trigger',
- async (nodeType) => {
- await page.viewport(1000, 700)
- const graph = createGraph()
- const menuNodes = initialNodes.map((node) => ({ ...node, type: nodeType }))
- graph.setState({ nodes: menuNodes })
- actions.deleteNodes.mockImplementation(() => graph.setState({ nodes: [] }))
- actions.undo.mockImplementation(() => graph.setState({ nodes: menuNodes }))
- const screen = await render(<Canvas graph={graph} />)
+it.each(['menu', 'note'] as const)(
+ 'returns to real canvas undo after the %s dropdown deletes its trigger',
+ async (type) => {
+ const screen = await setup({
+ nodes: initialNodes.map((node) => (node.id === 'node' ? { ...node, type } : node)),
+ })
const more = screen.getByRole('button', { name: 'common.operation.more' })
await more.click()
- await screen.getByRole('menuitem', { name: /common.operation.delete/ }).click()
+ await recordHistory(() =>
+ screen.getByRole('menuitem', { name: /common.operation.delete/ }).click(),
+ )
await expect.element(more).not.toBeInTheDocument()
- const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
- await expect.element(canvas).toHaveFocus()
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await expect.element(screen.getByRole('region', { name: 'app.types.workflow' })).toHaveFocus()
+ expect(graphNodes().map((node) => node.id)).toEqual(['anchor'])
+ await undo()
await expect.element(more).toBeInTheDocument()
- expect(actions.undo).toHaveBeenCalledTimes(1)
+ expect(graphNodes().map((node) => node.id)).toEqual(['node', 'anchor'])
},
)
-it('returns to canvas undo after a node context-menu action removes the focused node', async () => {
- await page.viewport(1000, 700)
- const graph = createGraph()
- actions.deleteNodes.mockImplementation(() => graph.setState({ nodes: [] }))
- actions.undo.mockImplementation(() => graph.setState({ nodes: initialNodes }))
- const screen = await render(<Canvas graph={graph} contextMenuType="node" />)
+it('returns to real canvas undo after a node context menu removes its focus target', async () => {
+ const screen = await setup({ contextMenuType: 'node' })
const node = screen.getByRole('button', { name: 'Workflow node' })
await node.click({ button: 'right' })
- await screen.getByRole('menuitem', { name: /common.operation.delete/ }).click()
+ await recordHistory(() =>
+ screen.getByRole('menuitem', { name: /common.operation.delete/ }).click(),
+ )
await expect.element(node).not.toBeInTheDocument()
- const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
- await expect.element(canvas).toHaveFocus()
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await expect.element(screen.getByRole('region', { name: 'app.types.workflow' })).toHaveFocus()
+ await undo()
await expect.element(node).toBeInTheDocument()
- expect(actions.undo).toHaveBeenCalledTimes(1)
})
-it('returns to canvas undo after an edge context-menu action removes the focused edge', async () => {
- await page.viewport(1000, 700)
- const graph = createGraph()
+it('returns to real canvas undo after deleting an edge through its context menu', async () => {
const nodes = [
...initialNodes,
- { id: 'other', position: { x: 500, y: 300 }, data: { label: 'Other node' } },
+ createNode({
+ id: 'other',
+ type: 'default',
+ position: { x: 500, y: 300 },
+ data: { label: 'Other node' },
+ }),
+ ]
+ const edges = [
+ createEdge({
+ id: 'edge',
+ source: 'node',
+ target: 'other',
+ sourceHandle: undefined,
+ targetHandle: undefined,
+ type: 'default',
+ }),
]
- const edges = [{ id: 'edge', source: 'node', target: 'other' }]
- graph.setState({ nodes, edges })
- actions.deleteEdge.mockImplementation(() => graph.setState({ edges: [] }))
- actions.undo.mockImplementation(() => graph.setState({ edges }))
- const screen = await render(<Canvas graph={graph} contextMenuType="edge" />)
+ const screen = await setup({ nodes, edges, contextMenuType: 'edge' })
const edge = screen.getByTestId('rf__edge-edge')
- const outsideInput = screen.getByLabelText('Outside canvas input')
- await outsideInput.click()
+ await screen.getByLabelText('Outside canvas input').click()
await edge.click({ button: 'right' })
- await screen.getByRole('menuitem', { name: /common.operation.delete/ }).click()
+ await recordHistory(() =>
+ screen.getByRole('menuitem', { name: /common.operation.delete/ }).click(),
+ )
await expect.element(edge).not.toBeInTheDocument()
- const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
- await expect.element(canvas).toHaveFocus()
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ await expect.element(screen.getByRole('region', { name: 'app.types.workflow' })).toHaveFocus()
+ expect(graphEdges()).toEqual([])
+ await undo()
await expect.element(edge).toBeInTheDocument()
- expect(actions.undo).toHaveBeenCalledTimes(1)
+ expect(graphEdges()).toMatchObject(edges)
await edge.click({ button: 'right' })
await userEvent.keyboard('{Escape}')
- await expect.element(canvas).toHaveFocus()
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
- expect(actions.undo).toHaveBeenCalledTimes(2)
+ await expect.element(screen.getByRole('region', { name: 'app.types.workflow' })).toHaveFocus()
})
-it('returns to canvas undo after a selection context-menu action removes the focused selection', async () => {
- await page.viewport(1000, 700)
- const graph = createGraph()
+it('returns to real canvas undo after deleting a native drag selection from its context menu', async () => {
const nodes = [
...initialNodes,
- { id: 'other', position: { x: 500, y: 300 }, data: { label: 'Other node' } },
+ createNode({
+ id: 'other',
+ type: 'default',
+ ariaLabel: 'Other node',
+ position: { x: 500, y: 300 },
+ data: { label: 'Other node' },
+ }),
]
- graph.setState({ nodes })
- actions.deleteNodes.mockImplementation(() => graph.setState({ nodes: [] }))
- actions.undo.mockImplementation(() => graph.setState({ nodes }))
- const screen = await render(<Canvas graph={graph} contextMenuType="selection" />)
+ const screen = await setup({ nodes, contextMenuType: 'selection' })
const canvas = screen.getByRole('region', { name: 'app.types.workflow' })
await userEvent.dragAndDrop(canvas, canvas, {
sourcePosition: { x: 300, y: 120 },
@@ -446,32 +376,32 @@ it('returns to canvas undo after a selection context-menu action removes the foc
steps: 5,
})
await canvas.click({ button: 'right', position: { x: 450, y: 220 } })
- await screen.getByRole('menuitem', { name: /common.operation.delete/ }).click()
+ await recordHistory(() =>
+ screen.getByRole('menuitem', { name: /common.operation.delete/ }).click(),
+ )
await expect
.element(screen.getByRole('button', { name: 'Workflow node' }))
.not.toBeInTheDocument()
await expect.element(screen.getByRole('button', { name: 'Other node' })).not.toBeInTheDocument()
await expect.element(canvas).toHaveFocus()
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
- await userEvent.keyboard(`{${mod}>}z{/${mod}}`)
+ expect(graphNodes().map((node) => node.id)).toEqual(['anchor'])
+ await undo()
await expect.element(screen.getByRole('button', { name: 'Workflow node' })).toBeInTheDocument()
await expect.element(screen.getByRole('button', { name: 'Other node' })).toBeInTheDocument()
- expect(actions.undo).toHaveBeenCalledTimes(1)
})
it('keeps focus on an outside input when it dismisses a node dropdown', async () => {
- await page.viewport(1000, 700)
- const graph = createGraph()
- graph.setState({ nodes: initialNodes.map((node) => ({ ...node, type: 'menu' })) })
- const screen = await render(<Canvas graph={graph} />)
+ const screen = await setup({
+ nodes: initialNodes.map((node) => (node.id === 'node' ? { ...node, type: 'menu' } : node)),
+ })
await screen.getByRole('button', { name: 'common.operation.more' }).click()
await expect.element(screen.getByRole('menuitem', { name: /workflow.common.copy/ })).toBeVisible()
- const outsideInput = screen.getByRole('textbox', { name: 'Outside canvas input' })
- await outsideInput.click()
+ const outside = screen.getByRole('textbox', { name: 'Outside canvas input' })
+ await outside.click()
await expect
.element(screen.getByRole('menuitem', { name: /workflow.common.copy/ }))
.not.toBeInTheDocument()
- await expect.element(outsideInput).toHaveFocus()
+ await expect.element(outside).toHaveFocus()
})
function VariableConnectionNode({ id }: NodeProps) {
@@ -489,20 +419,21 @@ const variableConnectionNodes: Node[] = [
id: 'source',
type: 'connection',
position: { x: 100, y: 150 },
- data: { type: BlockEnum.Code, title: 'Source' },
+ data: { type: BlockEnum.Code, title: 'Source', desc: '' },
},
{
id: 'assigner',
type: 'connection',
position: { x: 500, y: 150 },
- data: { type: BlockEnum.VariableAssigner, title: 'Assigner' },
+ data: { type: BlockEnum.VariableAssigner, title: 'Assigner', desc: '' },
},
]
function VariableConnectionCanvas({ onSelect }: { onSelect: (value: string[]) => void }) {
const [showPicker, setShowPicker] = useState(false)
const canvas = useReactFlowStore((state) => state.domNode)
- const handleNodeKeyDown = useNodeKeyboardInteractions(() => {})
+ const { handleNodeSelect } = useNodesInteractions()
+ const handleNodeKeyDown = useNodeKeyboardInteractions(handleNodeSelect)
return (
<div style={{ width: 800, height: 500 }}>
@@ -539,15 +470,12 @@ function VariableConnectionCanvas({ onSelect }: { onSelect: (value: string[]) =>
it('selects a connection variable before node movement handles the focused node keys', async () => {
// Real handle dragging preserves node focus; React capture must not move that node before the picker sees its keys.
await page.viewport(1000, 700)
- const store = createWorkflowStore({})
const onSelect = vi.fn()
const screen = await render(
- <WorkflowContext value={store}>
- <ReactFlowProvider>
- <VariableConnectionCanvas onSelect={onSelect} />
- <textarea aria-label="Outside variable picker" />
- </ReactFlowProvider>
- </WorkflowContext>,
+ <>
+ <VariableConnectionCanvas onSelect={onSelect} />
+ <textarea aria-label="Outside variable picker" />
+ </>,
)
const source = screen.getByTestId('rf__node-source')
@@ -562,11 +490,6 @@ it('selects a connection variable before node movement handles the focused node
const sourcePosition = source.element().getBoundingClientRect()
await userEvent.keyboard('{ArrowDown}')
- await expect
- .poll(() =>
- screen.getByText('second', { exact: true }).element().closest('[data-selected="true"]'),
- )
- .not.toBeNull()
await userEvent.keyboard('{Enter}')
expect(onSelect).toHaveBeenCalledExactlyOnceWith(