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 controls through real owners and stores (#44634)

Stephen Zhou567dc877219e
diff --git a/web/app/components/rag-pipeline/components/panel/test-run/preparation/data-source-options/__tests__/index.spec.tsx b/web/app/components/rag-pipeline/components/panel/test-run/preparation/data-source-options/__tests__/index.spec.tsx
index 8cc0c3da4f2..f542ade4f17 100644
--- a/web/app/components/rag-pipeline/components/panel/test-run/preparation/data-source-options/__tests__/index.spec.tsx
+++ b/web/app/components/rag-pipeline/components/panel/test-run/preparation/data-source-options/__tests__/index.spec.tsx
@@ -1,45 +1,70 @@
-import { render, screen } from '@testing-library/react'
+import type { Datasource } from '../../../types'
+import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { useState } from 'react'
+import { useNodes } from 'reactflow'
+import { createNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { BlockEnum } from '@/app/components/workflow/types'
import DataSourceOptions from '../index'
-const options = [
- { value: 'website', label: 'Website', data: { title: 'Website' } },
- { value: 'drive', label: 'Drive', data: { title: 'Drive' } },
-]
+// Provider icons are independent of datasource discovery and selection.
+vi.mock('@/app/components/workflow/hooks/use-tool-icon', () => ({ useToolIcon: () => undefined }))
-vi.mock('../../hooks', () => ({
- useDatasourceOptions: () => options,
-}))
+const sources = ['Website', 'Drive'].map((title) =>
+ createNode({
+ id: title.toLowerCase(),
+ data: {
+ type: BlockEnum.DataSource,
+ title,
+ plugin_id: 'plugin-1',
+ provider_type: 'online_document',
+ provider_name: 'source',
+ datasource_name: 'source',
+ datasource_label: title,
+ datasource_parameters: {},
+ datasource_configurations: {},
+ },
+ }),
+)
-vi.mock('@/app/components/workflow/hooks/use-tool-icon', () => ({
- useToolIcon: () => undefined,
-}))
+function Selection({ initialId }: { initialId: string }) {
+ const nodes = useNodes()
+ const [selected, setSelected] = useState<Datasource>()
+ // The production preparation panel mounts after its graph is initialized.
+ if (!nodes.length) return null
+ return (
+ <>
+ <DataSourceOptions dataSourceNodeId={selected?.nodeId ?? initialId} onSelect={setSelected} />
+ <output aria-label="Selected datasource">{JSON.stringify(selected)}</output>
+ </>
+ )
+}
+const renderOptions = (initialId = '') =>
+ renderWorkflowFlowComponent(<Selection initialId={initialId} />, {
+ resource: { kind: 'knowledge-pipeline', pipelineId: 'pipeline-1' },
+ nodes: sources,
+ })
+const selected = (): Datasource =>
+ JSON.parse(screen.getByRole('status', { name: 'Selected datasource' }).textContent!)
describe('DataSourceOptions', () => {
- it('selects the first datasource when no selection exists', () => {
- const onSelect = vi.fn()
-
- render(<DataSourceOptions dataSourceNodeId="" onSelect={onSelect} />)
-
- expect(onSelect).toHaveBeenCalledWith({ nodeId: 'website', nodeData: options[0]!.data })
+ it('selects the first canvas datasource when no selection exists', () => {
+ renderOptions()
+ expect(screen.getByRole('radio', { name: 'Website' })).toBeChecked()
+ expect(selected()).toMatchObject({ nodeId: 'website', nodeData: sources[0]!.data })
})
it('selects the datasource chosen by the user', async () => {
const user = userEvent.setup()
- const onSelect = vi.fn()
- const { rerender } = render(
- <DataSourceOptions dataSourceNodeId="website" onSelect={onSelect} />,
- )
-
- await user.tab()
- expect(screen.getByRole('radio', { name: 'Website' })).toHaveFocus()
- expect(screen.getByRole('radio', { name: 'Website' })).toBeChecked()
+ renderOptions('website')
+ const website = screen.getByRole('radio', { name: 'Website' })
+ website.focus()
+ expect(website).toBeChecked()
await user.keyboard('{ArrowRight}')
expect(screen.getByRole('radio', { name: 'Drive' })).toHaveFocus()
-
- expect(onSelect).toHaveBeenCalledWith({ nodeId: 'drive', nodeData: options[1]!.data })
- rerender(<DataSourceOptions dataSourceNodeId="drive" onSelect={onSelect} />)
expect(screen.getByRole('radio', { name: 'Drive' })).toBeChecked()
- expect(screen.getByRole('radio', { name: 'Website' })).not.toBeChecked()
+ expect(website).not.toBeChecked()
+ expect(selected()).toMatchObject({ nodeId: 'drive', nodeData: sources[1]!.data })
})
})
diff --git a/web/app/components/workflow/__tests__/features.spec.tsx b/web/app/components/workflow/__tests__/features.spec.tsx
index 0409bbda120..c5273b08957 100644
--- a/web/app/components/workflow/__tests__/features.spec.tsx
+++ b/web/app/components/workflow/__tests__/features.spec.tsx
@@ -1,3 +1,5 @@
+import type { StartNodeType } from '../nodes/start/types'
+import type { InputVar } from '../types'
import type { PromptVariable } from '@/models/debug'
import { act, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
@@ -10,8 +12,6 @@ import { InputVarType } from '../types'
import { createStartNode } from './fixtures'
import { renderWorkflowFlowComponent } from './workflow-test-env'
-const featureStore = createFeaturesStore()
-const mockHandleAddVariable = vi.fn()
const mockUpdateFeatures = vi.fn()
const mockOpenOpeningModal = vi.fn<
(options: {
@@ -22,9 +22,6 @@ const mockOpenOpeningModal = vi.fn<
}) => void
>()
-vi.mock('../nodes/start/use-config', () => ({
- default: () => ({ handleAddVariable: mockHandleAddVariable }),
-}))
vi.mock('@/service/workflow', () => ({
updateFeatures: (...args: unknown[]) => mockUpdateFeatures(...args),
}))
@@ -55,22 +52,46 @@ vi.mock('@/service/console', async (importOriginal) => {
}
})
+const initialVariables: InputVar[] = [
+ {
+ variable: 'existing_variable',
+ label: 'Existing Variable',
+ type: InputVarType.textInput,
+ required: true,
+ },
+]
const startNode = createStartNode({
id: 'start-node',
data: {
- variables: [{ variable: 'existing_variable', label: 'Existing Variable' }],
+ variables: initialVariables,
},
})
function ReadyFeatures() {
- const nodes = useNodes()
- return nodes.length ? <Features /> : null
+ const nodes = useNodes<StartNodeType>()
+ return nodes.length ? (
+ <>
+ <Features />
+ <output aria-label="Start variables">
+ {JSON.stringify(nodes.find((node) => node.id === 'start-node')?.data.variables)}
+ </output>
+ </>
+ ) : null
}
-function renderFeatures(mode: 'advanced-chat' | 'workflow' = 'advanced-chat') {
+function renderFeatures(
+ mode: 'advanced-chat' | 'workflow' = 'advanced-chat',
+ openingEnabled = false,
+) {
+ const featureStore = createFeaturesStore({
+ features: {
+ ...createFeaturesStore().getState().features,
+ opening: { enabled: openingEnabled, opening_statement: 'Hello' },
+ },
+ })
return renderWorkflowFlowComponent(
<NuqsTestingAdapter>
- <FeaturesContext.Provider value={featureStore}>
+ <FeaturesContext value={featureStore}>
<ReadyFeatures />
- </FeaturesContext.Provider>
+ </FeaturesContext>
</NuqsTestingAdapter>,
{
resource: { kind: 'app', appId: 'app-1', mode },
@@ -82,8 +103,6 @@ function renderFeatures(mode: 'advanced-chat' | 'workflow' = 'advanced-chat') {
}
beforeEach(() => {
- vi.clearAllMocks()
- featureStore.setState({ features: createFeaturesStore().getState().features })
mockUpdateFeatures.mockResolvedValue(undefined)
})
@@ -123,14 +142,8 @@ it('omits chat-only feature controls for a workflow app', () => {
it.each([true, undefined])(
'converts an opening variable with required=%s into a start-node input',
async (required) => {
- featureStore.setState({
- features: {
- ...featureStore.getState().features,
- opening: { enabled: true, opening_statement: 'Hello' },
- },
- })
const user = userEvent.setup()
- renderFeatures()
+ renderFeatures('advanced-chat', true)
await user.hover(screen.getByText('appDebug.feature.conversationOpener.title'))
const edit = screen.getByRole('button', { name: 'appDebug.openingStatement.writeOpener' })
expect(edit).toBeEnabled()
@@ -144,13 +157,18 @@ it.each([true, undefined])(
{ key: 'name', name: 'Name', type: 'string', max_length: 120, required },
]),
)
- expect(mockHandleAddVariable).toHaveBeenCalledExactlyOnceWith({
- variable: 'name',
- label: 'Name',
- type: InputVarType.textInput,
- max_length: 120,
- required: !!required,
- options: [],
- })
+ expect(
+ JSON.parse(screen.getByLabelText('Start variables', { selector: 'output' }).textContent!),
+ ).toEqual([
+ ...initialVariables,
+ {
+ variable: 'name',
+ label: 'Name',
+ type: InputVarType.textInput,
+ max_length: 120,
+ required: !!required,
+ options: [],
+ },
+ ])
},
)
diff --git a/web/app/components/workflow/header/__tests__/env-button.spec.tsx b/web/app/components/workflow/header/__tests__/env-button.spec.tsx
index fad3476dcde..aa26a0c0775 100644
--- a/web/app/components/workflow/header/__tests__/env-button.spec.tsx
+++ b/web/app/components/workflow/header/__tests__/env-button.spec.tsx
@@ -1,21 +1,18 @@
import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { createRagPipelineSliceSlice } from '@/app/components/rag-pipeline/store'
import { renderWorkflowComponent } from '../../__tests__/workflow-test-env'
import EnvButton from '../env-button'
-const mockCloseAllInputFieldPanels = vi.fn()
-
-vi.mock('@/app/components/rag-pipeline/hooks/use-input-field-panel', () => ({
- useInputFieldPanel: () => ({
- closeAllInputFieldPanels: mockCloseAllInputFieldPanels,
- }),
-}))
-
describe('EnvButton', () => {
it('should open the environment panel and close the other panels when clicked', async () => {
const user = userEvent.setup()
const { store } = renderWorkflowComponent(<EnvButton disabled={false} />, {
+ injectWorkflowStoreSliceFn: createRagPipelineSliceSlice,
initialStoreState: {
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: { onSubmit: () => {}, onClose: () => {} },
showChatVariablePanel: true,
showGlobalVariablePanel: true,
showDebugAndPreviewPanel: true,
@@ -28,13 +25,21 @@ describe('EnvButton', () => {
expect(store.getState().showChatVariablePanel).toBe(false)
expect(store.getState().showGlobalVariablePanel).toBe(false)
expect(store.getState().showDebugAndPreviewPanel).toBe(false)
- expect(mockCloseAllInputFieldPanels).toHaveBeenCalledTimes(1)
+ expect(store.getState()).toMatchObject({
+ showInputFieldPanel: false,
+ showInputFieldPreviewPanel: false,
+ inputFieldEditPanelProps: null,
+ })
})
it('should keep the button disabled when the disabled prop is true', async () => {
const user = userEvent.setup()
const { store } = renderWorkflowComponent(<EnvButton disabled />, {
+ injectWorkflowStoreSliceFn: createRagPipelineSliceSlice,
initialStoreState: {
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: { onSubmit: () => {}, onClose: () => {} },
showEnvPanel: false,
},
})
@@ -43,6 +48,10 @@ describe('EnvButton', () => {
expect(screen.getByRole('button', { name: 'workflow.env.envPanelTitle' })).toBeDisabled()
expect(store.getState().showEnvPanel).toBe(false)
- expect(mockCloseAllInputFieldPanels).not.toHaveBeenCalled()
+ expect(store.getState()).toMatchObject({
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: expect.objectContaining({ onSubmit: expect.any(Function) }),
+ })
})
})
diff --git a/web/app/components/workflow/header/__tests__/global-variable-button.spec.tsx b/web/app/components/workflow/header/__tests__/global-variable-button.spec.tsx
index a62f21d1dad..fedbba67ae9 100644
--- a/web/app/components/workflow/header/__tests__/global-variable-button.spec.tsx
+++ b/web/app/components/workflow/header/__tests__/global-variable-button.spec.tsx
@@ -1,21 +1,18 @@
import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { createRagPipelineSliceSlice } from '@/app/components/rag-pipeline/store'
import { renderWorkflowComponent } from '../../__tests__/workflow-test-env'
import GlobalVariableButton from '../global-variable-button'
-const mockCloseAllInputFieldPanels = vi.fn()
-
-vi.mock('@/app/components/rag-pipeline/hooks/use-input-field-panel', () => ({
- useInputFieldPanel: () => ({
- closeAllInputFieldPanels: mockCloseAllInputFieldPanels,
- }),
-}))
-
describe('GlobalVariableButton', () => {
it('should open the global variable panel and close the other panels when clicked', async () => {
const user = userEvent.setup()
const { store } = renderWorkflowComponent(<GlobalVariableButton disabled={false} />, {
+ injectWorkflowStoreSliceFn: createRagPipelineSliceSlice,
initialStoreState: {
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: { onSubmit: () => {}, onClose: () => {} },
showEnvPanel: true,
showChatVariablePanel: true,
showDebugAndPreviewPanel: true,
@@ -28,13 +25,21 @@ describe('GlobalVariableButton', () => {
expect(store.getState().showEnvPanel).toBe(false)
expect(store.getState().showChatVariablePanel).toBe(false)
expect(store.getState().showDebugAndPreviewPanel).toBe(false)
- expect(mockCloseAllInputFieldPanels).toHaveBeenCalledTimes(1)
+ expect(store.getState()).toMatchObject({
+ showInputFieldPanel: false,
+ showInputFieldPreviewPanel: false,
+ inputFieldEditPanelProps: null,
+ })
})
it('should keep the button disabled when the disabled prop is true', async () => {
const user = userEvent.setup()
const { store } = renderWorkflowComponent(<GlobalVariableButton disabled />, {
+ injectWorkflowStoreSliceFn: createRagPipelineSliceSlice,
initialStoreState: {
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: { onSubmit: () => {}, onClose: () => {} },
showGlobalVariablePanel: false,
},
})
@@ -43,6 +48,10 @@ describe('GlobalVariableButton', () => {
expect(screen.getByRole('button', { name: 'workflow.globalVar.title' })).toBeDisabled()
expect(store.getState().showGlobalVariablePanel).toBe(false)
- expect(mockCloseAllInputFieldPanels).not.toHaveBeenCalled()
+ expect(store.getState()).toMatchObject({
+ showInputFieldPanel: true,
+ showInputFieldPreviewPanel: true,
+ inputFieldEditPanelProps: expect.objectContaining({ onSubmit: expect.any(Function) }),
+ })
})
})
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/node-focus.browser.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/node-focus.browser.spec.tsx
index 9fb907920a0..31f4571e956 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/node-focus.browser.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/node-focus.browser.spec.tsx
@@ -1,83 +1,26 @@
-import type { ReactElement } from 'react'
import type { NodeProps } from 'reactflow'
import type { CommonNodeType } from '../../../../types'
import ReactFlow from 'reactflow'
+import { onTestFinished } from 'vite-plus/test'
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 { seedToolProviders } from '@/test/console/tool-providers'
-import { createAppDetailFixture } from '@/test/fixtures/app'
-import { createTestQueryClient } from '@/test/query-client'
-import { EditorResourceScope } from '../../../../editor-resource/provider'
+import { guardUnexpectedFetch } from '@/test/unexpected-fetch'
+import { CanvasNodesCatalogProbe } from '../../../../__tests__/canvas-nodes-catalog-probe'
+import { renderWorkflowBrowserComponent } from '../../../../__tests__/workflow-browser-test-env'
+import { fullWorkflowAccessControl } from '../../../../hooks-store/store'
import { BlockEnum } from '../../../../types'
import NodeControl from '../node-control'
import { NodeSourceHandle, NodeTargetHandle } from '../node-handle'
import 'reactflow/dist/style.css'
-const render = (ui: ReactElement) => {
- const queryClient = createTestQueryClient()
- seedToolProviders(queryClient, {
- builtInTools: [],
- customTools: [],
- workflowTools: [],
- mcpTools: [],
- })
- queryClient.setQueryData(consoleQuery.rag.pipelines.recommendedPlugins.get.queryKey(), {
- installed_recommended_plugins: [],
- uninstalled_recommended_plugins: [],
- })
- 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>,
- )
-}
+beforeEach(() => {
+ onTestFinished(guardUnexpectedFetch())
+})
// Plugin installation is outside node trigger and popup focus ownership.
vi.mock('@/app/components/plugins/install-plugin/install-from-marketplace', () => ({
default: () => null,
}))
-vi.mock('../../../../hooks/use-available-blocks', () => ({
- useAvailableBlocks: () => ({
- availablePrevBlocks: [BlockEnum.Code],
- availableNextBlocks: [BlockEnum.Code],
- }),
-}))
-vi.mock('../../../../hooks/use-nodes-interactions', () => ({
- useNodesInteractions: () => ({ handleNodeAdd: vi.fn(), handleNodeSelect: vi.fn() }),
-}))
-vi.mock('../../../../hooks/use-workflow', () => ({
- useNodesReadOnly: () => ({ nodesReadOnly: false, getNodesReadOnly: () => false }),
-}))
-vi.mock('../../../../hooks/use-nodes-meta-data', () => ({
- useNodeMetaData: () => ({
- isTypeFixed: true,
- isUndeletable: false,
- isSingleton: false,
- description: 'Code',
- author: 'Dify',
- }),
-}))
-vi.mock('@/app/components/workflow/store', () => ({
- useStore: (selector: (state: Record<string, unknown>) => unknown) =>
- selector({ nodes: [], dataSourceList: [], shouldAutoOpenStartNodeSelector: false }),
- useWorkflowStore: () => ({ getState: () => ({}) }),
-}))
-vi.mock('@/app/components/workflow/hooks-store', () => ({
- useHooksStore: (selector: (state: Record<string, unknown>) => unknown) =>
- selector({
- availableNodesMetaData: { nodes: [] },
- accessControl: { canRun: false },
- }),
-}))
vi.mock('@/service/use-plugins', () => ({
useInvalidateCheckInstalled: () => vi.fn(),
useFeaturedToolsRecommendations: () => ({ plugins: [], isLoading: false }),
@@ -106,8 +49,9 @@ function FocusNode({ id, data }: NodeProps<CommonNodeType>) {
const nodeTypes = { focus: FocusNode }
async function renderCanvas() {
await page.viewport(1000, 800)
- return render(
+ return renderWorkflowBrowserComponent(
<>
+ <CanvasNodesCatalogProbe />
<button type="button">Before canvas</button>
<div style={{ width: 800, height: 600 }}>
@@ -126,6 +70,7 @@ async function renderCanvas() {
</div>
<input aria-label="Outside editor" />
</>,
+ { hooksStoreProps: { accessControl: { ...fullWorkflowAccessControl, canRun: false } } },
)
}
diff --git a/web/app/components/workflow/nodes/agent/__tests__/node.spec.tsx b/web/app/components/workflow/nodes/agent/__tests__/node.spec.tsx
index 92f56a4b50d..9674f1ae99c 100644
--- a/web/app/components/workflow/nodes/agent/__tests__/node.spec.tsx
+++ b/web/app/components/workflow/nodes/agent/__tests__/node.spec.tsx
@@ -1,42 +1,27 @@
import type { AgentStrategyParameter } from '@dify/contracts/api/console/workspaces/types.gen'
import type { AgentNodeType } from '../types'
-import type useConfig from '../use-config'
-import { zAgentStrategyParameter } from '@dify/contracts/api/console/workspaces/zod.gen'
+import {
+ zAgentProviderResponse,
+ zAgentStrategyParameter,
+} from '@dify/contracts/api/console/workspaces/zod.gen'
import { screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing'
import { FormTypeEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
+import { createNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { VarKindType } from '@/app/components/workflow/nodes/_base/types'
import { BlockEnum } from '@/app/components/workflow/types'
-import { renderWithConsoleQuery as render } from '@/test/console/query-data'
+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 Node from '../node'
+import { createProvider, createStrategy } from './strategy-fixture'
-const mockUseConfig = vi.hoisted(() => vi.fn())
-const mockModelBar = vi.hoisted(() => vi.fn())
-const mockToolIcon = vi.hoisted(() => vi.fn())
-
-vi.mock('../use-config', () => ({
- __esModule: true,
- default: (...args: unknown[]) => mockUseConfig(...args),
-}))
-
-vi.mock('../components/model-bar', () => ({
- ModelBar: (props: { provider?: string; model?: string; param: string }) => {
- mockModelBar(props)
- return (
- <div>
- {props.provider
- ? `${props.param}:${props.provider}/${props.model}`
- : `${props.param}:empty-model`}
- </div>
- )
- },
-}))
-
-vi.mock('../components/tool-icon', () => ({
- ToolIcon: (props: { providerName: string }) => {
- mockToolIcon(props)
- return <div>{`tool:${props.providerName}`}</div>
- },
+// Plugin installation metadata is external; strategy resolution and node configuration stay real.
+vi.mock('@/service/use-plugins', () => ({
+ useFetchPluginsInMarketPlaceByIds: () => ({ isLoading: false, data: { data: { plugins: [] } } }),
+ useCheckInstalled: () => ({ data: { plugins: [] } }),
}))
const createStrategyParam = (overrides: Partial<AgentStrategyParameter> = {}) =>
@@ -60,6 +45,7 @@ const createData = (overrides: Partial<AgentNodeType> = {}): AgentNodeType => ({
desc: '',
type: BlockEnum.Agent,
output_schema: {},
+ tool_node_version: '2',
agent_strategy_provider_name: 'provider/agent',
agent_strategy_name: 'react',
agent_strategy_label: 'React Agent',
@@ -81,124 +67,73 @@ const createData = (overrides: Partial<AgentNodeType> = {}): AgentNodeType => ({
...overrides,
})
-const createConfigResult = (
- overrides: Partial<ReturnType<typeof useConfig>> = {},
-): ReturnType<typeof useConfig> => ({
- readOnly: false,
- inputs: createData(),
- setInputs: vi.fn(),
- handleVarListChange: vi.fn(),
- handleAddVariable: vi.fn(),
- currentStrategy: {
- identity: {
- author: 'provider',
- name: 'react',
- icon: 'icon',
- label: { en_US: 'React Agent' },
- provider: 'provider/agent',
- },
- parameters: [
- createStrategyParam(),
- createStrategyParam({
- name: 'optionalModel',
- required: false,
- }),
- createStrategyParam({
- name: 'multiToolParam',
- type: FormTypeEnum.multiToolSelector,
- required: false,
- }),
- ],
- description: { en_US: 'agent description' },
- output_schema: {},
- features: [],
- },
- formData: {},
- onFormChange: vi.fn(),
- currentStrategyStatus: {
- plugin: { source: 'marketplace', installed: true },
- isExistInPlugin: false,
- },
- strategyProvider: undefined,
- pluginDetail: {
- declaration: {
- label: { en_US: 'Plugin Marketplace' } as never,
+function renderNode(
+ data: AgentNodeType,
+ parameters = [
+ createStrategyParam(),
+ createStrategyParam({ name: 'optionalModel', required: false }),
+ createStrategyParam({
+ name: 'multiToolParam',
+ type: FormTypeEnum.multiToolSelector,
+ required: false,
+ }),
+ ],
+) {
+ const { queryClient } = createConsoleQueryWrapper()
+ seedModelProviderQueries(queryClient)
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
+ queryClient.setQueryData(consoleQuery.spec.schemaDefinitions.get.queryKey(), [])
+ queryClient.setQueryData(
+ consoleQuery.workspaces.current.agentProvider.byProviderName.get.queryKey({
+ input: { params: { provider_name: 'provider/agent' } },
+ }),
+ zAgentProviderResponse.parse(createProvider([createStrategy({ parameters })])),
+ )
+ return renderWorkflowFlowComponent(
+ <NuqsTestingAdapter>
+ <Node id="agent-node" data={data} />
+ </NuqsTestingAdapter>,
+ {
+ queryClient,
+ nodes: [createNode({ id: 'agent-node', data })],
},
- } as never,
- availableVars: [],
- availableNodesWithParent: [],
- outputSchema: [],
- handleMemoryChange: vi.fn(),
- isChatflow: true,
- ...overrides,
-})
+ )
+}
describe('agent/node', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUseConfig.mockReturnValue(createConfigResult())
- })
-
it('renders the not-set state when no strategy is configured', () => {
- mockUseConfig.mockReturnValue(
- createConfigResult({
- inputs: createData({
- agent_strategy_name: undefined,
- agent_strategy_label: undefined,
- agent_parameters: {},
- }),
- currentStrategy: undefined,
+ renderNode(
+ createData({
+ agent_strategy_name: undefined,
+ agent_strategy_label: undefined,
+ agent_parameters: {},
}),
)
-
- render(<Node id="agent-node" data={createData()} />)
-
expect(screen.getByText('workflowAgent.nodes.agent.strategyNotSet')).toBeInTheDocument()
- expect(mockModelBar).not.toHaveBeenCalled()
- expect(mockToolIcon).not.toHaveBeenCalled()
+ expect(screen.queryByText('workflowAgent.nodes.agent.model')).not.toBeInTheDocument()
+ expect(screen.queryByText('workflowAgent.nodes.agent.toolbox')).not.toBeInTheDocument()
})
- it('renders strategy status, required and selected model bars, and tool icons', async () => {
- const user = userEvent.setup()
- render(<Node id="agent-node" data={createData()} />)
-
+ it('renders required and selected models and the configured tools from the resolved strategy', () => {
+ renderNode(createData())
expect(screen.getByText('React Agent')).toBeInTheDocument()
- await user.hover(screen.getByText('React Agent'))
- expect(
- await screen.findByText(/workflowAgent.nodes.agent.strategyNotInstallTooltip/),
- ).toBeVisible()
- expect(screen.getByText('requiredModel:empty-model')).toBeInTheDocument()
- expect(screen.getByText('optionalModel:openai/gpt-4o')).toBeInTheDocument()
- expect(screen.getByText('tool:author/tool-b')).toBeInTheDocument()
- expect(screen.getByText('tool:author/tool-c')).toBeInTheDocument()
+ expect(screen.getByText('workflow.nodes.agent.modelNotSelected')).toBeInTheDocument()
+ expect(screen.getByText('gpt-4o')).toBeInTheDocument()
+ expect(screen.getByText('workflowAgent.nodes.agent.toolbox')).toBeInTheDocument()
+ expect(screen.getAllByRole('img', { name: 'tool icon' })).toHaveLength(2)
})
- it('skips optional models and empty tool values when no configuration is provided', () => {
- mockUseConfig.mockReturnValue(
- createConfigResult({
- inputs: createData({
- agent_parameters: {},
- }),
- currentStrategy: {
- ...createConfigResult().currentStrategy!,
- parameters: [
- createStrategyParam({
- name: 'optionalModel',
- required: false,
- }),
- ],
- },
- currentStrategyStatus: {
- plugin: { source: 'marketplace', installed: true },
- isExistInPlugin: true,
- },
- }),
- )
-
- render(<Node id="agent-node" data={createData()} />)
-
- expect(mockModelBar).not.toHaveBeenCalled()
- expect(mockToolIcon).not.toHaveBeenCalled()
- expect(screen.queryByText('optionalModel:empty-model')).not.toBeInTheDocument()
+ it('omits unconfigured optional models and tools', () => {
+ renderNode(createData({ agent_parameters: {} }), [
+ createStrategyParam({ name: 'optionalModel', required: false }),
+ ])
+ expect(screen.getByText('React Agent')).toBeInTheDocument()
+ expect(screen.queryByText('workflowAgent.nodes.agent.model')).not.toBeInTheDocument()
+ expect(screen.queryByText('workflowAgent.nodes.agent.toolbox')).not.toBeInTheDocument()
})
})
diff --git a/web/app/components/workflow/nodes/if-else/__tests__/integration.spec.tsx b/web/app/components/workflow/nodes/if-else/__tests__/integration.spec.tsx
index 347aa83b6d3..c4131936f83 100644
--- a/web/app/components/workflow/nodes/if-else/__tests__/integration.spec.tsx
+++ b/web/app/components/workflow/nodes/if-else/__tests__/integration.spec.tsx
@@ -1,69 +1,17 @@
-import type { Var } from '../../../types'
import type { IfElseNodeType } from '../types'
-import type { PanelProps } from '@/types/workflow'
import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useState } from 'react'
+import { useNodes } from 'reactflow'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { VarKindType } from '@/app/components/workflow/nodes/_base/types'
-import { BlockEnum, VarType } from '../../../types'
-import ConditionAdd from '../components/condition-add'
-import ConditionFilesListValue from '../components/condition-files-list-value'
-import ConditionList from '../components/condition-list'
+import { createEdge, createNode, createStartNode } from '../../../__tests__/fixtures'
+import { BlockEnum, InputVarType, VarType } from '../../../types'
import ConditionOperator from '../components/condition-list/condition-operator'
import ConditionNumberInput from '../components/condition-number-input'
-import ConditionValue from '../components/condition-value'
import Node from '../node'
import Panel from '../panel'
import { ComparisonOperator, LogicalOperator } from '../types'
-import useConfig from '../use-config'
-
-vi.mock('react-sortablejs', () => ({
- ReactSortable: ({ children }: { children: React.ReactNode }) => <div>{children}</div>,
-}))
-
-vi.mock(
- '@/app/components/workflow/nodes/_base/components/variable/variable-label',
- async (importOriginal) => ({
- ...(await importOriginal<
- typeof import('@/app/components/workflow/nodes/_base/components/variable/variable-label')
- >()),
- VariableLabelInText: ({ variables }: { variables: string[] }) => (
- <div>{variables.join('.')}</div>
- ),
- VariableLabelInNode: ({ variables }: { variables: string[] }) => (
- <div>{variables.join('.')}</div>
- ),
- }),
-)
-
-vi.mock('@/app/components/workflow/nodes/_base/components/variable-tag', () => ({
- __esModule: true,
- default: ({ valueSelector }: { valueSelector: string[] }) => <div>{valueSelector.join('.')}</div>,
-}))
-
-vi.mock('@/app/components/workflow/nodes/_base/components/node-handle', () => ({
- NodeSourceHandle: ({ handleId }: { handleId: string }) => (
- <div data-testid={`handle-${handleId}`} />
- ),
-}))
-
-vi.mock('@/app/components/workflow/nodes/_base/components/variable/use-match-schema-type', () => ({
- __esModule: true,
- default: () => ({
- schemaTypeDefinitions: [],
- matchSchemaType: () => undefined,
- }),
-}))
-
-vi.mock('../../variable-assigner/hooks', () => ({
- useGetAvailableVars: () => () => [
- {
- variable: ['node-1', 'score'],
- type: VarType.number,
- },
- ],
-}))
vi.mock('@/service/console', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/service/console')>()
@@ -71,6 +19,8 @@ vi.mock('@/service/console', async (importOriginal) => {
return {
...actual,
consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'workspaces.current.defaultModel.get': async () => ({ data: null }),
+ 'spec.schemaDefinitions.get': async () => [],
'workspaces.current.tools.builtin.get': async () => [],
'workspaces.current.tools.api.get': async () => [],
'workspaces.current.tools.workflow.get': async () => [],
@@ -79,12 +29,6 @@ vi.mock('@/service/console', async (importOriginal) => {
}
})
-vi.mock('../use-config', () => ({
- default: vi.fn(),
-}))
-
-const mockUseConfig = vi.mocked(useConfig)
-
const createData = (overrides: Partial<IfElseNodeType> = {}): IfElseNodeType => ({
title: 'If Else',
desc: '',
@@ -109,73 +53,6 @@ const createData = (overrides: Partial<IfElseNodeType> = {}): IfElseNodeType =>
...overrides,
})
-const createConfigResult = (
- overrides: Partial<ReturnType<typeof useConfig>> = {},
-): ReturnType<typeof useConfig> => ({
- readOnly: false,
- inputs: createData(),
- filterVar: () => true,
- filterNumberVar: (varPayload: Var) => varPayload.type === VarType.number,
- handleAddCase: vi.fn(),
- handleRemoveCase: vi.fn(),
- handleSortCase: vi.fn(),
- handleAddCondition: vi.fn(),
- handleUpdateCondition: vi.fn(),
- handleRemoveCondition: vi.fn(),
- handleToggleConditionLogicalOperator: vi.fn(),
- handleAddSubVariableCondition: vi.fn(),
- handleRemoveSubVariableCondition: vi.fn(),
- handleUpdateSubVariableCondition: vi.fn(),
- handleToggleSubVariableConditionLogicalOperator: vi.fn(),
- nodesOutputVars: [
- {
- nodeId: 'node-1',
- title: 'Start Node',
- vars: [
- {
- variable: 'answer',
- type: VarType.string,
- },
- ],
- },
- ],
- availableNodes: [],
- nodesOutputNumberVars: [
- {
- nodeId: 'node-1',
- title: 'Start Node',
- vars: [
- {
- variable: 'score',
- type: VarType.number,
- },
- ],
- },
- ],
- availableNumberNodes: [],
- varsIsVarFileAttribute: {},
- ...overrides,
-})
-
-const baseNodeProps = {
- type: 'custom',
- selected: false,
- zIndex: 1,
- xPos: 0,
- yPos: 0,
- dragging: false,
- isConnectable: true,
-}
-
-const panelProps: PanelProps = {
- getInputVars: vi.fn(() => []),
- toVarInputs: vi.fn(() => []),
- runInputData: {},
- runInputDataRef: { current: {} },
- setRunInputData: vi.fn(),
- runResult: null,
-}
-
const render = (
ui: Parameters<typeof renderWorkflowFlowComponent>[0],
options: Parameters<typeof renderWorkflowFlowComponent>[1] = {},
@@ -190,42 +67,80 @@ const render = (
],
...options,
})
-const renderWithConsoleQuery = render
const numberVariables = [
{ nodeId: 'node-1', title: 'Start Node', vars: [{ variable: 'score', type: VarType.number }] },
]
-describe('if-else path', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUseConfig.mockReturnValue(createConfigResult())
+function LivePanel() {
+ const node = useNodes<IfElseNodeType>().find((node) => node.id === 'if-else-node')
+ if (!node) return null
+ return (
+ <>
+ <Panel
+ id={node.id}
+ data={node.data}
+ panelProps={{
+ getInputVars: () => [],
+ toVarInputs: () => [],
+ runInputData: {},
+ runInputDataRef: { current: {} },
+ setRunInputData: () => {},
+ runResult: null,
+ }}
+ />
+ <output aria-label="Saved cases">{JSON.stringify(node.data.cases)}</output>
+ </>
+ )
+}
+const readCases = (): IfElseNodeType['cases'] =>
+ JSON.parse(screen.getByRole('status', { name: 'Saved cases' }).textContent!)
+const renderPanel = (data: IfElseNodeType) =>
+ render(<LivePanel />, {
+ nodes: [
+ createStartNode({
+ id: 'node-1',
+ data: {
+ variables: [
+ { variable: 'score', label: 'Score', type: InputVarType.number, required: true },
+ { variable: 'answer', label: 'Answer', type: InputVarType.textInput, required: true },
+ ],
+ },
+ }),
+ createNode({ id: 'if-else-node', data }),
+ ],
+ edges: [createEdge({ source: 'node-1', target: 'if-else-node' })],
+ })
+
+const nodeTypes = { ifElse: Node }
+const renderDisplay = (data: IfElseNodeType) =>
+ renderWorkflowFlowComponent(<></>, {
+ nodes: [
+ createStartNode({ id: 'node-1', type: 'input', data: { title: 'Start Node' } }),
+ createNode({ id: 'if-else-node', type: 'ifElse', data }),
+ ],
+ edges: [createEdge({ source: 'node-1', target: 'if-else-node' })],
+ reactFlowProps: { nodeTypes },
})
+describe('if-else path', () => {
describe('Condition controls', () => {
- it('should add a condition variable from the selector', async () => {
+ it('adds a selected upstream variable to the saved case', async () => {
const user = userEvent.setup()
- const onSelectVariable = vi.fn()
-
- render(
- <ConditionAdd
- caseId="case-1"
- variables={numberVariables}
- onSelectVariable={onSelectVariable}
- />,
- {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- },
+ renderPanel(
+ createData({
+ cases: [{ case_id: 'case-1', logical_operator: LogicalOperator.and, conditions: [] }],
+ }),
)
-
await user.click(
screen.getByRole('button', { name: /workflowLogic.nodes.ifElse.addCondition/i }),
)
await user.click(await screen.findByText('score'))
-
- expect(onSelectVariable).toHaveBeenCalledWith('case-1', ['node-1', 'score'], {
- variable: 'score',
- type: VarType.number,
- })
+ expect(readCases()[0]!.conditions).toEqual([
+ expect.objectContaining({
+ variable_selector: ['node-1', 'score'],
+ varType: VarType.number,
+ }),
+ ])
expect(screen.queryByRole('searchbox')).not.toBeInTheDocument()
})
@@ -279,128 +194,90 @@ describe('if-else path', () => {
expect(onSelect.mock.calls[0]?.[0]).toBe(ComparisonOperator.is)
})
- it('should toggle logical operators for a case list with multiple conditions', async () => {
+ it('toggles and saves the logical operator for multiple conditions', async () => {
const user = userEvent.setup()
- const onToggleConditionLogicalOperator = vi.fn()
+ const data = createData()
+ data.cases[0]!.conditions.push({
+ ...data.cases[0]!.conditions[0]!,
+ id: 'condition-2',
+ value: 'world',
+ })
+ renderPanel(data)
+ await user.click(screen.getByText('AND'))
+ expect(screen.getByText('OR')).toBeInTheDocument()
+ expect(readCases()[0]!.logical_operator).toBe(LogicalOperator.or)
+ expect(readCases()[0]!.conditions).toEqual(data.cases[0]!.conditions)
+ })
+ })
- renderWithConsoleQuery(
- <ConditionList
- caseId="case-1"
- caseItem={{
- case_id: 'case-1',
+ describe('Display rendering', () => {
+ it('renders upstream variable names, formatted values, and file sub-conditions', () => {
+ const data = createData()
+ data.cases[0]!.conditions = [
+ { ...data.cases[0]!.conditions[0]!, value: '{{#node-1.answer#}}' },
+ {
+ id: 'condition-files',
+ varType: VarType.arrayFile,
+ variable_selector: ['node-1', 'files'],
+ comparison_operator: ComparisonOperator.contains,
+ value: '',
+ sub_variable_condition: {
+ case_id: 'sub-case',
logical_operator: LogicalOperator.and,
conditions: [
{
- id: 'condition-1',
+ id: 'sub-condition',
+ key: 'name',
varType: VarType.string,
- variable_selector: ['node-1', 'answer'],
comparison_operator: ComparisonOperator.contains,
- value: 'hello',
- },
- {
- id: 'condition-2',
- varType: VarType.string,
- variable_selector: ['node-1', 'answer'],
- comparison_operator: ComparisonOperator.is,
- value: 'world',
+ value: 'report',
},
],
- }}
- nodeId="node-1"
- nodesOutputVars={[]}
- availableNodes={[]}
- numberVariables={[]}
- filterVar={() => true}
- varsIsVarFileAttribute={{}}
- onToggleConditionLogicalOperator={onToggleConditionLogicalOperator}
- />,
- )
-
- await user.click(screen.getByText('AND'))
-
- expect(onToggleConditionLogicalOperator).toHaveBeenCalledWith('case-1')
- })
- })
-
- describe('Display rendering', () => {
- it('should render formatted condition values and file sub-conditions', () => {
- render(
- <div>
- <ConditionValue
- variableSelector={['node-1', 'answer']}
- operator={ComparisonOperator.contains}
- value="{{#node-1.answer#}}"
- />
- <ConditionFilesListValue
- condition={{
- id: 'condition-files',
- varType: VarType.object,
- variable_selector: ['node-1', 'files'],
- comparison_operator: ComparisonOperator.contains,
- value: '',
- sub_variable_condition: {
- case_id: 'sub-case',
- logical_operator: LogicalOperator.or,
- conditions: [
- {
- id: 'sub-condition',
- key: 'name',
- varType: VarType.string,
- comparison_operator: ComparisonOperator.contains,
- value: 'report',
- },
- ],
- },
- }}
- />
- </div>,
- { resource: { kind: 'app', appId: 'app-1', mode: 'workflow' } },
- )
+ },
+ },
+ ]
+ renderDisplay(data)
- expect(screen.getByText('node-1.answer')).toBeInTheDocument()
+ expect(screen.getByText('Start Node')).toBeInTheDocument()
+ expect(screen.getByText('answer')).toBeInTheDocument()
expect(screen.getByText('{{answer}}')).toBeInTheDocument()
- expect(screen.getByText('node-1.files')).toBeInTheDocument()
+ expect(screen.getByText('files')).toBeInTheDocument()
expect(screen.getByText('name')).toBeInTheDocument()
expect(screen.getByText('report')).toBeInTheDocument()
})
- it('should render node cases, missing setup state, and else handles', () => {
- render(
- <Node
- id="if-else-node"
- {...baseNodeProps}
- data={createData({
- cases: [
- {
- case_id: 'case-1',
- logical_operator: LogicalOperator.and,
- conditions: [
- {
- id: 'condition-empty',
- varType: VarType.string,
- variable_selector: [],
- comparison_operator: ComparisonOperator.contains,
- value: '',
- },
- ],
- },
- {
- case_id: 'case-2',
- logical_operator: LogicalOperator.or,
- conditions: [
- {
- id: 'condition-ready',
- varType: VarType.boolean,
- variable_selector: ['node-1', 'passed'],
- comparison_operator: ComparisonOperator.is,
- value: false,
- },
- ],
- },
- ],
- })}
- />,
- { resource: { kind: 'app', appId: 'app-1', mode: 'workflow' } },
+ it('renders case labels, missing setup, false values, and branch handles', () => {
+ const { container } = renderDisplay(
+ createData({
+ cases: [
+ {
+ case_id: 'case-1',
+ logical_operator: LogicalOperator.and,
+ conditions: [
+ {
+ id: 'condition-empty',
+ varType: VarType.string,
+ variable_selector: [],
+ comparison_operator: ComparisonOperator.contains,
+ value: '',
+ },
+ ],
+ },
+ {
+ case_id: 'case-2',
+ logical_operator: LogicalOperator.or,
+ conditions: [
+ {
+ id: 'condition-ready',
+ varType: VarType.boolean,
+ variable_selector: ['node-1', 'passed'],
+ comparison_operator: ComparisonOperator.is,
+ value: false,
+ },
+ ],
+ },
+ ],
+ }),
)
expect(screen.getByText('IF')).toBeInTheDocument()
@@ -408,32 +285,26 @@ describe('if-else path', () => {
expect(screen.getByText('workflowLogic.nodes.ifElse.conditionNotSetup')).toBeInTheDocument()
expect(screen.getByText('False')).toBeInTheDocument()
expect(screen.getByText('ELSE')).toBeInTheDocument()
- expect(screen.getByTestId('handle-case-1')).toBeInTheDocument()
- expect(screen.getByTestId('handle-case-2')).toBeInTheDocument()
- expect(screen.getByTestId('handle-false')).toBeInTheDocument()
+ expect(container.querySelector('[data-handleid="case-1"]')).toBeInTheDocument()
+ expect(container.querySelector('[data-handleid="case-2"]')).toBeInTheDocument()
+ expect(container.querySelector('[data-handleid="false"]')).toBeInTheDocument()
})
})
describe('Panel integration', () => {
it('should add a case from the panel action and render else description', async () => {
const user = userEvent.setup()
- const handleAddCase = vi.fn()
const inputs = createData({ cases: [] })
-
- mockUseConfig.mockReturnValueOnce(
- createConfigResult({
- inputs,
- handleAddCase,
- }),
- )
-
- render(<Panel id="if-else-node" data={inputs} panelProps={panelProps} />, {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ renderPanel(inputs)
await user.click(screen.getByRole('button', { name: /elif/i }))
- expect(handleAddCase).toHaveBeenCalled()
+ expect(readCases()).toEqual([
+ { case_id: expect.any(String), logical_operator: LogicalOperator.and, conditions: [] },
+ ])
+ expect(
+ screen.getByRole('button', { name: /workflowLogic.nodes.ifElse.addCondition/i }),
+ ).toBeInTheDocument()
expect(screen.getByText('workflowLogic.nodes.ifElse.elseDescription')).toBeInTheDocument()
})
})
diff --git a/web/app/components/workflow/nodes/list-operator/__tests__/integration.spec.tsx b/web/app/components/workflow/nodes/list-operator/__tests__/integration.spec.tsx
index 9af6ab720ee..16c7583da7d 100644
--- a/web/app/components/workflow/nodes/list-operator/__tests__/integration.spec.tsx
+++ b/web/app/components/workflow/nodes/list-operator/__tests__/integration.spec.tsx
@@ -1,209 +1,176 @@
-import type { ComponentProps } from 'react'
import type { ListFilterNodeType } from '../types'
-import type { PanelProps } from '@/types/workflow'
-import { fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { useNodes } from 'reactflow'
+import {
+ createEdge,
+ createNode,
+ createStartNode,
+} from '@/app/components/workflow/__tests__/fixtures'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
-import { VarKindType } from '@/app/components/workflow/nodes/_base/types'
import { ComparisonOperator } from '@/app/components/workflow/nodes/if-else/types'
-import { BlockEnum, VarType } from '@/app/components/workflow/types'
-import ExtractInput from '../components/extract-input'
-import LimitConfig from '../components/limit-config'
-import SubVariablePicker from '../components/sub-variable-picker'
+import { BlockEnum, InputVarType, VarType } from '@/app/components/workflow/types'
import Node from '../node'
import Panel from '../panel'
import { OrderBy } from '../types'
-import useConfig from '../use-config'
-vi.mock('@/app/components/workflow/nodes/_base/hooks/use-available-var-list', () => ({
- default: () => ({ availableVars: [], availableNodesWithParent: [] }),
-}))
-
-vi.mock('@/app/components/workflow/nodes/_base/components/input-support-select-var', () => ({
- default: ({
- value,
- onChange,
- placeholder,
- className,
- readOnly,
- onFocusChange,
- }: ComponentProps<
- typeof import('@/app/components/workflow/nodes/_base/components/input-support-select-var').default
- >) => (
- <input
- value={value}
- placeholder={placeholder}
- className={className}
- readOnly={readOnly}
- onFocus={() => onFocusChange?.(true)}
- onBlur={() => onFocusChange?.(false)}
- onChange={(event) => onChange(event.target.value)}
- />
- ),
-}))
-
-vi.mock('@/app/components/workflow/nodes/_base/components/variable/var-reference-picker', () => ({
- default: ({
- onChange,
- }: ComponentProps<
- typeof import('@/app/components/workflow/nodes/_base/components/variable/var-reference-picker').default
- >) => (
- <button type="button" onClick={() => onChange(['node-1', 'items'], VarKindType.variable)}>
- pick-var
- </button>
- ),
-}))
-
-vi.mock('../components/filter-condition', () => ({
- default: ({
- onChange,
- }: ComponentProps<typeof import('../components/filter-condition').default>) => (
- <button
- type="button"
- onClick={() =>
- onChange({ key: 'size', comparison_operator: ComparisonOperator.equal, value: '1' })
- }
- >
- filter-condition
- </button>
- ),
-}))
-
-vi.mock('../use-config', () => ({
- default: vi.fn(),
-}))
-
-const mockUseConfig = vi.mocked(useConfig)
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleResponses } = await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleQuery: withConsoleResponses(actual.consoleQuery, {
+ 'spec.schemaDefinitions.get': async () => [],
+ 'workspaces.current.tools.builtin.get': async () => [],
+ 'workspaces.current.tools.api.get': async () => [],
+ 'workspaces.current.tools.workflow.get': async () => [],
+ 'workspaces.current.tools.mcp.get': async () => [],
+ }),
+ }
+})
const createData = (overrides: Partial<ListFilterNodeType> = {}): ListFilterNodeType => ({
title: 'List Operator',
desc: '',
type: BlockEnum.ListFilter,
- variable: ['node-1', 'items'],
+ variable: ['source', 'items'],
var_type: VarType.arrayNumber,
item_var_type: VarType.number,
filter_by: {
- enabled: true,
- conditions: [{ key: 'size', comparison_operator: ComparisonOperator.equal, value: '1' }],
+ enabled: false,
+ conditions: [{ key: '', comparison_operator: ComparisonOperator.equal, value: '1' }],
},
extract_by: { enabled: true, serial: '1' },
limit: { enabled: true, size: 10 },
- order_by: { enabled: true, key: 'size', value: OrderBy.ASC },
+ order_by: { enabled: true, key: '', value: OrderBy.ASC },
...overrides,
})
-const createConfigResult = (
- overrides: Partial<ReturnType<typeof useConfig>> = {},
-): ReturnType<typeof useConfig> => ({
- readOnly: false,
- inputs: createData(),
- filterVar: vi.fn(() => true),
- varType: VarType.arrayNumber,
- itemVarType: VarType.number,
- itemVarTypeShowName: 'number',
- hasSubVariable: true,
- handleVarChanges: vi.fn(),
- handleFilterEnabledChange: vi.fn(),
- handleFilterChange: vi.fn(),
- handleLimitChange: vi.fn(),
- handleOrderByEnabledChange: vi.fn(),
- handleOrderByKeyChange: vi.fn(),
- handleOrderByTypeChange: vi.fn(() => vi.fn()),
- handleExtractsEnabledChange: vi.fn(),
- handleExtractsChange: vi.fn(),
- ...overrides,
-})
-
-const panelProps: PanelProps = {
- getInputVars: vi.fn(() => []),
- toVarInputs: vi.fn(() => []),
- runInputData: {},
- runInputDataRef: { current: {} },
- setRunInputData: vi.fn(),
- runResult: null,
+function LivePanel() {
+ const node = useNodes<ListFilterNodeType>().find((node) => node.id === 'operator')
+ if (!node) return null
+ return (
+ <>
+ <Panel
+ id={node.id}
+ data={node.data}
+ panelProps={{
+ getInputVars: () => [],
+ toVarInputs: () => [],
+ runInputData: {},
+ runInputDataRef: { current: {} },
+ setRunInputData: () => {},
+ runResult: null,
+ }}
+ />
+ <output aria-label="Saved list configuration">{JSON.stringify(node.data)}</output>
+ </>
+ )
}
-
-const renderPanel = (data: ListFilterNodeType = createData()) =>
- render(<Panel id="node-1" data={data} panelProps={panelProps} />)
-
-describe('list-operator path', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUseConfig.mockReturnValue(createConfigResult())
+function renderPanel(data = createData(), readonly = false) {
+ return renderWorkflowFlowComponent(<LivePanel />, {
+ nodes: [
+ data.var_type === VarType.arrayFile
+ ? createStartNode({
+ id: 'source',
+ data: {
+ variables: [
+ {
+ variable: 'items',
+ label: 'Items',
+ type: InputVarType.multiFiles,
+ required: true,
+ },
+ ],
+ },
+ })
+ : createNode({
+ id: 'source',
+ data: {
+ type: BlockEnum.Code,
+ title: 'Source',
+ outputs: { items: { type: data.var_type } },
+ variables: [],
+ code: '',
+ code_language: 'python3',
+ },
+ }),
+ createNode({ id: 'operator', data }),
+ ],
+ edges: [createEdge({ source: 'source', target: 'operator' })],
+ initialStoreState: { canvasReadOnly: readonly },
})
+}
+const saved = (): ListFilterNodeType =>
+ JSON.parse(screen.getByRole('status', { name: 'Saved list configuration' }).textContent!)
- // The list-operator path should expose extract, limit, ordering, and node variable previews.
- describe('Path Integration', () => {
- it('should update the extract input', async () => {
- const user = userEvent.setup()
- const onChange = vi.fn()
- const { rerender } = render(
- <ExtractInput nodeId="node-1" readOnly={false} value="1" onChange={onChange} />,
- )
-
- fireEvent.change(screen.getByDisplayValue('1'), { target: { value: '2' } })
- expect(onChange).toHaveBeenCalledWith('2')
- onChange.mockClear()
-
- rerender(<ExtractInput nodeId="node-1" readOnly value="" onChange={onChange} />)
-
- await user.type(screen.getByRole('textbox'), '3')
- expect(screen.getByRole('textbox')).toHaveValue('')
- expect(onChange).not.toHaveBeenCalled()
- })
-
- it('should change the selected sub variable', async () => {
- const user = userEvent.setup()
- const onChange = vi.fn()
- const { unmount } = render(<SubVariablePicker value="size" onChange={onChange} />)
-
- await user.click(screen.getByRole('combobox'))
- await user.click(screen.getByRole('option', { name: 'name' }))
-
- await waitFor(() => {
- expect(onChange).toHaveBeenCalledWith('name')
- })
-
- unmount()
- render(<SubVariablePicker value="" onChange={onChange} />)
-
- expect(screen.getByText('common.placeholder.select')).toBeInTheDocument()
- })
-
- it('should toggle limit and update the size slider', async () => {
- const user = userEvent.setup()
- const onChange = vi.fn()
- const { rerender } = render(
- <LimitConfig readonly={false} config={{ enabled: true, size: 10 }} onChange={onChange} />,
- )
-
- screen.getByRole('slider', { name: 'workflowLogic.nodes.listFilter.limit' }).focus()
- await user.keyboard('{ArrowRight}')
+// The panel's switches currently have no accessible names. Their visible order is
+// Filter, Extract, Limit, Order; use the role list until those controls are labelled.
+const switches = () => screen.getAllByRole('switch')
- expect(onChange).toHaveBeenCalledWith({ enabled: true, size: 11 })
+// The rich-text input has no accessible name yet. Distinguish its public
+// contenteditable contract from the variable picker's read-only text input.
+const queryExtractEditor = () =>
+ screen.queryAllByRole('textbox').find((element) => element.hasAttribute('contenteditable')) ??
+ null
+const extractEditor = () => queryExtractEditor()!
- rerender(
- <LimitConfig readonly={false} config={{ enabled: false, size: 10 }} onChange={onChange} />,
- )
+describe('list-operator path', () => {
+ it('saves extract input edits to the canvas', async () => {
+ const user = userEvent.setup()
+ renderPanel()
+ const input = extractEditor()
+ await user.type(input, '2')
+ expect(input).toHaveTextContent('12')
+ expect(saved().extract_by).toEqual({ enabled: true, serial: '12' })
+ })
- expect(screen.queryByRole('slider')).not.toBeInTheDocument()
- await user.click(screen.getByRole('switch'))
- expect(onChange).toHaveBeenCalledWith({ enabled: true, size: 10 })
- })
+ it('saves the chosen file sub-variable for ordering', async () => {
+ const user = userEvent.setup()
+ renderPanel(
+ createData({
+ var_type: VarType.arrayFile,
+ item_var_type: VarType.file,
+ extract_by: { enabled: false, serial: '' },
+ order_by: { enabled: true, key: 'size', value: OrderBy.ASC },
+ }),
+ )
+ await user.click(screen.getByRole('combobox'))
+ await user.click(screen.getByRole('option', { name: 'name' }))
+ expect(saved().order_by).toEqual({ enabled: true, key: 'name', value: OrderBy.ASC })
+ expect(screen.getByRole('combobox')).toHaveTextContent('name')
+ })
- it('prevents changing the limit in readonly mode', async () => {
- const user = userEvent.setup()
- const onChange = vi.fn()
- render(<LimitConfig readonly config={{ enabled: true, size: 10 }} onChange={onChange} />)
+ it('saves the limit size and retains it across disabling and enabling the limit', async () => {
+ const user = userEvent.setup()
+ renderPanel()
+ screen.getByRole('slider', { name: 'workflowLogic.nodes.listFilter.limit' }).focus()
+ await user.keyboard('{ArrowRight}')
+ expect(saved().limit).toEqual({ enabled: true, size: 11 })
+ await user.click(switches()[2]!)
+ expect(screen.queryByRole('slider')).not.toBeInTheDocument()
+ expect(saved().limit).toEqual({ enabled: false, size: 11 })
+ await user.click(switches()[2]!)
+ expect(screen.getByRole('spinbutton')).toHaveValue(11)
+ expect(saved().limit).toEqual({ enabled: true, size: 11 })
+ })
- expect(screen.getByRole('spinbutton')).toBeDisabled()
- await user.click(screen.getByRole('switch'))
- await user.type(screen.getByRole('spinbutton'), '2')
- expect(onChange).not.toHaveBeenCalled()
- })
+ it('keeps extract and limit data unchanged in read-only mode', async () => {
+ const user = userEvent.setup()
+ const data = createData()
+ renderPanel(data, true)
+ expect(screen.getByRole('spinbutton')).toBeDisabled()
+ for (const toggle of switches()) expect(toggle).toHaveAttribute('aria-disabled', 'true')
+ await user.click(switches()[2]!)
+ await user.type(screen.getByRole('spinbutton'), '2')
+ expect(saved()).toMatchObject(data)
+ expect(extractEditor()).toHaveAttribute('contenteditable', 'false')
+ })
- it('should render the selected input variable in the node preview', () => {
- renderWorkflowFlowComponent(<Node id="node-2" data={createData()} />, {
+ it('should render the selected input variable in the node preview', () => {
+ renderWorkflowFlowComponent(
+ <Node id="node-2" data={createData({ variable: ['node-1', 'items'] })} />,
+ {
nodes: [
{
id: 'node-1',
@@ -212,67 +179,49 @@ describe('list-operator path', () => {
},
],
edges: [],
- })
-
- expect(screen.getByText('Answer')).toBeInTheDocument()
- expect(screen.getByText('items')).toBeInTheDocument()
- })
-
- it('should resolve system variables through the start node and return null without a variable', () => {
- const { rerender } = renderWorkflowFlowComponent(
- <Node id="node-2" data={createData({ variable: ['sys', 'files'] })} />,
- {
- nodes: [
- {
- id: 'start',
- position: { x: 0, y: 0 },
- data: { type: BlockEnum.Start, title: 'Start', desc: '' },
- },
- ],
- edges: [],
- },
- )
-
- expect(screen.getByText('Start')).toBeInTheDocument()
-
- rerender(<Node id="node-2" data={createData({ variable: [] })} />)
+ },
+ )
- expect(screen.queryByText('workflow.nodes.listFilter.inputVar')).not.toBeInTheDocument()
- expect(screen.queryByText('Start')).not.toBeInTheDocument()
- })
-
- it('should hide disabled sections and render order controls without sub variables', () => {
- mockUseConfig.mockReturnValue(
- createConfigResult({
- inputs: createData({
- variable: [],
- filter_by: { enabled: false, conditions: [] },
- extract_by: { enabled: false, serial: '' },
- order_by: { enabled: false, key: '', value: OrderBy.ASC },
- }),
- hasSubVariable: false,
- }),
- )
+ expect(screen.getByText('Answer')).toBeInTheDocument()
+ expect(screen.getByText('items')).toBeInTheDocument()
+ })
- const { rerender } = renderPanel()
+ it('should resolve system variables through the start node and return null without a variable', () => {
+ const { rerender } = renderWorkflowFlowComponent(
+ <Node id="node-2" data={createData({ variable: ['sys', 'files'] })} />,
+ {
+ nodes: [
+ {
+ id: 'start',
+ position: { x: 0, y: 0 },
+ data: { type: BlockEnum.Start, title: 'Start', desc: '' },
+ },
+ ],
+ edges: [],
+ },
+ )
- expect(screen.queryByText('filter-condition')).not.toBeInTheDocument()
- expect(screen.queryByDisplayValue('1')).not.toBeInTheDocument()
- expect(screen.queryByText('workflowLogic.nodes.listFilter.asc')).not.toBeInTheDocument()
+ expect(screen.getByText('Start')).toBeInTheDocument()
- mockUseConfig.mockReturnValue(
- createConfigResult({
- inputs: createData({
- order_by: { enabled: true, key: '', value: OrderBy.ASC },
- }),
- hasSubVariable: false,
- }),
- )
+ rerender(<Node id="node-2" data={createData({ variable: [] })} />)
- rerender(<Panel id="node-1" data={createData()} panelProps={panelProps} />)
+ expect(screen.queryByText('workflow.nodes.listFilter.inputVar')).not.toBeInTheDocument()
+ expect(screen.queryByText('Start')).not.toBeInTheDocument()
+ })
- expect(screen.getByText('workflowLogic.nodes.listFilter.asc')).toBeInTheDocument()
- expect(screen.queryByText('common.placeholder.select')).not.toBeInTheDocument()
- })
+ it('hides disabled controls and enables numeric ordering without sub-variable controls', async () => {
+ const user = userEvent.setup()
+ renderPanel(
+ createData({
+ extract_by: { enabled: false, serial: '' },
+ order_by: { enabled: false, key: '', value: OrderBy.ASC },
+ }),
+ )
+ expect(queryExtractEditor()).not.toBeInTheDocument()
+ expect(screen.queryByText('workflowLogic.nodes.listFilter.asc')).not.toBeInTheDocument()
+ await user.click(switches()[3]!)
+ expect(screen.getByText('workflowLogic.nodes.listFilter.asc')).toBeInTheDocument()
+ expect(screen.queryByRole('combobox')).not.toBeInTheDocument()
+ expect(saved().order_by).toEqual({ enabled: true, key: '', value: OrderBy.ASC })
})
})
diff --git a/web/app/components/workflow/operator/__tests__/add-block.spec.tsx b/web/app/components/workflow/operator/__tests__/add-block.spec.tsx
index 62883d53e6a..753573e2c62 100644
--- a/web/app/components/workflow/operator/__tests__/add-block.spec.tsx
+++ b/web/app/components/workflow/operator/__tests__/add-block.spec.tsx
@@ -1,54 +1,11 @@
-import type { NodeDefault } from '../../types'
-import { screen, waitFor } from '@testing-library/react'
+import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
+import { CanvasNodesCatalogProbe } from '../../__tests__/canvas-nodes-catalog-probe'
import { createNode } from '../../__tests__/fixtures'
import { renderWorkflowFlowComponent } from '../../__tests__/workflow-test-env'
-import { BlockClassification } from '../../block-selector/types'
import { BlockEnum } from '../../types'
import AddBlock from '../add-block'
-const { mockHandlePaneContextmenuCancel } = vi.hoisted(() => ({
- mockHandlePaneContextmenuCancel: vi.fn(),
-}))
-
-let mockNodesReadOnly = false
-let chatflowMode = false
-
-const answerBlock: NodeDefault = {
- metaData: {
- classification: BlockClassification.Default,
- sort: 0,
- type: BlockEnum.Answer,
- title: 'Answer',
- author: 'Dify',
- description: 'Answer description',
- },
- defaultValue: {
- title: 'Answer',
- desc: '',
- type: BlockEnum.Answer,
- },
- checkValid: () => ({ isValid: true }),
-}
-
-vi.mock('../../hooks/use-available-blocks', () => ({
- useAvailableBlocks: () => ({
- availableNextBlocks: [BlockEnum.Answer],
- }),
-}))
-
-vi.mock('../../hooks/use-nodes-meta-data', () => ({
- useNodesMetaData: () => ({
- nodesMap: { [BlockEnum.Answer]: answerBlock },
- }),
-}))
-
-vi.mock('../../hooks/use-panel-interactions', () => ({
- usePanelInteractions: () => ({
- handlePaneContextmenuCancel: mockHandlePaneContextmenuCancel,
- }),
-}))
-
vi.mock('@/service/use-plugins', () => ({
useFeaturedToolsRecommendations: () => ({ plugins: [], isLoading: false }),
useFeaturedTriggersRecommendations: () => ({ plugins: [], isLoading: false }),
@@ -77,44 +34,38 @@ vi.mock('@/app/components/plugins/marketplace/query', () => ({
useMarketplacePlugins: () => ({ data: undefined }),
}))
-const renderWithReactFlow = (nodes: Array<ReturnType<typeof createNode>> = []) =>
- renderWorkflowFlowComponent(<AddBlock />, {
- resource: { kind: 'app', appId: 'app-1', mode: chatflowMode ? 'advanced-chat' : 'workflow' },
- nodes,
- edges: [],
- initialStoreState: { canvasReadOnly: mockNodesReadOnly },
- hooksStoreProps: { availableNodesMetaData: { nodes: [answerBlock] } },
- })
+const renderWithReactFlow = (nodes: Array<ReturnType<typeof createNode>> = [], readonly = false) =>
+ renderWorkflowFlowComponent(
+ <>
+ <CanvasNodesCatalogProbe />
+ <AddBlock />
+ </>,
+ {
+ resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' },
+ nodes,
+ edges: [],
+ initialStoreState: { canvasReadOnly: readonly, contextMenuTarget: { type: 'panel' } },
+ },
+ )
describe('AddBlock', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockNodesReadOnly = false
- chatflowMode = false
- })
-
it('opens the real selector and exposes its open state', async () => {
const user = userEvent.setup()
renderWithReactFlow()
const trigger = screen.getByRole('button', { name: 'workflow.common.addBlock' })
- expect(trigger).not.toHaveAttribute('data-block-selector-open')
-
- await user.hover(trigger)
- await waitFor(() => expect(trigger).toHaveAttribute('data-popup-open', ''))
- expect(trigger).not.toHaveAttribute('data-block-selector-open')
+ expect(trigger).toHaveAttribute('aria-expanded', 'false')
await user.click(trigger)
- expect(trigger).toHaveAttribute('data-block-selector-open', '')
+ expect(trigger).toHaveAttribute('aria-expanded', 'true')
expect(screen.getByRole('dialog', { name: 'workflow.common.addBlock' })).toBeInTheDocument()
- expect(screen.getByRole('button', { name: 'Answer' })).toBeInTheDocument()
+ expect(screen.getByRole('button', { name: 'workflow.blocks.answer' })).toBeInTheDocument()
})
it('keeps the disabled trigger focusable without opening the selector', async () => {
const user = userEvent.setup()
- mockNodesReadOnly = true
- renderWithReactFlow()
+ renderWithReactFlow([], true)
const trigger = screen.getByRole('button', { name: 'workflow.common.addBlock' })
expect(trigger).toHaveAttribute('aria-disabled', 'true')
@@ -129,13 +80,16 @@ describe('AddBlock', () => {
it('closes the selector through the real trigger and cancels the pane menu', async () => {
const user = userEvent.setup()
- renderWithReactFlow()
+ const { store } = renderWithReactFlow()
const trigger = screen.getByRole('button', { name: 'workflow.common.addBlock' })
await user.click(trigger)
await user.click(trigger)
- expect(mockHandlePaneContextmenuCancel).toHaveBeenCalledTimes(1)
+ expect(
+ screen.queryByRole('dialog', { name: 'workflow.common.addBlock' }),
+ ).not.toBeInTheDocument()
+ expect(store.getState().contextMenuTarget).toBeUndefined()
})
it('creates a candidate node after selecting a real block option', async () => {
@@ -146,7 +100,7 @@ describe('AddBlock', () => {
])
await user.click(screen.getByRole('button', { name: 'workflow.common.addBlock' }))
- await user.click(screen.getByRole('button', { name: 'Answer' }))
+ await user.click(screen.getByRole('button', { name: 'workflow.blocks.answer' }))
expect(store.getState()).toMatchObject({
candidateNode: expect.objectContaining({
diff --git a/web/app/components/workflow/panel/comments-panel/__tests__/index.spec.tsx b/web/app/components/workflow/panel/comments-panel/__tests__/index.spec.tsx
index 56a3abd889b..6565015b5aa 100644
--- a/web/app/components/workflow/panel/comments-panel/__tests__/index.spec.tsx
+++ b/web/app/components/workflow/panel/comments-panel/__tests__/index.spec.tsx
@@ -1,15 +1,16 @@
import type { WorkflowCommentBasic } from '@dify/contracts/api/console/apps/types.gen'
-import { screen } from '@testing-library/react'
+import { screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { renderWorkflowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import CommentsPanel from '../index'
-const selectComment = vi.fn()
-const resolveComment = vi.fn()
function setup() {
- const { queryClient } = createConsoleQueryWrapper({ accountProfile: { id: 'user-1' } })
- return renderWorkflowComponent(<CommentsPanel />, {
+ const { queryClient } = createConsoleQueryWrapper({
+ accountProfile: { id: 'user-1' },
+ systemFeatures: { enable_collaboration_mode: true },
+ })
+ return renderWorkflowFlowComponent(<CommentsPanel />, {
queryClient,
initialStoreState: { showResolvedComments: true },
})
@@ -46,20 +47,33 @@ const commentFixtures: WorkflowCommentBasic[] = [
},
]
-// Comment retrieval and canvas positioning are independent of the panel's filters.
-vi.mock('../../../hooks/use-workflow-comment', () => ({
- useWorkflowComment: () => ({
- comments: commentFixtures,
- loading: false,
- handleCommentIconClick: selectComment,
- handleCommentResolve: resolveComment,
- }),
+vi.mock('@/app/components/workflow/collaboration/core/collaboration-manager', () => ({
+ collaborationManager: { onCommentsUpdate: () => () => {} },
}))
+vi.mock('@/service/console', async (importOriginal) => {
+ const actual = await importOriginal<typeof import('@/service/console')>()
+ const { withConsoleClientResponses } = await import('@/test/console/service-responses')
+ return {
+ ...actual,
+ consoleClient: withConsoleClientResponses(actual.consoleClient, {
+ 'apps.byAppId.workflow.comments.get': async () => ({ data: commentFixtures }),
+ 'apps.byAppId.workflow.comments.byCommentId.get': async ({
+ params,
+ }: {
+ params: { app_id: string; comment_id: string }
+ }) => ({
+ ...commentFixtures.find((comment) => comment.id === params.comment_id)!,
+ replies: [],
+ mentions: [],
+ }),
+ }),
+ }
+})
it('filters to the current user and routes the chosen thread', async () => {
const user = userEvent.setup()
- setup()
- expect(screen.getByText('others resolved thread')).toBeInTheDocument()
+ const { store } = setup()
+ expect(await screen.findByText('others resolved thread')).toBeInTheDocument()
await user.click(
screen.getByRole('button', { name: 'workflowComments.comments.aria.filterComments' }),
)
@@ -68,12 +82,18 @@ it('filters to the current user and routes the chosen thread', async () => {
)
expect(screen.queryByText('others resolved thread')).not.toBeInTheDocument()
await user.click(screen.getByText('my open thread'))
- expect(selectComment).toHaveBeenCalledExactlyOnceWith(expect.objectContaining({ id: 'c-1' }))
+ await waitFor(() => expect(store.getState().activeCommentDetailLoading).toBe(false))
+ expect(store.getState()).toMatchObject({
+ activeCommentId: 'c-1',
+ activeCommentDetail: { id: 'c-1', content: 'my open thread', replies: [], mentions: [] },
+ commentDetailCache: { 'c-1': { id: 'c-1' } },
+ })
})
it('hides and restores resolved comments when the filter changes', async () => {
const user = userEvent.setup()
const { store } = setup()
+ await screen.findByText('others resolved thread')
await user.click(
screen.getByRole('button', { name: 'workflowComments.comments.aria.filterComments' }),
)
diff --git a/web/test/unexpected-fetch.ts b/web/test/unexpected-fetch.ts
new file mode 100644
index 00000000000..88de974e66e
--- /dev/null
+++ b/web/test/unexpected-fetch.ts
@@ -0,0 +1,17 @@
+import { expect, vi } from 'vite-plus/test'
+
+/** Call explicitly during test setup and register the returned teardown with onTestFinished. */
+export function guardUnexpectedFetch() {
+ const unexpectedFetch = vi
+ .fn<typeof fetch>()
+ .mockRejectedValue(new Error('Unexpected network request'))
+ vi.stubGlobal('fetch', unexpectedFetch)
+
+ return () => {
+ try {
+ expect(unexpectedFetch).not.toHaveBeenCalled()
+ } finally {
+ vi.unstubAllGlobals()
+ }
+ }
+}