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 variable assignment with real workflow stores (#44349)

Stephen Zhou3bef0b2bba8f
diff --git a/web/app/components/workflow/__tests__/canvas-nodes-catalog-probe.tsx b/web/app/components/workflow/__tests__/canvas-nodes-catalog-probe.tsx
new file mode 100644
index 00000000000..bec1a878897
--- /dev/null
+++ b/web/app/components/workflow/__tests__/canvas-nodes-catalog-probe.tsx
@@ -0,0 +1,29 @@
+import type { AvailableNodesMetaData } from '../hooks-store'
+import { use, useLayoutEffect } from 'react'
+import { useNodes } from 'reactflow'
+import { HooksStoreContext } from '../hooks-store'
+import { useWorkflowNodeCatalog } from '../node-catalog'
+
+export const CANVAS_NODES_STATUS_NAME = 'Canvas nodes'
+
+// Publishes the real block catalog so node actions know which canvas nodes are copyable.
+export function CanvasNodesCatalogProbe() {
+ const catalog = useWorkflowNodeCatalog()
+ const hooksStore = use(HooksStoreContext)!
+ useLayoutEffect(() => {
+ const nodesMap = catalog.nodesMap as NonNullable<AvailableNodesMetaData['nodesMap']>
+ hooksStore.setState({
+ availableNodesMetaData: {
+ nodes: catalog.nodes.map((node) => nodesMap[node.metaData.type]),
+ nodesMap,
+ },
+ })
+ }, [catalog, hooksStore])
+ const nodes = useNodes<{ selected?: boolean }>()
+
+ return (
+ <output aria-label={CANVAS_NODES_STATUS_NAME}>
+ {nodes.map((node) => `${node.id}${node.data.selected ? '*' : ''}`).join(',')}
+ </output>
+ )
+}
diff --git a/web/app/components/workflow/node-actions-menu/__tests__/context-menu-content.spec.tsx b/web/app/components/workflow/node-actions-menu/__tests__/context-menu-content.spec.tsx
index 3535dc94c53..e0601ec54a4 100644
--- a/web/app/components/workflow/node-actions-menu/__tests__/context-menu-content.spec.tsx
+++ b/web/app/components/workflow/node-actions-menu/__tests__/context-menu-content.spec.tsx
@@ -1,18 +1,17 @@
-import type { AvailableNodesMetaData } from '../../hooks-store'
import { ContextMenu } from '@langgenius/dify-ui/context-menu'
import { detectPlatform } from '@tanstack/react-hotkeys'
import { fireEvent, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { use, useLayoutEffect } from 'react'
-import { useNodes } from 'reactflow'
+import {
+ CANVAS_NODES_STATUS_NAME,
+ CanvasNodesCatalogProbe,
+} from '@/app/components/workflow/__tests__/canvas-nodes-catalog-probe'
import { createNode } from '@/app/components/workflow/__tests__/fixtures'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { BlockEnum } from '@/app/components/workflow/types'
import { seedModelProviderQueries } from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
-import { HooksStoreContext } from '../../hooks-store'
import { useNodeMetaData } from '../../hooks/use-nodes-meta-data'
-import { useWorkflowNodeCatalog } from '../../node-catalog'
import { NodeActionsContextMenuContent } from '../context-menu-content'
// Node metadata comes from the per-app block registry, which has its own suite.
@@ -42,41 +41,27 @@ vi.mock('../change-block-popup', () => ({
const mockUseNodeMetaData = vi.mocked(useNodeMetaData)
-// Publishes the real block catalog so copy/duplicate know which nodes are copyable.
-const CanvasNodes = () => {
- const catalog = useWorkflowNodeCatalog()
- const hooksStore = use(HooksStoreContext)!
- useLayoutEffect(() => {
- const nodesMap = catalog.nodesMap as NonNullable<AvailableNodesMetaData['nodesMap']>
- hooksStore.setState({
- availableNodesMetaData: {
- nodes: catalog.nodes.map((node) => nodesMap[node.metaData.type]),
- nodesMap,
- },
- })
- }, [catalog, hooksStore])
- const nodes = useNodes()
- return <output aria-label="Canvas nodes">{nodes.map((node) => node.id).join(',')}</output>
-}
-
const canvasNodeIds = () =>
- (screen.getByRole('status', { hidden: true }).textContent ?? '').split(',').filter(Boolean)
+ (screen.getByLabelText(CANVAS_NODES_STATUS_NAME, { selector: 'output' }).textContent ?? '')
+ .split(',')
+ .filter(Boolean)
const renderContextMenu = (readOnly = false) => {
const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '0.6.0' })
seedModelProviderQueries(queryClient)
+ const onClose = vi.fn()
- return renderWorkflowFlowComponent(
+ const renderResult = renderWorkflowFlowComponent(
<>
<ContextMenu open>
<NodeActionsContextMenuContent
id="node-1"
data={{ type: BlockEnum.Code, title: 'Code Node', desc: '' }}
- onClose={() => undefined}
+ onClose={onClose}
showHelpLink={false}
/>
</ContextMenu>
- <CanvasNodes />
+ <CanvasNodesCatalogProbe />
</>,
{
initialStoreState: { canvasReadOnly: readOnly },
@@ -92,6 +77,8 @@ const renderContextMenu = (readOnly = false) => {
queryClient,
},
)
+
+ return { ...renderResult, onClose }
}
describe('NodeActionsContextMenuContent', () => {
@@ -112,10 +99,11 @@ describe('NodeActionsContextMenuContent', () => {
{ name: /workflow\.common\.duplicate/, clipboard: undefined, nodeCount: 2 },
])('runs the $name context-menu item on click', async ({ name, clipboard, nodeCount }) => {
const user = userEvent.setup()
- const { store } = renderContextMenu()
+ const { onClose, store } = renderContextMenu()
await user.click(screen.getByRole('menuitem', { name }))
+ expect(onClose).toHaveBeenCalledTimes(1)
if (clipboard)
expect(store.getState().clipboardElements.map((node) => node.id)).toEqual(clipboard)
await waitFor(() => expect(canvasNodeIds()).toHaveLength(nodeCount))
diff --git a/web/app/components/workflow/node-actions-menu/__tests__/index.spec.tsx b/web/app/components/workflow/node-actions-menu/__tests__/index.spec.tsx
index 5af85929de6..0f91f0dd8c1 100644
--- a/web/app/components/workflow/node-actions-menu/__tests__/index.spec.tsx
+++ b/web/app/components/workflow/node-actions-menu/__tests__/index.spec.tsx
@@ -1,17 +1,16 @@
-import type { AvailableNodesMetaData } from '../../hooks-store'
import { detectPlatform } from '@tanstack/react-hotkeys'
import { fireEvent, screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { use, useLayoutEffect } from 'react'
-import { useNodes } from 'reactflow'
+import {
+ CANVAS_NODES_STATUS_NAME,
+ CanvasNodesCatalogProbe,
+} from '@/app/components/workflow/__tests__/canvas-nodes-catalog-probe'
import { createNode } from '@/app/components/workflow/__tests__/fixtures'
import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { BlockEnum } from '@/app/components/workflow/types'
import { seedModelProviderQueries } from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
-import { HooksStoreContext } from '../../hooks-store'
import { useNodeMetaData } from '../../hooks/use-nodes-meta-data'
-import { useWorkflowNodeCatalog } from '../../node-catalog'
import { NodeActionsDropdown } from '../index'
// Node metadata comes from the per-app block registry, which has its own suite.
@@ -41,27 +40,7 @@ vi.mock('../change-block-popup', () => ({
const mockUseNodeMetaData = vi.mocked(useNodeMetaData)
-// Publishes the real block catalog so copy/duplicate know which nodes are copyable.
-const CanvasNodes = () => {
- const catalog = useWorkflowNodeCatalog()
- const hooksStore = use(HooksStoreContext)!
- useLayoutEffect(() => {
- const nodesMap = catalog.nodesMap as NonNullable<AvailableNodesMetaData['nodesMap']>
- hooksStore.setState({
- availableNodesMetaData: {
- nodes: catalog.nodes.map((node) => nodesMap[node.metaData.type]),
- nodesMap,
- },
- })
- }, [catalog, hooksStore])
- const nodes = useNodes<{ selected?: boolean }>()
- return (
- <output aria-label="Canvas nodes">
- {nodes.map((node) => `${node.id}${node.data.selected ? '*' : ''}`).join(',')}
- </output>
- )
-}
-const canvasNodes = () => screen.getByRole('status', { name: 'Canvas nodes' }).textContent
+const canvasNodes = () => screen.getByRole('status', { name: CANVAS_NODES_STATUS_NAME }).textContent
const renderComponent = (
showHelpLink: boolean = true,
onOpenChange?: (open: boolean) => void,
@@ -82,7 +61,7 @@ const renderComponent = (
onOpenChange={onOpenChange}
showHelpLink={showHelpLink}
/>
- <CanvasNodes />
+ <CanvasNodesCatalogProbe />
</>,
{
initialStoreState: { canvasReadOnly: readOnly },
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/add-variable-popup-with-position.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/add-variable-popup-with-position.spec.tsx
index 12c2d9be62b..2a9010e811b 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/add-variable-popup-with-position.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/add-variable-popup-with-position.spec.tsx
@@ -1,23 +1,13 @@
-import { screen } from '@testing-library/react'
+import type { VariableAssignerNodeType } from '../../../variable-assigner/types'
+import type { Node } from '@/app/components/workflow/types'
+import { screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import ReactFlow, { ReactFlowProvider } from 'reactflow'
-import { renderEditor as render } from '@/app/components/workflow/editor-resource/__tests__/render'
+import { useEdges, useNodes } from 'reactflow'
+import { createEdge, createNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { BlockEnum, VarType } from '@/app/components/workflow/types'
import AddVariablePopupWithPosition from '../add-variable-popup-with-position'
-const assignVariable = vi.fn()
-const workflowState = {
- showAssignVariablePopup: {
- nodeId: 'source',
- nodeData: { type: BlockEnum.TemplateTransform },
- variableAssignerNodeId: 'assigner',
- variableAssignerNodeData: { output_type: VarType.string },
- variableAssignerNodeHandleId: 'target',
- x: 0,
- y: 0,
- },
- setShowAssignVariablePopup: vi.fn(),
-}
const availableVars = [
{
nodeId: 'source',
@@ -29,49 +19,164 @@ const availableVars = [
},
]
-vi.mock('../../../../store', () => ({
- useStore: (selector: (state: typeof workflowState) => unknown) => selector(workflowState),
-}))
-vi.mock('../../../../hooks/use-node-data-update', () => ({
- useNodeDataUpdate: () => ({ handleNodeDataUpdate: vi.fn() }),
-}))
-vi.mock('../../../../hooks/use-workflow', () => ({
+// AP14: branch traversal and variable collection are heavy collaborators with their own suites.
+vi.mock('../../../../hooks/use-workflow', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('../../../../hooks/use-workflow')>()),
useWorkflow: () => ({ getBeforeNodesInSameBranch: () => [] }),
}))
-vi.mock('../../../../hooks/use-workflow-variables', () => ({
+vi.mock('../../../../hooks/use-workflow-variables', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('../../../../hooks/use-workflow-variables')>()),
useWorkflowVariables: () => ({ getNodeAvailableVars: () => availableVars }),
}))
-vi.mock('../../../variable-assigner/hooks', () => ({
- useVariableAssigner: () => ({ handleAddVariableInAddVariablePopupWithPosition: assignVariable }),
-}))
-it('selects a connection variable from the owning canvas and preserves its focus', async () => {
- const user = userEvent.setup()
- render(
+type CanvasNode = Pick<Node, 'id' | 'data'>
+type CanvasEdge = { id: string; source: string; target: string }
+
+function CanvasStateProbe() {
+ const nodes = useNodes()
+ const edges = useEdges()
+
+ return (
+ <>
+ <output aria-label="Canvas node state">
+ {JSON.stringify(nodes.map(({ id, data }) => ({ id, data })))}
+ </output>
+ <output aria-label="Canvas edge state">
+ {JSON.stringify(edges.map(({ id, source, target }) => ({ id, source, target })))}
+ </output>
+ </>
+ )
+}
+
+const readCanvasNodes = () =>
+ JSON.parse(
+ screen.getByRole('status', { name: 'Canvas node state' }).textContent ?? '[]',
+ ) as CanvasNode[]
+const readCanvasEdges = () =>
+ JSON.parse(
+ screen.getByRole('status', { name: 'Canvas edge state' }).textContent ?? '[]',
+ ) as CanvasEdge[]
+const readNodeData = (id: string) => readCanvasNodes().find((node) => node.id === id)!.data
+
+const renderPopup = () => {
+ const sourceData = {
+ title: 'Source',
+ desc: '',
+ type: BlockEnum.TemplateTransform,
+ _showAddVariablePopup: true,
+ _holdAddVariablePopup: false,
+ }
+ const assignerData: VariableAssignerNodeType = {
+ title: 'Assigner',
+ desc: '',
+ type: BlockEnum.VariableAssigner,
+ variables: [],
+ output_type: VarType.string,
+ advanced_settings: {
+ group_enabled: false,
+ groups: [],
+ },
+ _showAddVariablePopup: true,
+ _holdAddVariablePopup: false,
+ }
+ const edge = createEdge({
+ id: 'source-to-assigner',
+ source: 'source',
+ target: 'assigner',
+ sourceHandle: 'source',
+ targetHandle: 'target',
+ data: {
+ sourceType: BlockEnum.TemplateTransform,
+ targetType: BlockEnum.VariableAssigner,
+ },
+ })
+
+ return renderWorkflowFlowComponent(
<>
<input aria-label="Outside" />
- <ReactFlowProvider>
- <ReactFlow aria-label="Workflow canvas" tabIndex={0} nodes={[]} edges={[]}>
- <AddVariablePopupWithPosition nodeId="source" nodeData={{}} />
- </ReactFlow>
- </ReactFlowProvider>
+ <AddVariablePopupWithPosition nodeId="source" nodeData={sourceData} />
+ <CanvasStateProbe />
</>,
- { resource: { kind: 'app', appId: 'app-1', mode: 'workflow' } },
+ {
+ initialStoreState: {
+ showAssignVariablePopup: {
+ nodeId: 'source',
+ nodeData: sourceData,
+ variableAssignerNodeId: 'assigner',
+ variableAssignerNodeData: assignerData,
+ variableAssignerNodeHandleId: 'target',
+ x: 0,
+ y: 0,
+ },
+ },
+ nodes: [
+ createNode({ id: 'source', width: 240, height: 80, data: sourceData }),
+ createNode({ id: 'assigner', width: 240, height: 80, data: assignerData }),
+ ],
+ edges: [edge],
+ reactFlowProps: { 'aria-label': 'Workflow canvas', tabIndex: 0 },
+ resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
+ },
)
+}
+
+const expectSelectedVariable = async (variable: string) => {
+ await waitFor(() => {
+ expect(readNodeData('assigner')).toMatchObject({
+ variables: [['source', variable]],
+ output_type: VarType.string,
+ _showAddVariablePopup: false,
+ _holdAddVariablePopup: false,
+ })
+ })
+}
+
+it('selects a connection variable from the owning canvas and preserves its focus', async () => {
+ const user = userEvent.setup()
+ const { store } = renderPopup()
screen.getByRole('textbox', { name: 'Outside' }).focus()
await user.keyboard('{ArrowDown}{Enter}')
- expect(assignVariable).not.toHaveBeenCalled()
+ expect(readNodeData('assigner')).toMatchObject({ variables: [] })
+ expect(store.getState().showAssignVariablePopup).toBeDefined()
+
const canvas = screen.getByLabelText('Workflow canvas')
canvas.focus()
await user.keyboard('{ArrowDown}{Enter}')
- expect(assignVariable).toHaveBeenCalledWith(
- 'source',
- 'assigner',
- 'target',
- ['source', 'second'],
- expect.objectContaining({ variable: 'second' }),
- )
+ await expectSelectedVariable('second')
expect(canvas).toHaveFocus()
})
+
+it('selects a connection variable by mouse and updates the real canvas state', async () => {
+ const user = userEvent.setup()
+ const { store } = renderPopup()
+
+ await user.click(screen.getByText('first'))
+
+ await expectSelectedVariable('first')
+ expect(readNodeData('source')).toMatchObject({
+ _showAddVariablePopup: false,
+ _holdAddVariablePopup: false,
+ })
+ expect(readCanvasEdges()).toEqual([
+ { id: 'source-to-assigner', source: 'source', target: 'assigner' },
+ ])
+ expect(store.getState().showAssignVariablePopup).toBeUndefined()
+ expect(
+ screen.queryByText('workflowLogic.nodes.variableAssigner.setAssignVariable'),
+ ).not.toBeInTheDocument()
+})
+
+it('clears the popup and source-node flag when clicking away', async () => {
+ const user = userEvent.setup()
+ const { store } = renderPopup()
+
+ await user.click(screen.getByRole('textbox', { name: 'Outside' }))
+
+ await waitFor(() => {
+ expect(readNodeData('source')).toMatchObject({ _showAddVariablePopup: false })
+ })
+ expect(readNodeData('assigner')).toMatchObject({ variables: [] })
+ expect(store.getState().showAssignVariablePopup).toBeUndefined()
+})
diff --git a/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks/handle-send.spec.ts b/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks/handle-send.spec.ts
index dd562bded07..5b2f587aac1 100644
--- a/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks/handle-send.spec.ts
+++ b/web/app/components/workflow/panel/debug-and-preview/__tests__/hooks/handle-send.spec.ts
@@ -1,19 +1,10 @@
import type { useWorkflowRun } from '@/app/components/workflow/hooks/use-workflow-run'
-import type { VisionFile } from '@/types/app'
import { act } from '@testing-library/react'
-import { renderWorkflowFlowHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { renderWorkflowCanvasHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
import { fullWorkflowAccessControl } from '@/app/components/workflow/hooks-store/store'
import { useChat } from '../../hooks'
-type WorkflowRunCallbacks = NonNullable<
- Parameters<ReturnType<typeof useWorkflowRun>['handleRun']>[1]
->
-
-type WorkflowRunParams = Omit<Parameters<ReturnType<typeof useChat>['handleSend']>[0], 'files'> & {
- files?: VisionFile[]
-}
-
-const mockHandleRun = vi.fn<(params: WorkflowRunParams, callbacks: WorkflowRunCallbacks) => void>()
+const handleRun = vi.fn<ReturnType<typeof useWorkflowRun>['handleRun']>()
const mockNotify = vi.fn()
vi.mock('@/app/notifications', async (importOriginal) => {
const actual = await importOriginal<typeof import('@/app/notifications')>()
@@ -27,33 +18,33 @@ vi.mock('@/service/use-workflow', async (importOriginal) => ({
...(await importOriginal<typeof import('@/service/use-workflow')>()),
useInvalidateAllLastRun: () => mockInvalidAllLastRun,
}))
-const mockFetchInspectVars = vi.fn()
-
-vi.mock('../../../../hooks/use-workflow-run', () => ({
- useWorkflowRun: () => ({ handleRun: mockHandleRun }),
-}))
-
-vi.mock('../../../../hooks/use-set-workflow-vars-with-value', () => ({
- useSetWorkflowVarsWithValue: () => ({ fetchInspectVars: mockFetchInspectVars }),
-}))
+const fetchInspectVars = vi.fn(async () => undefined)
+
+const renderChat = (canRun = true) =>
+ renderHook(() => useChat({}), {
+ hooksStoreProps: {
+ accessControl: { ...fullWorkflowAccessControl, canRun },
+ fetchInspectVars,
+ handleRun,
+ },
+ resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
+ })
describe('useChat – handleSend', () => {
beforeEach(() => {
vi.clearAllMocks()
- mockHandleRun.mockReset()
+ handleRun.mockReset()
})
it('should call handleRun with processed params', () => {
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result } = renderChat()
act(() => {
result.current.handleSend({ query: 'hello', inputs: {} }, {})
})
- expect(mockHandleRun).toHaveBeenCalledTimes(1)
- const [bodyParams] = mockHandleRun.mock.calls[0]!
+ expect(handleRun).toHaveBeenCalledTimes(1)
+ const [bodyParams] = handleRun.mock.calls[0]!
expect(bodyParams.query).toBe('hello')
expect(result.current.isResponding).toBe(true)
expect(result.current.chatList).toEqual([
@@ -63,10 +54,7 @@ describe('useChat – handleSend', () => {
})
it('should return false and skip handleRun when test/run permission is missing', () => {
- const { result } = renderHook(() => useChat({}), {
- hooksStoreProps: { accessControl: { ...fullWorkflowAccessControl, canRun: false } },
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result } = renderChat(false)
let returned: unknown
act(() => {
@@ -74,16 +62,15 @@ describe('useChat – handleSend', () => {
})
expect(returned).toBe(false)
- expect(mockHandleRun).not.toHaveBeenCalled()
+ expect(handleRun).not.toHaveBeenCalled()
+ expect(result.current.isResponding).toBe(false)
expect(result.current.chatList).toHaveLength(0)
})
it('should show notification and return false when already responding', () => {
- mockHandleRun.mockImplementation(() => {})
+ handleRun.mockImplementation(() => {})
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result } = renderChat()
act(() => {
result.current.handleSend({ query: 'first' }, {})
@@ -95,12 +82,15 @@ describe('useChat – handleSend', () => {
})
expect(mockNotify).toHaveBeenCalledWith('appDebug.errorMessage.waitForResponse')
+ expect(handleRun).toHaveBeenCalledTimes(1)
+ expect(result.current.chatList).toEqual([
+ expect.objectContaining({ content: 'first', isAnswer: false }),
+ expect.objectContaining({ content: '', isAnswer: true }),
+ ])
})
it('should strip url from local_file transfer method files', () => {
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result } = renderChat()
act(() => {
result.current.handleSend(
@@ -135,31 +125,30 @@ describe('useChat – handleSend', () => {
)
})
- expect(mockHandleRun).toHaveBeenCalledTimes(1)
- const [bodyParams] = mockHandleRun.mock.calls[0]!
- const localFile = bodyParams.files!.find((f) => f.transfer_method === 'local_file')
- const remoteFile = bodyParams.files!.find((f) => f.transfer_method === 'remote_url')
+ expect(handleRun).toHaveBeenCalledTimes(1)
+ const [bodyParams] = handleRun.mock.calls[0]!
+ const files = bodyParams.files as { transfer_method: string; url: string }[]
+ const localFile = files.find((file) => file.transfer_method === 'local_file')
+ const remoteFile = files.find((file) => file.transfer_method === 'remote_url')
expect(localFile!.url).toBe('')
expect(remoteFile!.url).toBe('https://example.com/img.png')
})
it('should abort previous workflowEventsAbortController before sending', () => {
const controller = new AbortController()
- mockHandleRun.mockImplementation((_params: unknown, callbacks: WorkflowRunCallbacks) => {
- callbacks.getAbortController!(controller)
- callbacks.onCompleted!(false)
+ handleRun.mockImplementation((_params, callbacks) => {
+ callbacks!.getAbortController!(controller)
+ callbacks!.onCompleted!(false)
})
- const { result } = renderHook(() => useChat({}), {
- resource: { kind: 'app', appId: 'app-1', mode: 'workflow' },
- })
+ const { result } = renderChat()
act(() => {
result.current.handleSend({ query: 'first' }, {})
})
- mockHandleRun.mockImplementation((_params: unknown, callbacks: WorkflowRunCallbacks) => {
- callbacks.getAbortController!(new AbortController())
+ handleRun.mockImplementation((_params, callbacks) => {
+ callbacks!.getAbortController!(new AbortController())
})
act(() => {