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 preview, canvas and form test doubles (#44637)

Stephen Zhouf6bb28b6ad2e
diff --git a/web/app/components/rag-pipeline/components/panel/input-field/editor/form/__tests__/hooks.spec.ts b/web/app/components/rag-pipeline/components/panel/input-field/editor/form/__tests__/hooks.spec.ts
index 15cf3ea608b..f1a89f92614 100644
--- a/web/app/components/rag-pipeline/components/panel/input-field/editor/form/__tests__/hooks.spec.ts
+++ b/web/app/components/rag-pipeline/components/panel/input-field/editor/form/__tests__/hooks.spec.ts
@@ -1,197 +1,76 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-import { DEFAULT_FILE_UPLOAD_SETTING } from '@/app/components/workflow/constants'
+import type { FormData } from '../types'
+import { screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+import { createElement } from 'react'
import { PipelineInputVarType } from '@/models/pipeline'
-import { renderHookWithConsoleQuery as renderHook } from '@/test/console/query-data'
-import { useConfigurations, useHiddenConfigurations, useHiddenFieldNames } from '../hooks'
-
-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, {
- 'files.upload.get': async () => ({
- image_file_size_limit: 10,
- file_size_limit: 15,
- audio_file_size_limit: 50,
- video_file_size_limit: 100,
- }),
- }),
+import { consoleQuery } from '@/service/console'
+import { createConsoleQueryClient, renderWithConsoleQuery } from '@/test/console/query-data'
+import { createFileUploadConfigFixture } from '@/test/fixtures/file-upload-config'
+import { TransferMethod } from '@/types/app'
+import InputFieldForm from '../index'
+
+const renderForm = () => {
+ const initialData: FormData = {
+ type: PipelineInputVarType.paragraph,
+ variable: 'existingVar',
+ label: 'Display name',
+ required: true,
+ maxLength: 48,
+ allowedFileUploadMethods: [TransferMethod.remote_url],
+ allowedTypesAndExtensions: { allowedFileTypes: [], allowedFileExtensions: ['.pdf'] },
}
+ const queryClient = createConsoleQueryClient()
+ queryClient.setQueryData(
+ consoleQuery.files.upload.get.queryKey(),
+ createFileUploadConfigFixture(),
+ )
+ const onSubmit = vi.fn()
+ renderWithConsoleQuery(
+ createElement(InputFieldForm, {
+ initialData,
+ supportFile: true,
+ onSubmit,
+ onCancel: vi.fn(),
+ }),
+ { queryClient },
+ )
+ return { user: userEvent.setup(), onSubmit, initialData }
+}
+
+// File-type defaults are already exercised through form submission in index.spec.tsx.
+// Keep the remaining listener behavior at the real form's input/submission boundary.
+it('preserves configured upload options when switching to text', async () => {
+ const { user, onSubmit, initialData } = renderForm()
+ await user.click(screen.getByRole('combobox', { name: /variableConfig.fieldType/ }))
+ await user.click(screen.getByRole('option', { name: /variableConfig.text-input/ }))
+ await user.click(screen.getByRole('button', { name: /operation.submit/ }))
+
+ await waitFor(() =>
+ expect(onSubmit).toHaveBeenCalledExactlyOnceWith(
+ {
+ ...initialData,
+ type: PipelineInputVarType.textInput,
+ },
+ undefined,
+ ),
+ )
})
-describe('useHiddenFieldNames', () => {
- afterEach(() => {
- vi.clearAllMocks()
- })
-
- it('should return field names for paragraph type', () => {
- const { result } = renderHook(() => useHiddenFieldNames(PipelineInputVarType.paragraph))
-
- expect(result.current).toContain('variableconfig.defaultvalue')
- expect(result.current).toContain('variableconfig.placeholder')
- expect(result.current).toContain('variableconfig.tooltips')
- })
-
- it('should return field names for number type including unit', () => {
- const { result } = renderHook(() => useHiddenFieldNames(PipelineInputVarType.number))
-
- expect(result.current).toContain('appdebug.variableconfig.defaultvalue')
- expect(result.current).toContain('appdebug.variableconfig.unit')
- expect(result.current).toContain('appdebug.variableconfig.placeholder')
- expect(result.current).toContain('appdebug.variableconfig.tooltips')
- })
-
- it('should return field names for select type', () => {
- const { result } = renderHook(() => useHiddenFieldNames(PipelineInputVarType.select))
-
- expect(result.current).toContain('appdebug.variableconfig.defaultvalue')
- expect(result.current).toContain('appdebug.variableconfig.tooltips')
- })
-
- it('should return field names for singleFile type', () => {
- const { result } = renderHook(() => useHiddenFieldNames(PipelineInputVarType.singleFile))
-
- expect(result.current).toContain('appdebug.variableconfig.uploadmethod')
- expect(result.current).toContain('appdebug.variableconfig.tooltips')
- })
-
- it('should return field names for checkbox type', () => {
- const { result } = renderHook(() => useHiddenFieldNames(PipelineInputVarType.checkbox))
-
- expect(result.current).toContain('appdebug.variableconfig.startchecked')
- expect(result.current).toContain('appdebug.variableconfig.tooltips')
- })
-})
-
-describe('useConfigurations', () => {
- let mockGetFieldValue: ReturnType<typeof vi.fn<(...args: unknown[]) => unknown>>
- let mockSetFieldValue: ReturnType<typeof vi.fn<(...args: unknown[]) => void>>
-
- beforeEach(() => {
- mockGetFieldValue = vi.fn()
- mockSetFieldValue = vi.fn()
- vi.clearAllMocks()
- })
-
- it('should set file defaults when type changes to singleFile', () => {
- const { result } = renderHook(() =>
- useConfigurations({
- getFieldValue: mockGetFieldValue,
- setFieldValue: mockSetFieldValue,
- supportFile: true,
- }),
- )
-
- const typeConfig = result.current.find((c) => c.variable === 'type')
- typeConfig?.listeners?.onChange?.({
- value: PipelineInputVarType.singleFile,
- fieldApi: {} as never,
- })
-
- expect(mockSetFieldValue).toHaveBeenCalledWith(
- 'allowedFileUploadMethods',
- DEFAULT_FILE_UPLOAD_SETTING.allowed_file_upload_methods,
- )
- expect(mockSetFieldValue).toHaveBeenCalledWith('allowedTypesAndExtensions', {
- allowedFileTypes: DEFAULT_FILE_UPLOAD_SETTING.allowed_file_types,
- allowedFileExtensions: DEFAULT_FILE_UPLOAD_SETTING.allowed_file_extensions,
- })
- })
-
- it('should set maxLength when type changes to multiFiles', () => {
- const { result } = renderHook(() =>
- useConfigurations({
- getFieldValue: mockGetFieldValue,
- setFieldValue: mockSetFieldValue,
- supportFile: true,
- }),
- )
-
- const typeConfig = result.current.find((c) => c.variable === 'type')
- typeConfig?.listeners?.onChange?.({
- value: PipelineInputVarType.multiFiles,
- fieldApi: {} as never,
- })
-
- expect(mockSetFieldValue).toHaveBeenCalledWith(
- 'maxLength',
- DEFAULT_FILE_UPLOAD_SETTING.max_length,
- )
- })
-
- it('should not set file defaults when type changes to text', () => {
- const { result } = renderHook(() =>
- useConfigurations({
- getFieldValue: mockGetFieldValue,
- setFieldValue: mockSetFieldValue,
- supportFile: true,
- }),
- )
-
- const typeConfig = result.current.find((c) => c.variable === 'type')
- typeConfig?.listeners?.onChange?.({
- value: PipelineInputVarType.textInput,
- fieldApi: {} as never,
- })
-
- expect(mockSetFieldValue).not.toHaveBeenCalled()
- })
-
- it('should reset label to variable name when display name is cleared', () => {
- mockGetFieldValue.mockReturnValue('existingVar')
-
- const { result } = renderHook(() =>
- useConfigurations({
- getFieldValue: mockGetFieldValue,
- setFieldValue: mockSetFieldValue,
- supportFile: true,
- }),
- )
-
- const labelConfig = result.current.find((c) => c.variable === 'label')
- labelConfig?.listeners?.onBlur?.({ value: '', fieldApi: {} as never })
-
- expect(mockSetFieldValue).toHaveBeenCalledWith('label', 'existingVar')
- })
-})
-
-describe('useHiddenConfigurations', () => {
- afterEach(() => {
- vi.clearAllMocks()
- })
-
- it('should include tooltips configuration for all types', () => {
- const { result } = renderHook(() => useHiddenConfigurations({ options: undefined }))
-
- const tooltipsConfig = result.current.find((c) => c.variable === 'tooltips')
- expect(tooltipsConfig).toBeDefined()
- expect(tooltipsConfig?.showConditions).toEqual([])
- })
-
- it('should build select options from provided options', () => {
- const { result } = renderHook(() => useHiddenConfigurations({ options: ['opt1', 'opt2'] }))
-
- const selectDefault = result.current.find(
- (c) =>
- c.variable === 'default' &&
- c.showConditions?.some((sc) => sc.value === PipelineInputVarType.select),
- )
- expect(selectDefault?.options).toEqual([
- { value: '', label: 'appDebug.variableConfig.noDefaultSelected' },
- { value: 'opt1', label: 'opt1' },
- { value: 'opt2', label: 'opt2' },
- ])
- })
-
- it('should return empty options when options prop is undefined', () => {
- const { result } = renderHook(() => useHiddenConfigurations({ options: undefined }))
-
- const selectDefault = result.current.find(
- (c) =>
- c.variable === 'default' &&
- c.showConditions?.some((sc) => sc.value === PipelineInputVarType.select),
- )
- expect(selectDefault?.options).toEqual([])
- })
+it('restores the variable name after clearing and leaving the display name field', async () => {
+ const { user, onSubmit, initialData } = renderForm()
+ const displayName = screen.getByRole('textbox', { name: /variableConfig.displayName/ })
+ await user.clear(displayName)
+ await user.tab()
+
+ expect(displayName).toHaveValue('existingVar')
+ await user.click(screen.getByRole('button', { name: /operation.submit/ }))
+ await waitFor(() =>
+ expect(onSubmit).toHaveBeenCalledExactlyOnceWith(
+ {
+ ...initialData,
+ label: 'existingVar',
+ },
+ undefined,
+ ),
+ )
})
diff --git a/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.ts b/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.ts
deleted file mode 100644
index 206f2dc4499..00000000000
--- a/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import type { SnippetWorkflow } from '@/types/snippet'
-import { act, waitFor } from '@testing-library/react'
-import { createNode } from '@/app/components/workflow/__tests__/fixtures'
-import { renderWorkflowHook } from '@/app/components/workflow/__tests__/workflow-test-env'
-import { PipelineInputVarType } from '@/models/pipeline'
-import { createDeferred } from '@/test/deferred'
-import { useSnippetDraftStore } from '../../draft-store'
-import { useSnippetRefreshDraft } from '../use-snippet-refresh-draft'
-
-const mockFetchSnippetDraftWorkflow = vi.fn()
-const mockHandleUpdateWorkflowCanvas = vi.fn()
-vi.mock('@/service/use-snippet-workflows', () => ({
- fetchSnippetDraftWorkflow: (...args: unknown[]) => mockFetchSnippetDraftWorkflow(...args),
-}))
-vi.mock('@/app/components/workflow/hooks/use-workflow-update', () => ({
- useWorkflowUpdate: () => ({ handleUpdateWorkflowCanvas: mockHandleUpdateWorkflowCanvas }),
-}))
-
-const initialFields = [
- {
- type: PipelineInputVarType.textInput,
- label: 'Query',
- variable: 'query',
- required: true,
- },
-]
-
-beforeEach(() => {
- vi.resetAllMocks()
- useSnippetDraftStore.getState().reset()
- useSnippetDraftStore.getState().setInputFields(initialFields)
-})
-
-it('keeps syncing until the draft arrives, then replaces canvas, fields and version state', async () => {
- const pending = createDeferred<SnippetWorkflow>()
- const draft: SnippetWorkflow = {
- id: 'draft-1',
- graph: {
- nodes: [createNode({ id: 'node-1' })],
- edges: [],
- viewport: { x: 10, y: 20, zoom: 1.2 },
- },
- features: {},
- input_fields: [],
- hash: 'draft-hash',
- created_at: 1_712_300_000,
- updated_at: 1_712_345_678,
- }
- mockFetchSnippetDraftWorkflow.mockReturnValueOnce(pending.promise)
- const onSuccess = vi.fn()
- const { result, store } = renderWorkflowHook(() => useSnippetRefreshDraft('snippet-1'), {
- resource: { kind: 'snippet', snippetId: 'snippet-1' },
- })
-
- act(() => result.current.handleRefreshWorkflowDraft(onSuccess))
- expect(store.getState().isSyncingWorkflowDraft).toBe(true)
- expect(onSuccess).not.toHaveBeenCalled()
- expect(useSnippetDraftStore.getState().inputFields).toEqual(initialFields)
- await act(async () => pending.resolve(draft))
-
- await waitFor(() => expect(store.getState().isSyncingWorkflowDraft).toBe(false))
- expect(mockFetchSnippetDraftWorkflow).toHaveBeenCalledExactlyOnceWith('snippet-1')
- expect(mockHandleUpdateWorkflowCanvas).toHaveBeenCalledExactlyOnceWith(draft.graph)
- expect(useSnippetDraftStore.getState().inputFields).toEqual([])
- expect(store.getState().syncWorkflowDraftHash).toBe('draft-hash')
- expect(store.getState().draftUpdatedAt).toBe(1_712_345_678_000)
- expect(onSuccess).toHaveBeenCalledExactlyOnceWith(draft)
-})
-
-it('finishes without replacing editor state when no draft exists yet', async () => {
- mockFetchSnippetDraftWorkflow.mockResolvedValueOnce(undefined)
- const onSuccess = vi.fn()
- const { result, store } = renderWorkflowHook(() => useSnippetRefreshDraft('snippet-1'), {
- resource: { kind: 'snippet', snippetId: 'snippet-1' },
- initialStoreState: { syncWorkflowDraftHash: 'existing-hash', draftUpdatedAt: 1000 },
- })
- act(() => result.current.handleRefreshWorkflowDraft(onSuccess))
- await waitFor(() => expect(store.getState().isSyncingWorkflowDraft).toBe(false))
-
- expect(mockHandleUpdateWorkflowCanvas).not.toHaveBeenCalled()
- expect(useSnippetDraftStore.getState().inputFields).toEqual(initialFields)
- expect(store.getState().syncWorkflowDraftHash).toBe('existing-hash')
- expect(store.getState().draftUpdatedAt).toBe(1000)
- expect(onSuccess).not.toHaveBeenCalled()
-})
diff --git a/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.tsx b/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.tsx
new file mode 100644
index 00000000000..45b1a65b09d
--- /dev/null
+++ b/web/app/components/snippets/hooks/__tests__/use-snippet-refresh-draft.spec.tsx
@@ -0,0 +1,175 @@
+import type { ReactFlowInstance } from 'reactflow'
+import type { SnippetWorkflow } from '@/types/snippet'
+import { act, screen, waitFor } from '@testing-library/react'
+import { NuqsTestingAdapter } from 'nuqs/adapters/testing'
+import { createRef, useImperativeHandle } from 'react'
+import { useReactFlow } from 'reactflow'
+import WorkflowWithDefaultContext, { Workflow } from '@/app/components/workflow'
+import { createStartNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { EventEmitterContextProvider } from '@/context/event-emitter-provider'
+import { PipelineInputVarType } from '@/models/pipeline'
+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 { createDeferred } from '@/test/deferred'
+import { useSnippetDraftStore } from '../../draft-store'
+import { useSnippetRefreshDraft } from '../use-snippet-refresh-draft'
+
+const { fetchDraft } = vi.hoisted(() => ({
+ fetchDraft: vi.fn<() => Promise<SnippetWorkflow | undefined>>(),
+}))
+vi.mock('@/next/navigation', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/next/navigation')>()),
+ useSearchParams: () => new URLSearchParams(),
+ usePathname: () => '/snippets/snippet-1',
+ useRouter: () => ({ push: vi.fn(), replace: vi.fn() }),
+}))
+vi.mock('@/service/use-snippet-workflows', () => ({ fetchSnippetDraftWorkflow: fetchDraft }))
+vi.mock('@/service/workflow', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/service/workflow')>()),
+ fetchAllInspectVars: async () => [],
+}))
+
+const initialFields = [
+ {
+ type: PipelineInputVarType.textInput,
+ label: 'Query',
+ variable: 'query',
+ required: true,
+ },
+]
+const localNodes = [
+ createStartNode({
+ id: 'local',
+ width: 240,
+ height: 100,
+ data: { title: 'Local draft', variables: [] },
+ }),
+]
+const localViewport = { x: 80, y: 60, zoom: 0.8 }
+
+function setup() {
+ const { queryClient } = createConsoleQueryWrapper({
+ systemFeatures: { enable_collaboration_mode: false },
+ appDslVersion: '0.6.0',
+ })
+ seedModelProviderQueries(queryClient)
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
+ queryClient.setQueryData(consoleQuery.spec.schemaDefinitions.get.queryKey(), [])
+ queryClient.setQueryData(consoleQuery.workspaces.current.agentProviders.get.queryKey(), [])
+ queryClient.setQueryData(consoleQuery.workspaces.current.triggers.get.queryKey({ input: {} }), [])
+ const refresh = createRef<ReturnType<typeof useSnippetRefreshDraft>>()
+ const flow = createRef<ReactFlowInstance>()
+ function Refresh() {
+ const hook = useSnippetRefreshDraft('snippet-1')
+ const canvas = useReactFlow()
+ useImperativeHandle(refresh, () => hook, [hook])
+ useImperativeHandle(flow, () => canvas, [canvas])
+ return null
+ }
+ // Mount the production event subscriber: emitting an update must replace the displayed graph.
+ const view = renderWorkflowComponent(
+ <NuqsTestingAdapter>
+ <EventEmitterContextProvider>
+ <WorkflowWithDefaultContext nodes={localNodes} edges={[]}>
+ <Workflow nodes={localNodes} edges={[]} viewport={localViewport}>
+ <Refresh />
+ </Workflow>
+ </WorkflowWithDefaultContext>
+ </EventEmitterContextProvider>
+ </NuqsTestingAdapter>,
+ {
+ queryClient,
+ resource: { kind: 'snippet', snippetId: 'snippet-1' },
+ initialStoreState: { syncWorkflowDraftHash: 'existing-hash', draftUpdatedAt: 1000 },
+ },
+ )
+ return { ...view, refresh, flow }
+}
+
+beforeEach(() => {
+ fetchDraft.mockReset()
+ useSnippetDraftStore.getState().setInputFields(initialFields)
+ vi.stubGlobal(
+ 'fetch',
+ vi.fn(() => {
+ throw new Error('Unexpected network request')
+ }),
+ )
+})
+afterEach(() => vi.unstubAllGlobals())
+
+it('keeps syncing until the draft arrives, then replaces canvas, fields and version state', async () => {
+ const pending = createDeferred<SnippetWorkflow>()
+ const draft: SnippetWorkflow = {
+ id: 'draft-1',
+ graph: {
+ nodes: [
+ createStartNode({
+ id: 'saved',
+ width: 240,
+ height: 100,
+ data: { title: 'Saved draft', variables: [] },
+ }),
+ ],
+ edges: [],
+ viewport: { x: 10, y: 20, zoom: 1.2 },
+ },
+ features: {},
+ input_fields: [],
+ hash: 'draft-hash',
+ created_at: 1_712_300_000,
+ updated_at: 1_712_345_678,
+ }
+ fetchDraft.mockReturnValueOnce(pending.promise)
+ const onSuccess = vi.fn()
+ const { refresh, flow, store } = setup()
+ expect(await screen.findByText('Local draft')).toBeInTheDocument()
+
+ act(() => refresh.current!.handleRefreshWorkflowDraft(onSuccess))
+ expect(store.getState().isSyncingWorkflowDraft).toBe(true)
+ expect(onSuccess).not.toHaveBeenCalled()
+ expect(useSnippetDraftStore.getState().inputFields).toEqual(initialFields)
+ expect(flow.current!.getNodes().map((node) => node.id)).toEqual(['local'])
+ await act(async () => pending.resolve(draft))
+
+ expect(await screen.findByText('Saved draft')).toBeInTheDocument()
+ expect(screen.queryByText('Local draft')).not.toBeInTheDocument()
+ await waitFor(() => expect(flow.current!.getViewport()).toEqual(draft.graph.viewport))
+ expect(flow.current!.getNodes()).toMatchObject([
+ {
+ id: 'saved',
+ data: { title: 'Saved draft', _connectedSourceHandleIds: [], _connectedTargetHandleIds: [] },
+ },
+ ])
+ expect(store.getState().isSyncingWorkflowDraft).toBe(false)
+ expect(fetchDraft).toHaveBeenCalledExactlyOnceWith('snippet-1')
+ expect(useSnippetDraftStore.getState().inputFields).toEqual([])
+ expect(store.getState().syncWorkflowDraftHash).toBe('draft-hash')
+ expect(store.getState().draftUpdatedAt).toBe(1_712_345_678_000)
+ expect(onSuccess).toHaveBeenCalledExactlyOnceWith(draft)
+})
+
+it('finishes without replacing editor state when no draft exists yet', async () => {
+ fetchDraft.mockResolvedValueOnce(undefined)
+ const onSuccess = vi.fn()
+ const { refresh, flow, store } = setup()
+ expect(await screen.findByText('Local draft')).toBeInTheDocument()
+ act(() => refresh.current!.handleRefreshWorkflowDraft(onSuccess))
+ await waitFor(() => expect(store.getState().isSyncingWorkflowDraft).toBe(false))
+
+ expect(flow.current!.getNodes()).toMatchObject(localNodes)
+ expect(flow.current!.getViewport()).toEqual(localViewport)
+ expect(screen.getByText('Local draft')).toBeInTheDocument()
+ expect(useSnippetDraftStore.getState().inputFields).toEqual(initialFields)
+ expect(store.getState().syncWorkflowDraftHash).toBe('existing-hash')
+ expect(store.getState().draftUpdatedAt).toBe(1000)
+ expect(onSuccess).not.toHaveBeenCalled()
+})
diff --git a/web/app/components/workflow/comment/comment-icon.spec.tsx b/web/app/components/workflow/comment/comment-icon.spec.tsx
index 8ee32025e1e..1df0415f314 100644
--- a/web/app/components/workflow/comment/comment-icon.spec.tsx
+++ b/web/app/components/workflow/comment/comment-icon.spec.tsx
@@ -1,47 +1,27 @@
import type { WorkflowCommentBasic } from '@dify/contracts/api/console/apps/types.gen'
import type { ReactElement } from 'react'
-import { fireEvent, screen } from '@testing-library/react'
+import { fireEvent, screen, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useState } from 'react'
-import { beforeEach, describe, expect, it, vi } from 'vite-plus/test'
-import { renderWorkflowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { describe, expect, it, vi } from 'vite-plus/test'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import { CommentIcon } from './comment-icon'
-type Position = { x: number; y: number }
-
-let mockUserId = 'user-1'
-const mockConsoleState = vi.hoisted(() => ({
- userProfile: {
- id: 'user-1',
- name: 'User',
- avatar_url: 'avatar',
- },
-}))
-
-const mockFlowToScreenPosition = vi.fn((position: Position) => position)
-const mockScreenToFlowPosition = vi.fn((position: Position) => position)
-
-const render = (ui: ReactElement) => {
+const render = (ui: ReactElement, userId = 'user-1') => {
const { queryClient } = createConsoleQueryWrapper({
- accountProfile: { ...mockConsoleState.userProfile, id: mockUserId },
+ accountProfile: { id: userId, name: 'User', avatar_url: 'avatar' },
+ })
+ return renderWorkflowFlowComponent(ui, {
+ queryClient,
+ reactFlowProps: {
+ proOptions: { hideAttribution: true },
+ fitView: false,
+ defaultViewport: { x: 50, y: 30, zoom: 2 },
+ },
})
- return renderWorkflowComponent(ui, { queryClient })
}
-vi.mock('reactflow', async (importOriginal) => ({
- ...(await importOriginal<typeof import('reactflow')>()),
- useReactFlow: () => ({
- flowToScreenPosition: mockFlowToScreenPosition,
- screenToFlowPosition: mockScreenToFlowPosition,
- }),
- useViewport: () => ({
- x: 0,
- y: 0,
- zoom: 1,
- }),
-}))
-
const createComment = (overrides: Partial<WorkflowCommentBasic> = {}): WorkflowCommentBasic => ({
id: 'comment-1',
position_x: 0,
@@ -64,11 +44,6 @@ const createComment = (overrides: Partial<WorkflowCommentBasic> = {}): WorkflowC
})
describe('CommentIcon', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUserId = 'user-1'
- })
-
it('opens with the keyboard and moves an authored comment in canvas coordinates', async () => {
const user = userEvent.setup()
const onClick = vi.fn()
@@ -108,7 +83,6 @@ describe('CommentIcon', () => {
it("allows opening another author's comment but does not move it with arrow keys", async () => {
const user = userEvent.setup()
- mockUserId = 'user-2'
const onClick = vi.fn()
const onPositionUpdate = vi.fn()
render(
@@ -117,6 +91,7 @@ describe('CommentIcon', () => {
onClick={onClick}
onPositionUpdate={onPositionUpdate}
/>,
+ 'user-2',
)
await user.tab()
await user.keyboard('{ArrowRight}{Enter}')
@@ -124,29 +99,24 @@ describe('CommentIcon', () => {
expect(onClick).toHaveBeenCalledTimes(1)
})
- it('toggles preview on hover when inactive', () => {
+ it('toggles preview on hover when inactive', async () => {
+ const user = userEvent.setup()
const comment = createComment()
- const { container } = render(
- <CommentIcon comment={comment} onClick={vi.fn()} isActive={false} />,
- )
- const marker = container.querySelector('[data-role="comment-marker"]') as HTMLElement
- const hoverTarget = marker.firstElementChild as HTMLElement
-
- fireEvent.mouseEnter(hoverTarget)
+ render(<CommentIcon comment={comment} onClick={vi.fn()} isActive={false} />)
+ const marker = screen.getByRole('button', { name: /workflow.keyboard.openComment/ })
+ await user.hover(within(marker).getByRole('img', { name: 'Alice' }))
expect(screen.getByText('Hello')).toBeInTheDocument()
- fireEvent.mouseLeave(hoverTarget)
+ await user.unhover(within(marker).getByRole('img', { name: 'Alice' }))
expect(screen.queryByText('Hello')).not.toBeInTheDocument()
})
- it('calls onPositionUpdate after dragging by author', () => {
+ it('converts pointer movement through the zoomed canvas before saving the authored position', () => {
const comment = createComment({ position_x: 0, position_y: 0 })
const onClick = vi.fn()
const onPositionUpdate = vi.fn()
- const { container } = render(
- <CommentIcon comment={comment} onClick={onClick} onPositionUpdate={onPositionUpdate} />,
- )
- const marker = container.querySelector('[data-role="comment-marker"]') as HTMLElement
+ render(<CommentIcon comment={comment} onClick={onClick} onPositionUpdate={onPositionUpdate} />)
+ const marker = screen.getByRole('button', { name: /workflow.keyboard.openComment/ })
fireEvent.pointerDown(marker, {
pointerId: 1,
@@ -165,32 +135,17 @@ describe('CommentIcon', () => {
clientY: 110,
})
- expect(mockScreenToFlowPosition).toHaveBeenCalledWith({ x: 10, y: 10 })
- expect(onPositionUpdate).toHaveBeenCalledWith({ x: 10, y: 10 })
+ expect(onPositionUpdate).toHaveBeenCalledExactlyOnceWith({ x: 5, y: 5 })
expect(onClick).not.toHaveBeenCalled()
})
- it('calls onClick for non-author clicks', () => {
- mockUserId = 'user-2'
- const comment = createComment()
+ it('opens another author’s comment with a click', async () => {
+ const user = userEvent.setup()
const onClick = vi.fn()
- const { container } = render(
- <CommentIcon comment={comment} onClick={onClick} isActive={false} />,
- )
- const marker = container.querySelector('[data-role="comment-marker"]') as HTMLElement
+ render(<CommentIcon comment={createComment()} onClick={onClick} isActive={false} />, 'user-2')
- fireEvent.pointerDown(marker, {
- pointerId: 1,
- button: 0,
- clientX: 50,
- clientY: 60,
- })
- fireEvent.pointerUp(marker, {
- pointerId: 1,
- clientX: 50,
- clientY: 60,
- })
+ await user.click(screen.getByRole('button', { name: /workflow.keyboard.openComment/ }))
- expect(onClick).toHaveBeenCalledTimes(1)
+ expect(onClick).toHaveBeenCalledExactlyOnceWith()
})
})
diff --git a/web/app/components/workflow/panel/debug-and-preview/__tests__/components.spec.tsx b/web/app/components/workflow/panel/debug-and-preview/__tests__/components.spec.tsx
index 5bbfe4e97cc..c8954da0d70 100644
--- a/web/app/components/workflow/panel/debug-and-preview/__tests__/components.spec.tsx
+++ b/web/app/components/workflow/panel/debug-and-preview/__tests__/components.spec.tsx
@@ -1,12 +1,15 @@
import type { PaginatedConversationVariableResponse } from '@dify/contracts/api/console/apps/types.gen'
+import type { EventEmitter } from 'ahooks/lib/useEventEmitter'
+import type { ComponentProps } from 'react'
+import type { useWorkflowRun } from '../../../hooks/use-workflow-run'
import type { ChatWrapperRefType } from '../index'
-import type { HumanInputFieldValue } from '@/app/components/base/chat/chat/answer/human-input-content/field-renderer'
+import type Chat from '@/app/components/base/chat/chat'
import type { ConversationVariable } from '@/app/components/workflow/types'
import type { EventEmitterValue } from '@/context/event-emitter'
import { act, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { useEventEmitter } from 'ahooks'
import copy from 'copy-to-clipboard'
+import { createRef } from 'react'
import { FeaturesProvider } from '@/app/components/base/features/context'
import { createStartNode } from '@/app/components/workflow/__tests__/fixtures'
import {
@@ -16,124 +19,94 @@ import {
import { ChatVarType } from '@/app/components/workflow/panel/chat-variable-panel/type'
import { InputVarType } from '@/app/components/workflow/types'
import { EVENT_WORKFLOW_STOP } from '@/app/components/workflow/variable-inspect/types'
-import { EventEmitterContext } from '@/context/event-emitter'
+import { useEventEmitterContextContext } from '@/context/event-emitter'
+import { EventEmitterContextProvider } from '@/context/event-emitter-provider'
import ChatWrapper from '../chat-wrapper'
import ConversationVariableModal from '../conversation-variable-modal'
import UserInput from '../user-input'
-const mockUseChat = vi.fn()
-const mockChatRender = vi.fn()
-let emitter: ReturnType<typeof useEventEmitter<EventEmitterValue>>
-
-vi.mock('copy-to-clipboard', () => ({
- default: vi.fn(),
+type HandleRun = ReturnType<typeof useWorkflowRun>['handleRun']
+const handleRun = vi.fn<HandleRun>()
+const callbacks = () => handleRun.mock.calls.at(-1)![1]!
+let emitter: EventEmitter<EventEmitterValue>
+const { mockRequest, submitHumanInputForm } = vi.hoisted(() => ({
+ mockRequest: vi.fn(),
+ submitHumanInputForm: vi.fn(),
}))
-
-const routeParams = vi.hoisted(() => ({ appId: 'app-1' }))
-const mockRequest = vi.hoisted(() => vi.fn())
-
-vi.mock('@/next/navigation', async (importOriginal) => ({
- ...(await importOriginal<typeof import('@/next/navigation')>()),
- useParams: () => routeParams,
-}))
-
-vi.mock('@/service/console/browser', () => ({
- consoleBrowserLink: { call: mockRequest },
+vi.mock('copy-to-clipboard', () => ({ default: vi.fn() }))
+vi.mock('@/service/console/browser', () => ({ consoleBrowserLink: { call: mockRequest } }))
+vi.mock('@/service/workflow', async (importOriginal) => ({
+ ...(await importOriginal<typeof import('@/service/workflow')>()),
+ submitHumanInputForm,
}))
-
vi.mock('@/hooks/use-timestamp', () => ({
- default: () => ({
- formatTime: (timestamp: number) => `formatted-${timestamp}`,
- }),
+ default: () => ({ formatTime: (timestamp: number) => `formatted-${timestamp}` }),
}))
-
+// Monaco renders the runtime value; its editing behavior is outside this read-only modal.
vi.mock('@/app/components/workflow/nodes/_base/components/editor/code-editor', () => ({
default: ({ value }: { value?: string }) => (
<pre data-testid="conversation-code-editor">{value}</pre>
),
}))
+// Shared Chat UI is independently tested; the preview's real useChat owns the conversation tree and stream.
vi.mock('@/app/components/base/chat/chat', () => ({
default: ({
+ chatList,
chatNode,
inputDisabled,
+ isResponding,
+ suggestedQuestions,
onSend,
onRegenerate,
switchSibling,
onHumanInputFormSubmit,
- onFeatureBarClick,
- }: {
- chatNode: React.ReactNode
- inputDisabled?: boolean
- onSend?: (message: string, files: unknown[]) => void
- onRegenerate?: (chatItem: {
- id: string
- parentMessageId?: string
- content?: string
- message_files?: unknown[]
- }) => void
- switchSibling?: (siblingMessageId: string) => void
- onHumanInputFormSubmit?: (
- formToken: string,
- formData: { inputs: Record<string, HumanInputFieldValue>; action: string },
- ) => Promise<void>
- onFeatureBarClick?: (state: boolean) => void
- }) => {
- mockChatRender({
- inputDisabled,
- hasChatNode: !!chatNode,
- })
- return (
- <div data-testid="chat-shell">
- <div data-testid="chat-input-disabled">{`${inputDisabled}`}</div>
- <button type="button" disabled={inputDisabled} onClick={() => onSend?.('hello', [])}>
- send-chat
- </button>
- <button
- type="button"
- onClick={() =>
- onRegenerate?.({
- id: 'answer-2',
- parentMessageId: 'question-1',
- content: 'latest answer',
- message_files: [],
- })
- }
- >
- regenerate-chat
- </button>
- <button type="button" onClick={() => switchSibling?.('sibling-2')}>
- switch-sibling
- </button>
- <button
- type="button"
- onClick={() =>
- onHumanInputFormSubmit?.('token-1', { inputs: { answer: 'ok' }, action: 'approve' })
- }
- >
- submit-human-input
- </button>
- <button type="button" onClick={() => onFeatureBarClick?.(true)}>
- open-feature-panel
- </button>
- {chatNode}
+ }: ComponentProps<typeof Chat>) => (
+ <>
+ <div role="log" aria-label="Conversation">
+ {chatList.map((item) => (
+ <p key={item.id}>{item.content}</p>
+ ))}
</div>
- )
- },
-}))
-
-vi.mock('../hooks', () => ({
- useChat: (...args: unknown[]) => mockUseChat(...args),
+ <output aria-label="Response state">{isResponding ? 'Responding' : 'Idle'}</output>
+ {suggestedQuestions?.map((question) => (
+ <p key={question}>{question}</p>
+ ))}
+ <button type="button" disabled={inputDisabled} onClick={() => onSend?.('hello', [])}>
+ send-chat
+ </button>
+ <button type="button" onClick={() => onRegenerate?.(chatList.at(-1)!)}>
+ regenerate-chat
+ </button>
+ <button type="button" onClick={() => switchSibling?.('answer-1')}>
+ switch-sibling
+ </button>
+ <button
+ type="button"
+ onClick={() =>
+ onHumanInputFormSubmit?.('token-1', {
+ inputs: { answer: 'ok' },
+ action: 'approve',
+ })
+ }
+ >
+ submit-human-input
+ </button>
+ {chatNode}
+ </>
+ ),
}))
-const Providers = ({ children }: { children: React.ReactNode }) => {
- emitter = useEventEmitter<EventEmitterValue>()
- return (
- <EventEmitterContext.Provider value={{ eventEmitter: emitter }}>
- <FeaturesProvider>{children}</FeaturesProvider>
- </EventEmitterContext.Provider>
- )
+function EventProbe() {
+ emitter = useEventEmitterContextContext().eventEmitter!
+ return null
}
+const Providers = ({ children }: { children: React.ReactNode }) => (
+ <EventEmitterContextProvider>
+ <EventProbe />
+ <FeaturesProvider features={{ suggested: { enabled: true } }}>{children}</FeaturesProvider>
+ </EventEmitterContextProvider>
+)
const renderWorkflowComponent = (
ui: React.ReactElement,
options?: Parameters<typeof renderWorkflowComponentBase>[1],
@@ -141,10 +114,12 @@ const renderWorkflowComponent = (
const renderWorkflowFlowComponent = (
ui: React.ReactElement,
options?: Parameters<typeof renderWorkflowFlowComponentBase>[1],
-) => renderWorkflowFlowComponentBase(<Providers>{ui}</Providers>, options)
-
+) =>
+ renderWorkflowFlowComponentBase(<Providers>{ui}</Providers>, {
+ ...options,
+ hooksStoreProps: { handleRun, ...options?.hooksStoreProps },
+ })
const mockCopy = vi.mocked(copy)
-
const createConversationVariable = (
overrides: Partial<ConversationVariable> = {},
): ConversationVariable => ({
@@ -155,21 +130,6 @@ const createConversationVariable = (
value: '{"draft":true}',
...overrides,
})
-
-const createChatState = (overrides: Record<string, unknown> = {}) => ({
- conversationId: 'conversation-1',
- chatList: [],
- handleStop: vi.fn(),
- isResponding: false,
- suggestedQuestions: [],
- handleSend: vi.fn(),
- handleRestart: vi.fn(),
- handleSwitchSibling: vi.fn(),
- handleSubmitHumanInputForm: vi.fn(),
- getHumanInputNodeData: vi.fn(),
- ...overrides,
-})
-
const createConversationVariableResponse = (
data: PaginatedConversationVariableResponse['data'] = [],
): PaginatedConversationVariableResponse => ({
@@ -179,23 +139,31 @@ const createConversationVariableResponse = (
total: data.length,
page: 1,
})
-
-const createChatWrapperRef = () =>
- ({ current: null }) as unknown as React.RefObject<ChatWrapperRefType>
+const createChatWrapperRef = () => createRef<ChatWrapperRefType>()
+const sendChunk = (answer: string, id: string, taskId = 'task-1') => {
+ act(() =>
+ callbacks().onData?.(answer, true, { conversationId: 'conversation-1', messageId: id, taskId }),
+ )
+}
+const complete = async () => {
+ await act(async () => {
+ await callbacks().onCompleted?.(false)
+ })
+}
describe('debug-and-preview components', () => {
beforeEach(() => {
- vi.clearAllMocks()
- routeParams.appId = 'app-1'
- mockRequest.mockReset()
- mockUseChat.mockReturnValue(createChatState())
- mockRequest.mockResolvedValue(createConversationVariableResponse())
- })
-
- afterEach(() => {
- vi.useRealTimers()
+ handleRun.mockReset()
+ submitHumanInputForm.mockReset().mockResolvedValue(undefined)
+ mockRequest
+ .mockReset()
+ .mockImplementation(async (path: string[]) =>
+ path.includes('suggestedQuestions')
+ ? { data: ['Try another question'] }
+ : createConversationVariableResponse(),
+ )
})
-
+ afterEach(() => vi.useRealTimers())
describe('ConversationVariableModal', () => {
it('copies the displayed runtime value and re-enables copying after the timeout', async () => {
vi.useFakeTimers({ shouldAdvanceTime: true })
@@ -309,11 +277,9 @@ describe('debug-and-preview components', () => {
})
describe('ChatWrapper', () => {
- it('should seed start defaults into workflow inputs and expose restart through the ref handle', async () => {
- const chatState = createChatState()
- mockUseChat.mockReturnValue(chatState)
+ it('seeds start defaults, then restarting clears the conversation and restores inputs', async () => {
+ const user = userEvent.setup()
const chatRef = createChatWrapperRef()
-
const { store } = renderWorkflowFlowComponent(
<ChatWrapper
ref={chatRef}
@@ -337,42 +303,30 @@ describe('debug-and-preview components', () => {
},
}),
],
- edges: [],
- initialStoreState: {
- inputs: {
- custom: 'value',
- },
- },
+ initialStoreState: { inputs: { custom: 'value' } },
},
)
-
- await waitFor(() => {
- expect(store.getState().inputs).toEqual({
- custom: 'value',
- name: 'Ada',
- })
- })
-
+ expect(store.getState().inputs).toEqual({ custom: 'value', name: 'Ada' })
expect(screen.getByText('workflow.common.previewPlaceholder')).toBeInTheDocument()
-
- act(() => {
- chatRef.current?.handleRestart()
- })
-
- expect(chatState.handleRestart).toHaveBeenCalledTimes(1)
- expect(store.getState().inputs).toEqual({
- name: 'Ada',
- })
+ await user.click(screen.getByRole('button', { name: 'send-chat' }))
+ sendChunk('A saved answer', 'answer-1')
+ expect(screen.getByRole('log', { name: 'Conversation' })).toHaveTextContent('A saved answer')
+ act(() => chatRef.current!.handleRestart())
+ expect(screen.getByRole('log', { name: 'Conversation' })).toBeEmptyDOMElement()
+ expect(screen.getByLabelText('Response state')).toHaveTextContent('Idle')
+ expect(screen.getByText('workflow.common.previewPlaceholder')).toBeInTheDocument()
+ expect(store.getState().inputs).toEqual({ name: 'Ada' })
})
- it('preserves zero and false start defaults when initializing and restarting', async () => {
+ it('preserves zero and false defaults when initializing and restarting after input edits', async () => {
+ const user = userEvent.setup()
const chatRef = createChatWrapperRef()
const { store } = renderWorkflowFlowComponent(
<ChatWrapper
ref={chatRef}
showConversationVariableModal={false}
onConversationModalHide={vi.fn()}
- showInputsFieldsPanel={false}
+ showInputsFieldsPanel
onHide={vi.fn()}
/>,
{
@@ -393,25 +347,19 @@ describe('debug-and-preview components', () => {
],
},
)
- await waitFor(() => expect(store.getState().inputs).toEqual({ count: 0, ready: false }))
- act(() => store.getState().setInputs({ count: 8, ready: true }))
- act(() => chatRef.current?.handleRestart())
expect(store.getState().inputs).toEqual({ count: 0, ready: false })
+ await user.clear(screen.getByLabelText('Count'))
+ await user.type(screen.getByLabelText('Count'), '8')
+ await user.click(screen.getByRole('checkbox', { name: /^Ready/ }))
+ expect(store.getState().inputs).toEqual({ count: 8, ready: true })
+ act(() => chatRef.current!.handleRestart())
+ expect(store.getState().inputs).toEqual({ count: 0, ready: false })
+ expect(screen.getByLabelText('Count')).toHaveValue('0')
+ expect(screen.getByRole('checkbox', { name: /^Ready/ })).not.toBeChecked()
})
- it('disables sending while the latest workflow is paused', async () => {
+ it('disables sending when the active response pauses', async () => {
const user = userEvent.setup()
- const chatState = createChatState({
- chatList: [
- {
- id: 'paused-answer',
- isAnswer: true,
- content: '',
- workflowProcess: { status: 'paused' },
- },
- ],
- })
- mockUseChat.mockReturnValue(chatState)
renderWorkflowFlowComponent(
<ChatWrapper
ref={createChatWrapperRef()}
@@ -422,107 +370,55 @@ describe('debug-and-preview components', () => {
/>,
)
const send = screen.getByRole('button', { name: 'send-chat' })
- expect(send).toBeDisabled()
await user.click(send)
- expect(chatState.handleSend).not.toHaveBeenCalled()
- })
-
- it('should hide the side panel while responding and render the conversation modal when requested', async () => {
- const onHide = vi.fn()
- mockUseChat.mockReturnValue(
- createChatState({
- isResponding: true,
- }),
- )
- mockRequest.mockResolvedValue(
- createConversationVariableResponse([
- {
- ...createConversationVariable({
- id: 'var-1',
- value: '{"latest":1}',
- }),
- updated_at: 100,
- created_at: 50,
- },
- ]),
- )
-
- renderWorkflowFlowComponent(
- <ChatWrapper
- ref={createChatWrapperRef()}
- showConversationVariableModal
- onConversationModalHide={vi.fn()}
- showInputsFieldsPanel={false}
- onHide={onHide}
- />,
- {
- nodes: [
- createStartNode({
- data: {
- variables: [],
- },
- }),
- ],
- edges: [],
- resource: { kind: 'app' as const, appId: 'app-1', mode: 'workflow' as const },
- initialStoreState: {
- conversationVariables: [createConversationVariable()],
+ const envelope = { task_id: 'task-1', workflow_run_id: 'run-1' }
+ act(() => {
+ callbacks().onWorkflowStarted?.({
+ ...envelope,
+ event: 'workflow_started',
+ message_id: 'answer-1',
+ data: { id: 'run-1', workflow_id: 'workflow-1', created_at: 1 },
+ })
+ callbacks().onWorkflowPaused?.({
+ ...envelope,
+ event: 'workflow_paused',
+ data: {
+ workflow_run_id: 'run-1',
+ paused_nodes: ['human-input'],
+ reasons: [],
+ outputs: {},
},
- },
- )
-
- await waitFor(() => {
- expect(onHide).toHaveBeenCalledTimes(1)
+ })
})
-
- expect(screen.getAllByText('session_state')).toHaveLength(2)
+ await complete()
+ expect(send).toBeDisabled()
+ expect(screen.getByLabelText('Response state')).toHaveTextContent('Idle')
+ await user.click(send)
+ expect(screen.getByRole('log', { name: 'Conversation' })).toHaveTextContent('hello')
})
- it('forwards chat actions and responds to real stop events', async () => {
+ it('renders streamed answers, regenerates and switches siblings, and stops through the event bus', async () => {
const user = userEvent.setup()
- const handleSend = vi.fn()
- const handleSwitchSibling = vi.fn()
- const handleSubmitHumanInputForm = vi.fn().mockResolvedValue(undefined)
- const handleStop = vi.fn()
- mockUseChat.mockReturnValue(
- createChatState({
- chatList: [
- {
- id: 'answer-1',
- isAnswer: true,
- content: 'first answer',
- },
- {
- id: 'question-1',
- isAnswer: false,
- content: 'first question',
- parentMessageId: 'answer-1',
- message_files: [],
- },
- {
- id: 'answer-2',
- isAnswer: true,
- parentMessageId: 'question-1',
- content: 'latest answer',
- workflowProcess: {
- status: 'succeeded',
- },
- },
- ],
- handleSend,
- handleSwitchSibling,
- handleSubmitHumanInputForm,
- handleStop,
- }),
+ const onHide = vi.fn()
+ const chatRef = createChatWrapperRef()
+ const view = (showConversationVariableModal = false) => (
+ <Providers>
+ <ChatWrapper
+ ref={chatRef}
+ showConversationVariableModal={showConversationVariableModal}
+ onConversationModalHide={vi.fn()}
+ showInputsFieldsPanel={false}
+ onHide={onHide}
+ />
+ </Providers>
)
-
- const { store } = renderWorkflowFlowComponent(
+ const { rerender } = renderWorkflowFlowComponent(
<ChatWrapper
- ref={createChatWrapperRef()}
+ ref={chatRef}
showConversationVariableModal={false}
onConversationModalHide={vi.fn()}
showInputsFieldsPanel={false}
- onHide={vi.fn()}
+ onHide={onHide}
/>,
{
nodes: [
@@ -539,102 +435,68 @@ describe('debug-and-preview components', () => {
},
}),
],
- edges: [],
initialStoreState: {
- inputs: {
- existing: 'value',
- },
+ inputs: { existing: 'value' },
+ conversationVariables: [createConversationVariable()],
},
},
)
-
- await waitFor(() => {
- expect(store.getState().inputs).toEqual({
- existing: 'value',
- name: 'Ada',
- })
- })
-
- expect(screen.getByRole('button', { name: 'send-chat' })).toBeEnabled()
-
await user.click(screen.getByRole('button', { name: 'send-chat' }))
- expect(handleSend).toHaveBeenCalledWith(
+ expect(handleRun).toHaveBeenLastCalledWith(
expect.objectContaining({
query: 'hello',
- conversation_id: 'conversation-1',
- inputs: {
- existing: 'value',
- name: 'Ada',
- },
- parent_message_id: 'answer-2',
- }),
- expect.objectContaining({
- onGetSuggestedQuestions: expect.any(Function),
+ inputs: { existing: 'value', name: 'Ada' },
}),
+ expect.any(Object),
)
-
- const sendCallbacks = handleSend.mock.calls[0]?.[1] as {
- onGetSuggestedQuestions: (messageId: string, onCancel: (cancel: () => void) => void) => void
- }
- await sendCallbacks.onGetSuggestedQuestions('message-1', () => {})
+ expect(onHide).toHaveBeenCalledOnce()
+ expect(screen.getByLabelText('Response state')).toHaveTextContent('Responding')
+ sendChunk('First answer', 'answer-1')
+ await complete()
+ expect(screen.getByRole('log', { name: 'Conversation' })).toHaveTextContent('First answer')
+ expect(await screen.findByText('Try another question')).toBeInTheDocument()
expect(mockRequest).toHaveBeenCalledWith(
['apps', 'byAppId', 'chatMessages', 'byMessageId', 'suggestedQuestions', 'get'],
- { params: { app_id: 'app-1', message_id: 'message-1' } },
- expect.objectContaining({ signal: expect.any(AbortSignal) }),
- )
-
- await user.click(screen.getByRole('button', { name: 'regenerate-chat' }))
- expect(handleSend).toHaveBeenNthCalledWith(
- 2,
- expect.objectContaining({
- query: 'first question',
- parent_message_id: 'answer-1',
- }),
+ { params: { app_id: 'app-1', message_id: 'answer-1' } },
expect.any(Object),
)
-
+ await user.click(screen.getByRole('button', { name: 'regenerate-chat' }))
+ sendChunk('Second answer', 'answer-2')
+ await complete()
+ expect(screen.getByRole('log', { name: 'Conversation' })).toHaveTextContent('Second answer')
await user.click(screen.getByRole('button', { name: 'switch-sibling' }))
- expect(handleSwitchSibling).toHaveBeenCalledWith(
- 'sibling-2',
- expect.objectContaining({
- onGetSuggestedQuestions: expect.any(Function),
- }),
- )
-
- const switchCallbacks = handleSwitchSibling.mock.calls[0]?.[1] as {
- onGetSuggestedQuestions: (messageId: string, onCancel: (cancel: () => void) => void) => void
- }
- await switchCallbacks.onGetSuggestedQuestions('message-2', () => {})
- expect(mockRequest).toHaveBeenCalledWith(
- ['apps', 'byAppId', 'chatMessages', 'byMessageId', 'suggestedQuestions', 'get'],
- { params: { app_id: 'app-1', message_id: 'message-2' } },
- expect.objectContaining({ signal: expect.any(AbortSignal) }),
- )
-
+ expect(screen.getByRole('log', { name: 'Conversation' })).toHaveTextContent('First answer')
+ expect(screen.queryByText('Second answer')).not.toBeInTheDocument()
await user.click(screen.getByRole('button', { name: 'submit-human-input' }))
- await waitFor(() => {
- expect(handleSubmitHumanInputForm).toHaveBeenCalledWith('token-1', {
- inputs: { answer: 'ok' },
- action: 'approve',
- })
+ expect(submitHumanInputForm).toHaveBeenCalledExactlyOnceWith('token-1', {
+ inputs: { answer: 'ok' },
+ action: 'approve',
})
-
- const stopResponding = mockUseChat.mock.calls[0]?.[3] as (taskId: string) => void
- await stopResponding('task-1')
- expect(mockRequest).toHaveBeenCalledWith(
- ['apps', 'byAppId', 'chatMessages', 'byTaskId', 'stop', 'post'],
- { params: { app_id: 'app-1', task_id: 'task-1' } },
- expect.any(Object),
+ await user.click(screen.getByRole('button', { name: 'send-chat' }))
+ sendChunk('Pending answer', 'answer-3', 'task-3')
+ act(() => emitter.emit({ type: 'unrelated-event' }))
+ expect(screen.getByLabelText('Response state')).toHaveTextContent('Responding')
+ act(() => emitter.emit({ type: EVENT_WORKFLOW_STOP }))
+ expect(screen.getByLabelText('Response state')).toHaveTextContent('Idle')
+ await waitFor(() =>
+ expect(mockRequest).toHaveBeenCalledWith(
+ ['apps', 'byAppId', 'chatMessages', 'byTaskId', 'stop', 'post'],
+ { params: { app_id: 'app-1', task_id: 'task-3' } },
+ expect.any(Object),
+ ),
)
-
- act(() => {
- emitter.emit({ type: 'unrelated-event' })
- })
- expect(handleStop).not.toHaveBeenCalled()
- act(() => {
- emitter.emit({ type: EVENT_WORKFLOW_STOP })
- })
- expect(handleStop).toHaveBeenCalledTimes(1)
+ mockRequest.mockResolvedValue(
+ createConversationVariableResponse([
+ {
+ ...createConversationVariable({ value: '{"latest":1}' }),
+ updated_at: 100,
+ created_at: 50,
+ },
+ ]),
+ )
+ rerender(view(true))
+ expect(await screen.findByRole('dialog')).toBeInTheDocument()
+ expect(await screen.findByText('{"latest":1}')).toBeInTheDocument()
})
})
})