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 and access points through real owners (#44423)

Stephen Zhou19440438a3d5
diff --git a/web/app/components/app/access-point/__tests__/built-in-access-points.spec.tsx b/web/app/components/app/access-point/__tests__/built-in-access-points.spec.tsx
index 555c9367f82..d566030d8de 100644
--- a/web/app/components/app/access-point/__tests__/built-in-access-points.spec.tsx
+++ b/web/app/components/app/access-point/__tests__/built-in-access-points.spec.tsx
@@ -1,287 +1,261 @@
-import type { AppMode } from '@dify/contracts/api/console/apps/types.gen'
+import type {
+ AppDetailWithSite,
+ AppMode,
+ WorkflowTriggerResponse,
+} from '@dify/contracts/api/console/apps/types.gen'
import type { ReactElement } from 'react'
-import { screen } from '@testing-library/react'
+import type { PublishedWorkflow } from '../shared/utils'
+import { screen, within } from '@testing-library/react'
import { consoleQuery } from '@/service/console'
-import { createHttpError } from '@/service/http-error'
-import { consoleQueryKey } from '@/test/console/operation-hooks'
import { renderWithConsoleQuery as renderWithConsole } from '@/test/console/query-data'
-import { createAppDetailFixture } from '@/test/fixtures/app'
+import { createAppDetailFixture, createAppSiteFixture } from '@/test/fixtures/app'
+import { createWorkflowResponseFixture } from '@/test/fixtures/workflow-response'
import { createTestQueryClient } from '@/test/query-client'
import { BuiltInAccessPoints } from '../built-in-access-points'
-const mocks = vi.hoisted(() => ({
- appInfo: {
- id: 'app-1',
- mode: 'workflow',
- enable_site: false,
- enable_api: false,
- permission_keys: [],
- } as Record<string, unknown>,
- workflow: {
- data: null as Record<string, unknown> | null,
- isError: false,
- isPending: false,
- },
- webCard: vi.fn(),
- apiCard: vi.fn(),
- mcpCard: vi.fn(),
- triggerCard: vi.fn(),
- useAppWorkflow: vi.fn(),
-}))
-
-vi.mock('@/features/system-features/client', () => ({
- systemFeaturesQueryOptions: () => ({ queryKey: consoleQueryKey('systemFeatures.get') }),
+const workflowState = vi.hoisted(() => ({
+ data: undefined as PublishedWorkflow,
+ isError: false,
+ isPending: false,
}))
-function render(ui: ReactElement) {
- const queryClient = createTestQueryClient()
- queryClient.setQueryData(consoleQueryKey('systemFeatures.get'), {
- webapp_auth: { enabled: true },
- rbac_enabled: true,
- })
- queryClient.setQueryData(
- consoleQuery.apps.byAppId.get.queryKey({ input: { params: { app_id: 'app-1' } } }),
- createAppDetailFixture({ ...mocks.appInfo, mode: mocks.appInfo.mode as AppMode }),
- )
- return renderWithConsole(ui, {
- queryClient,
- currentWorkspace: { id: 'workspace-1', role: 'owner' },
- })
-}
-
vi.mock('@/context/i18n', () => ({
- useDocLink: () => (path: string) => path,
+ useDocLink: () => (path: string) => `https://docs.example.test${path}`,
}))
+// Published workflow retrieval is the query boundary for this availability coordinator.
vi.mock('@/service/use-workflow', () => ({
- useAppWorkflow: (...args: unknown[]) => {
- mocks.useAppWorkflow(...args)
- return mocks.workflow
- },
+ useAppWorkflow: () => workflowState,
}))
-vi.mock('../shared/use-access-point-actions', () => ({
- useAccessPointActions: () => ({
- refreshAppDetail: vi.fn(),
- saveSiteConfig: vi.fn().mockResolvedValue(true),
- }),
+vi.mock('@/service/access-control/use-app-access-control', () => ({
+ useAppWhiteListSubjects: () => ({ data: undefined }),
+ useGetUserCanAccessApp: () => ({ data: { result: true }, refetch: vi.fn() }),
}))
-vi.mock('../built-in-access-points/web-app-card', () => ({
- WebAppAccessPointCard: (props: Record<string, unknown>) => {
- mocks.webCard(props)
- return null
- },
+vi.mock('@/service/use-triggers', () => ({
+ useAllTriggerPlugins: () => ({ data: [] }),
}))
-vi.mock('../built-in-access-points/service-api-card', () => ({
- ServiceApiAccessPointCard: (props: Record<string, unknown>) => {
- mocks.apiCard(props)
- return null
- },
+// These independently tested dialogs do not own card availability or permission state.
+vi.mock('@/app/components/app/overview/customize', () => ({
+ CustomizeDialog: ({ disabled }: { disabled?: boolean }) => (
+ <button type="button" disabled={disabled}>
+ Customize
+ </button>
+ ),
}))
-vi.mock('../built-in-access-points/mcp-card', () => ({
- MCPAccessPointCard: (props: Record<string, unknown>) => {
- mocks.mcpCard(props)
- return null
- },
+vi.mock('@/app/components/app/overview/settings', () => ({
+ SettingsDialog: ({ disabled }: { disabled?: boolean }) => (
+ <button type="button" disabled={disabled}>
+ Settings
+ </button>
+ ),
}))
-vi.mock('../built-in-access-points/trigger-card', () => ({
- TriggerAccessPointCard: (props: Record<string, unknown>) => {
- mocks.triggerCard(props)
- return null
- },
+vi.mock('@/app/components/app/overview/workflow-launch-dialog', () => ({
+ WorkflowLaunchDialog: () => null,
}))
+const startWorkflow = createWorkflowResponseFixture({
+ graph: { nodes: [{ id: 'start', data: { type: 'start' } }], edges: [] },
+})
+
+const triggerWorkflow = createWorkflowResponseFixture({
+ graph: { nodes: [{ id: 'trigger', data: { type: 'trigger-webhook' } }], edges: [] },
+})
+
+const publishedTrigger: WorkflowTriggerResponse = {
+ id: 'trigger-1',
+ trigger_type: 'trigger-webhook',
+ title: 'Published webhook',
+ node_id: 'trigger',
+ provider_name: 'Webhook',
+ icon: '',
+ status: 'enabled',
+ created_at: '2026-10-20T00:00:00Z',
+ updated_at: '2026-10-20T00:00:00Z',
+}
+
+let appInfo: AppDetailWithSite
+let triggers: WorkflowTriggerResponse[]
+
+function createAppInfo(mode: AppMode = 'workflow', overrides: Partial<AppDetailWithSite> = {}) {
+ return createAppDetailFixture({
+ id: 'app-1',
+ mode,
+ enable_site: false,
+ enable_api: false,
+ site: createAppSiteFixture(),
+ permission_keys: [],
+ ...overrides,
+ })
+}
+
+function render(ui: ReactElement) {
+ const queryClient = createTestQueryClient()
+ queryClient.setQueryData(
+ consoleQuery.apps.byAppId.get.queryKey({ input: { params: { app_id: 'app-1' } } }),
+ appInfo,
+ )
+ queryClient.setQueryData(
+ consoleQuery.apps.byAppId.server.get.queryKey({
+ input: { params: { app_id: 'app-1' } },
+ }),
+ {
+ id: '',
+ server_code: '',
+ name: '',
+ description: '',
+ parameters: {},
+ status: 'inactive',
+ },
+ )
+ queryClient.setQueryData(
+ consoleQuery.apps.byAppId.triggers.get.queryKey({
+ input: { params: { app_id: 'app-1' } },
+ }),
+ { data: triggers },
+ )
+ queryClient.setQueryData(
+ consoleQuery.apps.byResourceId.apiKeys.get.queryKey({
+ input: { params: { resource_id: 'app-1' } },
+ }),
+ { data: [] },
+ )
+ return renderWithConsole(ui, {
+ queryClient,
+ currentWorkspace: { id: 'workspace-1', role: 'owner' },
+ systemFeatures: { webapp_auth: { enabled: false }, rbac_enabled: true },
+ })
+}
+
+function renderAccessPoints(
+ permissions: {
+ canDeploy?: boolean
+ canManageAccessPoint?: boolean
+ canReleaseAndVersion?: boolean
+ } = {},
+) {
+ return render(
+ <BuiltInAccessPoints
+ canViewLayout
+ appId="app-1"
+ canDeploy={permissions.canDeploy ?? true}
+ canManageAccessPoint={permissions.canManageAccessPoint ?? true}
+ canReleaseAndVersion={permissions.canReleaseAndVersion ?? true}
+ />,
+ )
+}
+
+const getCards = () => ({
+ web: screen.getByRole('region', { name: /agentDetail\.access\.webApp\.title/ }),
+ api: screen.getByRole('region', { name: /agentDetail\.access\.serviceApi\.title/ }),
+ mcp: screen.getByRole('region', { name: /mcp\.server\.title/ }),
+ trigger: screen.queryByRole('region', { name: /settings\.trigger/ }),
+})
+
describe('BuiltInAccessPoints', () => {
beforeEach(() => {
- vi.clearAllMocks()
- mocks.appInfo = {
- id: 'app-1',
- mode: 'workflow',
- enable_site: false,
- enable_api: false,
- permission_keys: [],
- }
- mocks.workflow = {
- data: null,
- isError: false,
- isPending: false,
- }
+ appInfo = createAppInfo()
+ triggers = []
+ workflowState.data = undefined
+ workflowState.isError = false
+ workflowState.isPending = false
})
it('renders the unpublished state across all access point cards', () => {
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint={false}
- canReleaseAndVersion={false}
- />,
- )
+ renderAccessPoints({ canManageAccessPoint: false, canReleaseAndVersion: false })
expect(screen.getByText('deployments.studio.accessPoint.noPublishedTitle')).toBeInTheDocument()
- expect(mocks.webCard).toHaveBeenCalledWith(
- expect.objectContaining({
- availability: 'unavailable',
- canDeploy: true,
- canManageAccessPoint: false,
- }),
- )
- expect(mocks.apiCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable', canManage: false }),
- )
- expect(mocks.mcpCard).toHaveBeenCalledTimes(1)
- expect(mocks.triggerCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable', canManageAccessPoint: false }),
- )
+ const cards = getCards()
+ expect(cards.trigger).toBeInTheDocument()
+ for (const card of [cards.web, cards.api, cards.mcp, cards.trigger!])
+ expect(
+ within(card).getAllByText('deployments.health.ENVIRONMENT_STATUS_FAILED').length,
+ ).toBeGreaterThan(0)
+ expect(
+ screen.getByRole('button', { name: 'deployments.studio.accessPoint.goToPublish' }),
+ ).toBeDisabled()
})
it('keeps Trigger unavailable when no trigger node is published', () => {
- mocks.workflow = {
- data: {
- graph: {
- nodes: [{ data: { type: 'start' } }],
- },
- },
- isError: false,
- isPending: false,
- }
-
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint={false}
- canReleaseAndVersion={false}
- />,
- )
+ workflowState.data = startWorkflow
+ renderAccessPoints({ canManageAccessPoint: false, canReleaseAndVersion: false })
expect(
screen.queryByText('deployments.studio.accessPoint.noPublishedTitle'),
).not.toBeInTheDocument()
- expect(mocks.webCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'available', workflow: mocks.workflow.data }),
- )
- expect(mocks.apiCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'available' }),
- )
- expect(mocks.triggerCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
+ const cards = getCards()
+ expect(
+ within(cards.web).queryByText('deployments.health.ENVIRONMENT_STATUS_FAILED'),
+ ).not.toBeInTheDocument()
+ expect(
+ within(cards.api).queryByText('deployments.health.ENVIRONMENT_STATUS_FAILED'),
+ ).not.toBeInTheDocument()
+ expect(
+ within(cards.trigger!).getByText('deployments.health.ENVIRONMENT_STATUS_FAILED'),
+ ).toBeInTheDocument()
})
it('keeps an unpublished Chatflow unavailable without showing a Trigger card', () => {
- mocks.appInfo = {
- ...mocks.appInfo,
- mode: 'advanced-chat',
- enable_site: true,
- enable_api: true,
- }
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion
- />,
- )
+ appInfo = createAppInfo('advanced-chat', { enable_site: true, enable_api: true })
+ renderAccessPoints()
expect(screen.getByText('deployments.studio.accessPoint.noPublishedTitle')).toBeInTheDocument()
- expect(mocks.webCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.apiCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.mcpCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.triggerCard).not.toHaveBeenCalled()
- expect(mocks.useAppWorkflow).toHaveBeenCalledWith('app-1', expect.any(Object))
+ const cards = getCards()
+ expect(cards.trigger).not.toBeInTheDocument()
+ for (const card of [cards.web, cards.api, cards.mcp])
+ expect(
+ within(card).getAllByText('deployments.health.ENVIRONMENT_STATUS_FAILED').length,
+ ).toBeGreaterThan(0)
})
it.each([
- ['loading', { data: null, isError: false, isPending: true }, 'loading'],
- ['failed', { data: null, isError: true, isPending: false }, 'unavailable'],
- [
- 'published',
- {
- data: { graph: { nodes: [{ data: { type: 'start' } }] } },
- isError: false,
- isPending: false,
- },
- 'available',
- ],
- ] as const)(
- 'shows Chatflow access points as %s while published workflow is %s',
- (_state, workflow, availability) => {
- mocks.appInfo = {
- ...mocks.appInfo,
- mode: 'advanced-chat',
- enable_site: true,
- enable_api: true,
- }
- mocks.workflow = workflow
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion
- />,
- )
-
- expect(mocks.webCard).toHaveBeenCalledWith(expect.objectContaining({ availability }))
- expect(mocks.apiCard).toHaveBeenCalledWith(expect.objectContaining({ availability }))
- expect(mocks.triggerCard).not.toHaveBeenCalled()
- expect(
- screen.queryByText('deployments.studio.accessPoint.noPublishedTitle'),
- ).not.toBeInTheDocument()
- },
- )
+ ['loading', { data: undefined, isError: false, isPending: true }, 'loading'],
+ ['failed', { data: undefined, isError: true, isPending: false }, 'unavailable'],
+ ['published', { data: startWorkflow, isError: false, isPending: false }, 'available'],
+ ] as const)('shows Chatflow access points as %s', (_state, workflow, availability) => {
+ appInfo = createAppInfo('advanced-chat', { enable_site: true, enable_api: true })
+ Object.assign(workflowState, workflow)
+ renderAccessPoints()
+
+ const cards = getCards()
+ expect(cards.trigger).not.toBeInTheDocument()
+ for (const card of [cards.web, cards.api]) {
+ if (availability === 'loading') expect(card).toHaveAttribute('aria-busy', 'true')
+ else expect(card).not.toHaveAttribute('aria-busy')
+ if (availability === 'unavailable')
+ expect(
+ within(card).getAllByText('deployments.health.ENVIRONMENT_STATUS_FAILED').length,
+ ).toBeGreaterThan(0)
+ else
+ expect(
+ within(card).queryByText('deployments.health.ENVIRONMENT_STATUS_FAILED'),
+ ).not.toBeInTheDocument()
+ }
+ expect(
+ screen.queryByText('deployments.studio.accessPoint.noPublishedTitle'),
+ ).not.toBeInTheDocument()
+ })
- it('uses Access Point management for every requested built-in operation', () => {
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion={false}
- />,
- )
+ it('enables access point management controls only with permission', () => {
+ workflowState.data = startWorkflow
+ const { rerender } = renderAccessPoints({ canManageAccessPoint: false })
- expect(mocks.webCard).toHaveBeenCalledWith(
- expect.objectContaining({ canManageAccessPoint: true }),
- )
- expect(mocks.apiCard).toHaveBeenCalledWith(expect.objectContaining({ canManage: true }))
- expect(mocks.mcpCard).toHaveBeenCalledWith(
- expect.objectContaining({ canManageAccessPoint: true }),
- )
- expect(mocks.triggerCard).toHaveBeenCalledWith(
- expect.objectContaining({ canManageAccessPoint: true }),
+ expect(
+ screen.getByRole('switch', { name: 'appOverview.overview.appInfo.title' }),
+ ).toHaveAttribute('aria-disabled', 'true')
+ expect(
+ screen.getByRole('switch', { name: 'appOverview.overview.apiInfo.title' }),
+ ).toHaveAttribute('aria-disabled', 'true')
+ expect(screen.getByRole('switch', { name: 'tools.mcp.server.title' })).toHaveAttribute(
+ 'aria-disabled',
+ 'true',
)
- })
-
- it('enables Trigger and disables the other access points in trigger mode', () => {
- mocks.workflow = {
- data: {
- graph: {
- nodes: [{ data: { type: 'trigger-webhook' } }],
- },
- },
- isError: false,
- isPending: false,
- }
- render(
+ rerender(
<BuiltInAccessPoints
canViewLayout
appId="app-1"
@@ -290,87 +264,50 @@ describe('BuiltInAccessPoints', () => {
canReleaseAndVersion
/>,
)
-
- expect(mocks.webCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.apiCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.mcpCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'unavailable' }),
- )
- expect(mocks.triggerCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'available' }),
+ expect(
+ screen.getByRole('switch', { name: 'appOverview.overview.appInfo.title' }),
+ ).not.toHaveAttribute('aria-disabled', 'true')
+ expect(
+ screen.getByRole('switch', { name: 'appOverview.overview.apiInfo.title' }),
+ ).not.toHaveAttribute('aria-disabled', 'true')
+ expect(screen.getByRole('switch', { name: 'tools.mcp.server.title' })).not.toHaveAttribute(
+ 'aria-disabled',
+ 'true',
)
+ })
+
+ it('enables Trigger and disables the other access points in trigger mode', () => {
+ workflowState.data = triggerWorkflow
+ triggers = [publishedTrigger]
+ renderAccessPoints()
+
+ const cards = getCards()
+ for (const card of [cards.web, cards.api, cards.mcp])
+ expect(
+ within(card).getAllByText('deployments.health.ENVIRONMENT_STATUS_FAILED').length,
+ ).toBeGreaterThan(0)
+ expect(cards.trigger).toBeInTheDocument()
+ expect(screen.getByRole('switch', { name: 'Published webhook' })).toBeChecked()
expect(
screen.getByText('deployments.studio.accessPoint.triggerExclusiveNotice'),
).toBeInTheDocument()
})
it('keeps all cards visible while the published workflow is loading', () => {
- mocks.workflow = {
- data: null,
- isError: false,
- isPending: true,
- }
+ workflowState.isPending = true
+ renderAccessPoints()
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion
- />,
- )
-
- expect(mocks.webCard).toHaveBeenCalledWith(expect.objectContaining({ availability: 'loading' }))
- expect(mocks.apiCard).toHaveBeenCalledWith(expect.objectContaining({ availability: 'loading' }))
- expect(mocks.triggerCard).toHaveBeenCalledWith(
- expect.objectContaining({ availability: 'loading' }),
- )
+ const cards = getCards()
+ for (const card of [cards.web, cards.api, cards.mcp, cards.trigger!])
+ expect(card).toHaveAttribute('aria-busy', 'true')
})
it('does not show the unpublished card when loading the published workflow fails', () => {
- mocks.workflow = {
- data: null,
- isError: true,
- isPending: false,
- }
-
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion
- />,
- )
+ workflowState.isError = true
+ renderAccessPoints()
expect(
screen.queryByText('deployments.studio.accessPoint.noPublishedTitle'),
).not.toBeInTheDocument()
})
-
- it('does not retry forbidden published workflow requests', () => {
- render(
- <BuiltInAccessPoints
- canViewLayout
- appId="app-1"
- canDeploy
- canManageAccessPoint
- canReleaseAndVersion
- />,
- )
-
- const options = mocks.useAppWorkflow.mock.calls.at(-1)?.[1] as {
- retry: (failureCount: number, error: unknown) => boolean
- }
-
- expect(options.retry(0, createHttpError(new Response(null, { status: 403 })))).toBe(false)
- expect(options.retry(0, createHttpError(new Response(null, { status: 500 })))).toBe(true)
- expect(options.retry(3, createHttpError(new Response(null, { status: 500 })))).toBe(false)
- })
})
diff --git a/web/app/components/workflow/__tests__/custom-edge.spec.tsx b/web/app/components/workflow/__tests__/custom-edge.spec.tsx
index 37307f57931..95c98677b81 100644
--- a/web/app/components/workflow/__tests__/custom-edge.spec.tsx
+++ b/web/app/components/workflow/__tests__/custom-edge.spec.tsx
@@ -1,102 +1,129 @@
-import { screen } from '@testing-library/react'
+import type { CommonNodeType, Edge } from '../types'
+import { screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
-import { Position } from 'reactflow'
+import { Position, useEdges, useNodes } from 'reactflow'
+import { seedModelProviderQueries } from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import { seedToolProviders } from '@/test/console/tool-providers'
import CustomEdge from '../custom-edge'
-import codeDefault from '../nodes/code/default'
-import llmDefault from '../nodes/llm/default'
-import toolDefault from '../nodes/tool/default'
import { BlockEnum } from '../types'
+import { CanvasNodesCatalogProbe } from './canvas-nodes-catalog-probe'
+import { createEdge, createNode } from './fixtures'
import { renderWorkflowFlowComponent } from './workflow-test-env'
-const mockUseAvailableBlocks = vi.hoisted(() => vi.fn())
-const mockUseNodesInteractions = vi.hoisted(() => vi.fn())
+function CanvasEdgesProbe() {
+ const edges = useEdges<Edge['data']>()
+ return (
+ <output aria-label="Canvas edges">
+ {edges
+ .map((edge) => `${edge.source}:${edge.sourceHandle}->${edge.target}:${edge.targetHandle}`)
+ .join(',')}
+ </output>
+ )
+}
-vi.mock('../hooks/use-available-blocks', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../hooks/use-available-blocks')>()
-
- return {
- ...actual,
- useAvailableBlocks: (...args: unknown[]) => mockUseAvailableBlocks(...args),
- }
-})
-
-vi.mock('../hooks/use-nodes-interactions', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../hooks/use-nodes-interactions')>()
-
- return {
- ...actual,
- useNodesInteractions: () => mockUseNodesInteractions(),
- }
-})
+function CanvasNodeTypesProbe() {
+ const nodes = useNodes<CommonNodeType>()
+ return (
+ <output aria-label="Canvas node types">
+ {nodes.map((node) => `${node.id}:${node.data.type}`).join(',')}
+ </output>
+ )
+}
describe('CustomEdge insertion', () => {
it('offers compatible blocks without a start tab and inserts between the connected handles', async () => {
const user = userEvent.setup()
- const handleNodeAdd = vi.fn()
- mockUseNodesInteractions.mockReturnValue({ handleNodeAdd })
- mockUseAvailableBlocks.mockImplementation((type: BlockEnum) =>
- type === BlockEnum.Code
- ? { availablePrevBlocks: [BlockEnum.LLM, BlockEnum.Code] }
- : { availableNextBlocks: [BlockEnum.LLM, BlockEnum.Tool] },
- )
- const { queryClient } = createConsoleQueryWrapper()
+ const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '1.0.0' })
+ seedModelProviderQueries(queryClient)
seedToolProviders(queryClient, {
builtInTools: [],
customTools: [],
workflowTools: [],
mcpTools: [],
})
+ const nodes = [
+ createNode({
+ id: 'source-node',
+ position: { x: 100, y: 120 },
+ width: 240,
+ height: 80,
+ data: { type: BlockEnum.Start, title: 'Start' },
+ }),
+ createNode({
+ id: 'target-node',
+ position: { x: 600, y: 220 },
+ width: 240,
+ height: 80,
+ data: { type: BlockEnum.Code, title: 'Code' },
+ }),
+ ]
+ const edges = [
+ createEdge({
+ id: 'edge',
+ source: 'source-node',
+ sourceHandle: 'branch',
+ target: 'target-node',
+ targetHandle: 'input',
+ data: { sourceType: BlockEnum.Start, targetType: BlockEnum.Code },
+ }),
+ ]
+
renderWorkflowFlowComponent(
- <svg>
- <CustomEdge
- id="edge"
- source="source-node"
- sourceHandleId="branch"
- target="target-node"
- targetHandleId="input"
- sourceX={100}
- sourceY={120}
- sourcePosition={Position.Right}
- targetX={300}
- targetY={220}
- targetPosition={Position.Left}
- selected={false}
- data={{ sourceType: BlockEnum.Start, targetType: BlockEnum.Code, _hovering: true }}
- />
- </svg>,
+ <>
+ <svg>
+ <CustomEdge
+ id="edge"
+ source="source-node"
+ sourceHandleId="branch"
+ target="target-node"
+ targetHandleId="input"
+ sourceX={100}
+ sourceY={120}
+ sourcePosition={Position.Right}
+ targetX={600}
+ targetY={220}
+ targetPosition={Position.Left}
+ selected={false}
+ data={{ sourceType: BlockEnum.Start, targetType: BlockEnum.Code, _hovering: true }}
+ />
+ </svg>
+ <CanvasNodesCatalogProbe />
+ <CanvasNodeTypesProbe />
+ <CanvasEdgesProbe />
+ </>,
{
+ nodes,
+ edges,
queryClient,
- hooksStoreProps: {
- availableNodesMetaData: {
- nodes: [
- { metadata: llmDefault.metaData, title: 'LLM' },
- { metadata: codeDefault.metaData, title: 'Code' },
- { metadata: toolDefault.metaData, title: 'Tool' },
- ].map(({ metadata, title }) => ({
- defaultValue: {},
- metaData: { ...metadata, title },
- checkValid: () => ({ isValid: true }),
- })),
- },
- },
+ hooksStoreProps: { doSyncWorkflowDraft: async () => undefined },
+ reactFlowProps: { fitView: false },
},
)
+
await user.click(screen.getByRole('button', { name: 'workflow.common.addBlock' }))
expect(screen.queryByRole('tab', { name: 'workflow.tabs.start' })).not.toBeInTheDocument()
- const compatible = await screen.findByRole('button', { name: 'LLM' })
- expect(screen.queryByRole('button', { name: 'Code' })).not.toBeInTheDocument()
- expect(screen.queryByRole('button', { name: 'Tool' })).not.toBeInTheDocument()
- await user.click(compatible)
- expect(handleNodeAdd).toHaveBeenCalledWith(
- expect.objectContaining({ nodeType: BlockEnum.LLM }),
- {
- prevNodeId: 'source-node',
- prevNodeSourceHandle: 'branch',
- nextNodeId: 'target-node',
- nextNodeTargetHandle: 'input',
- },
- )
+ await user.click(await screen.findByRole('button', { name: 'workflow.blocks.llm' }))
+
+ await waitFor(() => {
+ const nodeIds = (screen.getByLabelText('Canvas nodes').textContent ?? '')
+ .split(',')
+ .filter(Boolean)
+ .map((id) => id.replace(/\*$/, ''))
+ expect(nodeIds).toHaveLength(3)
+ const insertedNodeId = nodeIds.find((id) => !['source-node', 'target-node'].includes(id))!
+ expect(screen.getByLabelText('Canvas node types')).toHaveTextContent(
+ `${insertedNodeId}:${BlockEnum.LLM}`,
+ )
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent(
+ `source-node:branch->${insertedNodeId}:target`,
+ )
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent(
+ `${insertedNodeId}:source->target-node:input`,
+ )
+ expect(screen.getByLabelText('Canvas edges')).not.toHaveTextContent(
+ 'source-node:branch->target-node:input',
+ )
+ })
})
})
diff --git a/web/app/components/workflow/__tests__/selection-contextmenu.spec.tsx b/web/app/components/workflow/__tests__/selection-contextmenu.spec.tsx
index bb13a53e98a..b78fb1b93d4 100644
--- a/web/app/components/workflow/__tests__/selection-contextmenu.spec.tsx
+++ b/web/app/components/workflow/__tests__/selection-contextmenu.spec.tsx
@@ -1,50 +1,35 @@
import type { Edge, Node } from '../types'
import { ContextMenu } from '@langgenius/dify-ui/context-menu'
import { detectPlatform } from '@tanstack/react-hotkeys'
-import { act, fireEvent, screen, waitFor } from '@testing-library/react'
+import { act, screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useEffect } from 'react'
-import { useNodes } from 'reactflow'
+import { useEdges, useNodes } from 'reactflow'
import { PipelineInputVarType } from '@/models/pipeline'
+import { seedModelProviderQueries } from '@/test/console/model-provider'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { seedToolProviders } from '@/test/console/tool-providers'
import { fullWorkflowAccessControl } from '../hooks-store'
import { SelectionContextmenu } from '../selection-contextmenu'
import { useWorkflowStore } from '../store'
import { BlockEnum } from '../types'
import { useWorkflowHistoryStore } from '../workflow-history-store'
+import { CanvasNodesCatalogProbe } from './canvas-nodes-catalog-probe'
import { createEdge, createNode } from './fixtures'
import { renderWorkflowFlowComponent } from './workflow-test-env'
let latestNodes: Node[] = []
+let latestEdges: Edge[] = []
let latestHistoryEvent: string | undefined
-const mockHandleNodesCopy = vi.fn()
-const mockHandleNodesDuplicate = vi.fn()
-const mockHandleNodesDelete = vi.fn()
-const mockHandleCreateSnippet = vi.fn()
-const mockCreateSnippetDialogRender = vi.fn()
const mockWorkspacePermissionKeys = vi.hoisted(() => ({
value: ['snippets.create_and_modify'] as string[],
}))
-vi.mock('@/app/components/snippets/hooks/use-create-snippet', async () => {
- const React = await vi.importActual<typeof import('react')>('react')
-
- return {
- useCreateSnippet: () => {
- const [isOpen, setIsOpen] = React.useState(false)
-
- return {
- createSnippetMutation: { isPending: false },
- handleCloseCreateSnippetDialog: () => setIsOpen(false),
- handleCreateSnippet: mockHandleCreateSnippet,
- handleOpenCreateSnippetDialog: () => setIsOpen(true),
- isCreateSnippetDialogOpen: isOpen,
- isCreatingSnippet: false,
- }
- },
- }
-})
+vi.mock('@/next/navigation', () => ({
+ useRouter: () => ({ push: vi.fn() }),
+}))
+// The dialog form is independently tested; keep this boundary focused on the prepared graph.
vi.mock('@/app/components/snippets/create-snippet-dialog', () => ({
CreateSnippetDialog: (props: {
isOpen: boolean
@@ -54,27 +39,18 @@ vi.mock('@/app/components/snippets/create-snippet-dialog', () => ({
viewport: { x: number; y: number; zoom: number }
}
inputFields?: Array<{ variable: string }>
- }) => {
- mockCreateSnippetDialogRender(props)
-
- return props.isOpen ? <div data-testid="create-snippet-dialog" /> : null
- },
+ }) =>
+ props.isOpen ? (
+ <section role="dialog" aria-label="Create snippet">
+ <output aria-label="Selected snippet graph">{JSON.stringify(props.selectedGraph)}</output>
+ <output aria-label="Snippet input fields">{JSON.stringify(props.inputFields ?? [])}</output>
+ </section>
+ ) : null,
}))
-vi.mock('../hooks/use-nodes-interactions', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../hooks/use-nodes-interactions')>()
- return {
- ...actual,
- useNodesInteractions: () => ({
- handleNodesCopy: mockHandleNodesCopy,
- handleNodesDuplicate: mockHandleNodesDuplicate,
- handleNodesDelete: mockHandleNodesDelete,
- }),
- }
-})
-
const RuntimeProbe = () => {
latestNodes = useNodes() as Node[]
+ latestEdges = useEdges() as Edge[]
const { store } = useWorkflowHistoryStore()
useEffect(() => {
@@ -110,18 +86,28 @@ const renderSelectionMenu = (options?: {
initialStoreState?: Record<string, unknown>
}) => {
latestNodes = []
+ latestEdges = []
latestHistoryEvent = undefined
const nodes = options?.nodes ?? []
const edges = options?.edges ?? []
const { queryClient } = createConsoleQueryWrapper({
+ appDslVersion: '1.0.0',
workspacePermissionKeys: mockWorkspacePermissionKeys.value,
})
+ seedModelProviderQueries(queryClient)
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
return renderWorkflowFlowComponent(
<div id="workflow-container" style={{ width: 800, height: 600 }}>
<RuntimeProbe />
+ <CanvasNodesCatalogProbe />
<SelectionMenuHarness />
</div>,
{
@@ -138,36 +124,90 @@ const renderSelectionMenu = (options?: {
describe('SelectionContextmenu', () => {
beforeEach(() => {
- vi.clearAllMocks()
latestNodes = []
+ latestEdges = []
latestHistoryEvent = undefined
- mockHandleNodesCopy.mockReset()
- mockHandleNodesDuplicate.mockReset()
- mockHandleNodesDelete.mockReset()
- mockHandleCreateSnippet.mockReset()
- mockCreateSnippetDialogRender.mockReset()
mockWorkspacePermissionKeys.value = ['snippets.create_and_modify']
})
- afterEach(() => {
- vi.useRealTimers()
+ const createSelectedGraph = () => ({
+ nodes: [
+ createNode({
+ id: 'n1',
+ selected: true,
+ width: 80,
+ height: 40,
+ data: { selected: true, _isBundled: true },
+ }),
+ createNode({
+ id: 'n2',
+ selected: true,
+ position: { x: 140, y: 0 },
+ width: 80,
+ height: 40,
+ data: { selected: true, _isBundled: true },
+ }),
+ ],
+ edges: [createEdge({ id: 'n1-n2', source: 'n1', target: 'n2' })],
})
+ const expectGraphAction = async (
+ action: 'copy' | 'duplicate' | 'delete',
+ store: ReturnType<typeof renderSelectionMenu>['store'],
+ ) => {
+ if (action === 'copy') {
+ expect(store.getState().clipboardElements.map((node) => node.id)).toEqual(['n1', 'n2'])
+ expect(store.getState().clipboardEdges.map((edge) => edge.id)).toEqual(['n1-n2'])
+ expect(latestNodes).toHaveLength(2)
+ expect(latestEdges).toHaveLength(1)
+ return
+ }
+
+ if (action === 'duplicate') {
+ await waitFor(() => expect(latestNodes).toHaveLength(4))
+ expect(latestEdges).toHaveLength(2)
+ expect(latestNodes.map((node) => node.id)).toEqual(expect.arrayContaining(['n1', 'n2']))
+ expect(latestEdges).toEqual(
+ expect.arrayContaining([
+ expect.objectContaining({ id: 'n1-n2', source: 'n1', target: 'n2' }),
+ ]),
+ )
+ const duplicatedNodeIds = latestNodes
+ .filter((node) => !['n1', 'n2'].includes(node.id))
+ .map((node) => node.id)
+ const duplicatedEdge = latestEdges.find(
+ (edge) => edge.source !== 'n1' || edge.target !== 'n2',
+ )
+ expect(duplicatedNodeIds).toHaveLength(2)
+ expect(duplicatedEdge).toBeDefined()
+ expect(new Set([duplicatedEdge!.source, duplicatedEdge!.target])).toEqual(
+ new Set(duplicatedNodeIds),
+ )
+ return
+ }
+
+ await waitFor(() => expect(latestNodes).toHaveLength(0))
+ expect(latestEdges).toHaveLength(0)
+ }
+
it.each([
- { key: 'c', action: mockHandleNodesCopy },
- { key: 'd', action: mockHandleNodesDuplicate },
- { key: 'Delete', action: mockHandleNodesDelete },
- ])('runs $key for the menu selection and closes the menu', async ({ key, action }) => {
+ { key: 'c', action: 'copy' as const },
+ { key: 'd', action: 'duplicate' as const },
+ { key: 'Delete', action: 'delete' as const },
+ ])('runs $key on the selected graph and closes the menu', async ({ key, action }) => {
const user = userEvent.setup()
- renderSelectionMenu({
- nodes: [createNode({ id: 'n1', selected: true }), createNode({ id: 'n2', selected: true })],
+ const graph = createSelectedGraph()
+ const { store } = renderSelectionMenu({
+ ...graph,
initialStoreState: { contextMenuTarget: { type: 'selection' } },
})
const item = await screen.findByRole('menuitem', { name: /common.copy/ })
act(() => item.focus())
const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
+
await user.keyboard(key.length === 1 ? `{${mod}>}${key}{/${mod}}` : `{${key}}`)
- expect(action).toHaveBeenCalledTimes(1)
+
+ await expectGraphAction(action, store)
expect(screen.queryByRole('menu')).not.toBeInTheDocument()
})
@@ -177,38 +217,21 @@ describe('SelectionContextmenu', () => {
expect(screen.queryByRole('menu')).not.toBeInTheDocument()
})
- it('should render and execute copy/duplicate/delete operations', async () => {
+ it.each([
+ { name: /common.copy/, action: 'copy' as const },
+ { name: /common.duplicate/, action: 'duplicate' as const },
+ { name: /operation.delete/, action: 'delete' as const },
+ ])('runs the $action menu item on the selected graph', async ({ name, action }) => {
const user = userEvent.setup()
- const nodes = [
- createNode({ id: 'n1', selected: true, width: 80, height: 40 }),
- createNode({ id: 'n2', selected: true, position: { x: 140, y: 0 }, width: 80, height: 40 }),
- ]
- const { store } = renderSelectionMenu({ nodes })
-
- act(() => {
- store.setState({ contextMenuTarget: { type: 'selection' } })
- })
-
- await waitFor(() => {
- expect(screen.getByRole('menuitem', { name: /common.copy/ })).toBeInTheDocument()
+ const graph = createSelectedGraph()
+ const { store } = renderSelectionMenu({
+ ...graph,
+ initialStoreState: { contextMenuTarget: { type: 'selection' } },
})
- await user.click(screen.getByRole('menuitem', { name: /common.copy/ }))
- expect(mockHandleNodesCopy).toHaveBeenCalledTimes(1)
- expect(store.getState().contextMenuTarget).toBeUndefined()
+ await user.click(await screen.findByRole('menuitem', { name }))
- act(() => {
- store.setState({ contextMenuTarget: { type: 'selection' } })
- })
- await user.click(screen.getByRole('menuitem', { name: /common.duplicate/ }))
- expect(mockHandleNodesDuplicate).toHaveBeenCalledTimes(1)
- expect(store.getState().contextMenuTarget).toBeUndefined()
-
- act(() => {
- store.setState({ contextMenuTarget: { type: 'selection' } })
- })
- await user.click(screen.getByRole('menuitem', { name: /operation.delete/ }))
- expect(mockHandleNodesDelete).toHaveBeenCalledTimes(1)
+ await expectGraphAction(action, store)
expect(store.getState().contextMenuTarget).toBeUndefined()
})
@@ -233,17 +256,17 @@ describe('SelectionContextmenu', () => {
await screen.findByRole('menuitem', { name: /Create Snippet|snippet\.createDialogTitle/ }),
)
- expect(screen.getByTestId('create-snippet-dialog')).toBeInTheDocument()
+ expect(screen.getByRole('dialog', { name: 'Create snippet' })).toBeInTheDocument()
expect(store.getState().contextMenuTarget).toBeUndefined()
- const dialogProps = mockCreateSnippetDialogRender.mock.calls.at(-1)?.[0]
- expect(dialogProps.selectedGraph.nodes.map((node: Node) => node.id)).toEqual(['n1', 'n2'])
- expect(dialogProps.selectedGraph.nodes.every((node: Node) => node.selected === false)).toBe(
- true,
- )
- expect(dialogProps.selectedGraph.edges).toHaveLength(1)
- expect(dialogProps.selectedGraph.viewport).toEqual({ x: 490, y: 380, zoom: 1 })
- expect(dialogProps.selectedGraph.edges[0]).toEqual(
+ const selectedGraph = JSON.parse(
+ screen.getByLabelText('Selected snippet graph').textContent ?? '{}',
+ ) as { nodes: Node[]; edges: Edge[]; viewport: { x: number; y: number; zoom: number } }
+ expect(selectedGraph.nodes.map((node) => node.id)).toEqual(['n1', 'n2'])
+ expect(selectedGraph.nodes.every((node) => node.selected === false)).toBe(true)
+ expect(selectedGraph.edges).toHaveLength(1)
+ expect(selectedGraph.viewport).toEqual({ x: 490, y: 380, zoom: 1 })
+ expect(selectedGraph.edges[0]).toEqual(
expect.objectContaining({
source: 'n1',
target: 'n2',
@@ -304,8 +327,10 @@ describe('SelectionContextmenu', () => {
await screen.findByRole('menuitem', { name: /Create Snippet|snippet\.createDialogTitle/ }),
)
- const dialogProps = mockCreateSnippetDialogRender.mock.calls.at(-1)?.[0]
- expect(dialogProps.inputFields).toEqual([
+ const inputFields = JSON.parse(
+ screen.getByLabelText('Snippet input fields').textContent ?? '[]',
+ ) as Array<{ label: string; variable: string; type: PipelineInputVarType; required: boolean }>
+ expect(inputFields).toEqual([
{
label: 'topic',
variable: 'topic',
@@ -319,14 +344,23 @@ describe('SelectionContextmenu', () => {
required: true,
},
])
- expect(dialogProps.selectedGraph.nodes[0].data.prompt_template).toBe(
- 'Use {{#start.topic#}} and {{#n2.answer#}}',
- )
- expect(dialogProps.selectedGraph.nodes[0].data.query_variable_selector).toEqual([
- 'start',
- 'topic',
- ])
- expect(dialogProps.selectedGraph.nodes[0].data.env_reference).toBe('{{#start.API_KEY#}}')
+ const selectedGraph = JSON.parse(
+ screen.getByLabelText('Selected snippet graph').textContent ?? '{}',
+ ) as {
+ nodes: Array<
+ Node & {
+ data: Node['data'] & {
+ prompt_template: string
+ query_variable_selector: string[]
+ env_reference: string
+ }
+ }
+ >
+ }
+ const snippetData = selectedGraph.nodes[0]!.data
+ expect(snippetData.prompt_template).toBe('Use {{#start.topic#}} and {{#n2.answer#}}')
+ expect(snippetData.query_variable_selector).toEqual(['start', 'topic'])
+ expect(snippetData.env_reference).toBe('{{#start.API_KEY#}}')
})
it.each([BlockEnum.Answer, BlockEnum.End, BlockEnum.Start])(
@@ -366,7 +400,7 @@ describe('SelectionContextmenu', () => {
})
it('should align selected nodes to the left and save history', async () => {
- vi.useFakeTimers()
+ const user = userEvent.setup()
const nodes = [
createNode({ id: 'n1', selected: true, position: { x: 20, y: 40 }, width: 40, height: 20 }),
createNode({ id: 'n2', selected: true, position: { x: 140, y: 90 }, width: 60, height: 30 }),
@@ -376,8 +410,8 @@ describe('SelectionContextmenu', () => {
nodes,
edges: [createEdge({ source: 'n1', target: 'n2' })],
initialStoreState: {
- helpLineHorizontal: { y: 10 } as never,
- helpLineVertical: { x: 10 } as never,
+ helpLineHorizontal: { top: 10, left: 0, width: 100 },
+ helpLineVertical: { top: 0, left: 10, height: 100 },
},
})
@@ -385,7 +419,7 @@ describe('SelectionContextmenu', () => {
store.setState({ contextMenuTarget: { type: 'selection' } })
})
- fireEvent.click(screen.getByRole('menuitem', { name: /operator.alignLeft/ }))
+ await user.click(screen.getByRole('menuitem', { name: /operator.alignLeft/ }))
expect(latestNodes.find((node) => node.id === 'n1')?.position.x).toBe(20)
expect(latestNodes.find((node) => node.id === 'n2')?.position.x).toBe(20)
@@ -395,12 +429,10 @@ describe('SelectionContextmenu', () => {
act(() => {
store.getState().flushPendingSync()
- vi.advanceTimersByTime(600)
})
expect(hooksStoreProps.doSyncWorkflowDraft).toHaveBeenCalled()
- expect(latestHistoryEvent).toBe('NodeDragStop')
- vi.useRealTimers()
+ await waitFor(() => expect(latestHistoryEvent).toBe('NodeDragStop'))
})
it('should distribute selected nodes horizontally', async () => {
diff --git a/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.spec.tsx b/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.spec.tsx
index a59889df18f..81761ca410e 100644
--- a/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/__tests__/node-resizer.spec.tsx
@@ -1,4 +1,3 @@
-import type { ResizeParamsWithDirection } from 'reactflow'
import type { CommonNodeType } from '@/app/components/workflow/types'
import { screen } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
@@ -6,40 +5,10 @@ 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 { seedModelProviderQueries } from '@/test/console/model-provider'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
import NodeResizer from '../node-resizer'
-const resize = vi.hoisted(() => vi.fn())
-
-// Graph mutation owns draft persistence and history; keep React Flow and the resize UI real.
-vi.mock('../../../../hooks/use-nodes-interactions', async () => {
- const { useStoreApi } = await import('reactflow')
- return {
- useNodesInteractions: () => {
- const store = useStoreApi()
- return {
- handleNodeResize: (id: string, params: ResizeParamsWithDirection) => {
- resize(id, params)
- store.getState().setNodes(
- store
- .getState()
- .getNodes()
- .map((node) =>
- node.id === id
- ? {
- ...node,
- width: params.width,
- height: params.height,
- data: { ...node.data, width: params.width, height: params.height },
- }
- : node,
- ),
- )
- },
- }
- },
- }
-})
-
function ResizableNode() {
const node = useNodes<CommonNodeType>().find((node) => node.id === 'container')!
if (!node) return null
@@ -49,14 +18,17 @@ function ResizableNode() {
<output aria-label="Node size">
{node.data.width} × {node.data.height}
</output>
+ <output aria-label="Node position">{JSON.stringify(node.position)}</output>
</>
)
}
describe('NodeResizer', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- })
+ const createQueryClient = () => {
+ const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '1.0.0' })
+ seedModelProviderQueries(queryClient)
+ return queryClient
+ }
const container = () =>
createNode({
@@ -77,25 +49,28 @@ describe('NodeResizer', () => {
it('resizes both dimensions without moving the node and shrinks only as far as its contents allow', async () => {
const user = userEvent.setup()
+ const nodes = [
+ container(),
+ createNode({
+ id: 'child',
+ parentId: 'container',
+ position: { x: 100, y: 100 },
+ width: 240,
+ height: 100,
+ }),
+ ]
renderWorkflowFlowComponent(<ResizableNode />, {
- nodes: [
- container(),
- createNode({
- id: 'child',
- parentId: 'container',
- position: { x: 100, y: 100 },
- width: 240,
- height: 100,
- }),
- ],
+ nodes,
+ historyStore: { nodes, edges: [] },
+ hooksStoreProps: { doSyncWorkflowDraft: async () => undefined },
+ queryClient: createQueryClient(),
})
const control = await screen.findByRole('button', { name: 'common.resize.node' })
control.focus()
await user.keyboard('{ArrowRight}{Shift>}{ArrowDown}{/Shift}')
expect(screen.getByRole('status', { name: 'Node size' })).toHaveTextContent('508 × 432')
- expect(resize).toHaveBeenLastCalledWith(
- 'container',
- expect.objectContaining({ x: 50, y: 70, width: 508, height: 432 }),
+ expect(screen.getByRole('status', { name: 'Node position' })).toHaveTextContent(
+ '{"x":50,"y":70}',
)
await user.keyboard('{Home}')
expect(screen.getByRole('status', { name: 'Node size' })).toHaveTextContent('356 × 220')
@@ -111,6 +86,7 @@ describe('NodeResizer', () => {
renderWorkflowFlowComponent(<ResizableNode />, {
nodes: [container()],
initialStoreState: { canvasReadOnly: true },
+ queryClient: createQueryClient(),
})
await screen.findByRole('status', { name: 'Node size' })
expect(screen.queryByRole('button', { name: 'common.resize.node' })).not.toBeInTheDocument()
diff --git a/web/app/components/workflow/nodes/_base/components/next-step/__tests__/operator.spec.tsx b/web/app/components/workflow/nodes/_base/components/next-step/__tests__/operator.spec.tsx
index 448149cb159..5366353b476 100644
--- a/web/app/components/workflow/nodes/_base/components/next-step/__tests__/operator.spec.tsx
+++ b/web/app/components/workflow/nodes/_base/components/next-step/__tests__/operator.spec.tsx
@@ -1,40 +1,17 @@
-import type { CommonNodeType } from '@/app/components/workflow/types'
-import { render, screen } from '@testing-library/react'
+import type { CommonNodeType, Edge } from '@/app/components/workflow/types'
+import { screen, waitFor } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useState } from 'react'
-import { ReactFlowProvider } from 'reactflow'
-import { renderWorkflowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { useEdges } from 'reactflow'
+import { CanvasNodesCatalogProbe } from '@/app/components/workflow/__tests__/canvas-nodes-catalog-probe'
+import { createEdge, 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 { useAvailableBlocks } from '../../../../../hooks/use-available-blocks'
-import { useNodesInteractions } from '../../../../../hooks/use-nodes-interactions'
+import { seedModelProviderQueries } from '@/test/console/model-provider'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { seedToolProviders } from '@/test/console/tool-providers'
import Operator from '../operator'
-vi.mock('../../../../../hooks/use-available-blocks', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../../../../../hooks/use-available-blocks')>()
-
- return {
- ...actual,
- useAvailableBlocks: vi.fn(),
- }
-})
-
-vi.mock('../../../../../hooks/use-nodes-interactions', async (importOriginal) => {
- const actual =
- await importOriginal<typeof import('../../../../../hooks/use-nodes-interactions')>()
-
- return {
- ...actual,
- useNodesInteractions: vi.fn(),
- }
-})
-
-const mockUseAvailableBlocks = vi.mocked(useAvailableBlocks)
-const mockUseNodesInteractions = vi.mocked(useNodesInteractions)
-
-const mockHandleNodeChange = vi.fn()
-const mockHandleNodeDelete = vi.fn()
-const mockHandleNodeDisconnect = vi.fn()
-
const defaultNodeData = {
type: BlockEnum.Code,
title: 'Code Node',
@@ -54,45 +31,86 @@ const TestHarness = () => {
)
}
-describe('NextStep operator', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUseAvailableBlocks.mockReturnValue({
- availablePrevBlocks: [BlockEnum.HttpRequest],
- availableNextBlocks: [BlockEnum.HttpRequest],
- getAvailableBlocks: vi.fn(),
- } as ReturnType<typeof useAvailableBlocks>)
- mockUseNodesInteractions.mockReturnValue({
- handleNodeChange: mockHandleNodeChange,
- handleNodeDelete: mockHandleNodeDelete,
- handleNodeDisconnect: mockHandleNodeDisconnect,
- } as unknown as ReturnType<typeof useNodesInteractions>)
+function CanvasEdgesProbe() {
+ const edges = useEdges<Edge['data']>()
+ return <output aria-label="Canvas edges">{edges.map((edge) => edge.id).join(',')}</output>
+}
+
+function renderOperator() {
+ const { queryClient } = createConsoleQueryWrapper({ appDslVersion: '1.0.0' })
+ seedModelProviderQueries(queryClient)
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
})
+ return renderWorkflowFlowComponent(
+ <>
+ <TestHarness />
+ <CanvasNodesCatalogProbe />
+ <CanvasEdgesProbe />
+ </>,
+ {
+ nodes: [
+ createNode({ id: 'previous', width: 240, height: 80 }),
+ createNode({
+ id: 'node-1',
+ position: { x: 320, y: 0 },
+ width: 240,
+ height: 80,
+ data: defaultNodeData,
+ }),
+ createNode({ id: 'next', position: { x: 640, y: 0 }, width: 240, height: 80 }),
+ ],
+ edges: [
+ createEdge({ id: 'incoming', source: 'previous', target: 'node-1' }),
+ createEdge({ id: 'outgoing', source: 'node-1', target: 'next' }),
+ createEdge({ id: 'unrelated', source: 'previous', target: 'next' }),
+ ],
+ queryClient,
+ hooksStoreProps: { doSyncWorkflowDraft: async () => undefined },
+ reactFlowProps: { fitView: false },
+ },
+ )
+}
- it('disconnects and deletes the next step from the menu', async () => {
+const canvasNodeIds = () =>
+ (screen.getByLabelText('Canvas nodes').textContent ?? '')
+ .split(',')
+ .filter(Boolean)
+ .map((id) => id.replace(/\*$/, ''))
+
+describe('NextStep operator', () => {
+ it('disconnects incident edges, then deletes the next step and closes the menu', async () => {
const user = userEvent.setup()
- render(<TestHarness />)
+ renderOperator()
await user.click(screen.getByRole('button', { name: 'workflow.common.moreActions' }))
await user.click(screen.getByRole('menuitem', { name: 'workflow.common.disconnect' }))
- expect(mockHandleNodeDisconnect).toHaveBeenCalledWith('node-1')
- expect(screen.queryByText('workflow.common.disconnect')).not.toBeInTheDocument()
+
+ await waitFor(() =>
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent('unrelated'),
+ )
+ expect(screen.getByLabelText('Canvas edges')).not.toHaveTextContent('incoming')
+ expect(screen.getByLabelText('Canvas edges')).not.toHaveTextContent('outgoing')
+ expect(canvasNodeIds()).toEqual(['previous', 'node-1', 'next'])
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument()
await user.click(screen.getByRole('button', { name: 'workflow.common.moreActions' }))
await user.click(screen.getByRole('menuitem', { name: 'common.operation.delete' }))
- expect(mockHandleNodeDelete).toHaveBeenCalledWith('node-1')
+
+ await waitFor(() => expect(canvasNodeIds()).toEqual(['previous', 'next']))
+ expect(screen.getByLabelText('Canvas edges')).toHaveTextContent('unrelated')
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument()
})
- it('opens the node selector from the change menu item with the keyboard', async () => {
+ it('opens the node selector from the change menu item', async () => {
const user = userEvent.setup()
- renderWorkflowComponent(
- <ReactFlowProvider>
- <TestHarness />
- </ReactFlowProvider>,
- )
+ renderOperator()
- await user.tab()
- await user.keyboard('{ArrowDown}{Enter}')
+ await user.click(screen.getByRole('button', { name: 'workflow.common.moreActions' }))
+ await user.click(screen.getByRole('menuitem', { name: 'workflow.panel.change' }))
expect(
await screen.findByRole('dialog', { name: 'workflow.common.addBlock' }),
diff --git a/web/app/components/workflow/operator/__tests__/zoom-in-out.spec.tsx b/web/app/components/workflow/operator/__tests__/zoom-in-out.spec.tsx
index 33c9e34a4ec..75ec2fdbee4 100644
--- a/web/app/components/workflow/operator/__tests__/zoom-in-out.spec.tsx
+++ b/web/app/components/workflow/operator/__tests__/zoom-in-out.spec.tsx
@@ -1,66 +1,44 @@
-import { detectPlatform } from '@tanstack/react-hotkeys'
-import { act, fireEvent, screen, within } from '@testing-library/react'
+import type { Shape as HooksStoreShape } from '../../hooks-store/store'
+import { act, screen, waitFor, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { useState } from 'react'
-import { renderWorkflowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { createNode } from '@/app/components/workflow/__tests__/fixtures'
+import { renderWorkflowFlowComponent } from '@/app/components/workflow/__tests__/workflow-test-env'
import { createConsoleQueryWrapper } from '@/test/console/query-data'
import ZoomInOut from '../zoom-in-out'
-const {
- mockZoomIn,
- mockZoomOut,
- mockZoomTo,
- mockFitView,
- mockViewport,
- mockHandleSyncWorkflowDraft,
- mockToggleMiniMap,
- mockToggleUserComments,
- mockToggleUserCursors,
-} = vi.hoisted(() => ({
- mockZoomIn: vi.fn(),
- mockZoomOut: vi.fn(),
- mockZoomTo: vi.fn(),
- mockFitView: vi.fn(),
- mockViewport: { zoom: 1 },
- mockHandleSyncWorkflowDraft: vi.fn(),
- mockToggleMiniMap: vi.fn(),
- mockToggleUserComments: vi.fn(),
- mockToggleUserCursors: vi.fn(),
-}))
-
let workflowReadOnly = false
let collaborationEnabled = true
-vi.mock('reactflow', async (importOriginal) => ({
- ...(await importOriginal<typeof import('reactflow')>()),
- useReactFlow: () => ({
- zoomIn: mockZoomIn,
- zoomOut: mockZoomOut,
- zoomTo: mockZoomTo,
- fitView: mockFitView,
- }),
- useViewport: () => mockViewport,
-}))
-
-vi.mock('../../hooks/use-nodes-sync-draft', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../../hooks/use-nodes-sync-draft')>()
-
- return {
- ...actual,
- useNodesSyncDraft: () => ({
- handleSyncWorkflowDraft: mockHandleSyncWorkflowDraft,
- }),
- }
-})
-
-const renderZoomInOut = (ui: React.ReactElement = <ZoomInOut />) => {
+const renderZoomInOut = ({
+ ui = <ZoomInOut />,
+ initialZoom = 1,
+}: {
+ ui?: React.ReactElement
+ initialZoom?: number
+} = {}) => {
const { queryClient } = createConsoleQueryWrapper({
systemFeatures: { enable_collaboration_mode: collaborationEnabled },
})
- return renderWorkflowComponent(ui, {
+ const doSyncWorkflowDraft = vi
+ .fn<HooksStoreShape['doSyncWorkflowDraft']>()
+ .mockResolvedValue(undefined)
+ const view = renderWorkflowFlowComponent(ui, {
queryClient,
+ nodes: [
+ createNode({ id: 'left', position: { x: 0, y: 0 }, width: 240, height: 80 }),
+ createNode({ id: 'right', position: { x: 1600, y: 400 }, width: 240, height: 80 }),
+ ],
initialStoreState: { canvasReadOnly: workflowReadOnly },
+ hooksStoreProps: { doSyncWorkflowDraft },
+ reactFlowProps: {
+ fitView: false,
+ minZoom: 0.25,
+ maxZoom: 2,
+ defaultViewport: { x: 0, y: 0, zoom: initialZoom },
+ },
})
+ return { ...view, doSyncWorkflowDraft }
}
const getZoomControls = () => ({
@@ -69,172 +47,190 @@ const getZoomControls = () => ({
zoomInTrigger: screen.getByRole('button', { name: 'workflow.operator.zoomIn' }),
})
-const openZoomMenu = () => {
- fireEvent.click(getZoomControls().label)
+const openZoomMenu = async (user: ReturnType<typeof userEvent.setup>) => {
+ await user.click(getZoomControls().label)
return within(screen.getByRole('menu'))
}
describe('workflow zoom controls', () => {
beforeEach(() => {
- vi.clearAllMocks()
- mockViewport.zoom = 1
workflowReadOnly = false
collaborationEnabled = true
})
it.each([
- { key: '1', modifier: 'Mod', zoom: undefined },
- { key: '1', modifier: 'Shift', zoom: 1 },
- { key: '5', modifier: 'Shift', zoom: 0.5 },
- ])('applies $modifier+$key from the focused zoom menu', async ({ key, modifier, zoom }) => {
+ { key: '1', modifier: 'Shift', initialZoom: 0.75, expectedLabel: '100%' },
+ { key: '5', modifier: 'Shift', initialZoom: 1, expectedLabel: '50%' },
+ ])(
+ 'applies $modifier+$key from the focused zoom menu',
+ async ({ key, modifier, initialZoom, expectedLabel }) => {
+ const user = userEvent.setup()
+ const { store, doSyncWorkflowDraft } = renderZoomInOut({ initialZoom })
+ const menu = await openZoomMenu(user)
+ const item = menu.getByRole('menuitem', { name: '200%' })
+ act(() => item.focus())
+
+ await user.keyboard(`{${modifier}>}${key}{/${modifier}}`)
+
+ await waitFor(() => expect(getZoomControls().label).toHaveAccessibleName(expectedLabel))
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument()
+ act(() => store.getState().flushPendingSync())
+ expect(doSyncWorkflowDraft).toHaveBeenCalledTimes(1)
+ },
+ )
+
+ it('fits the real graph from the menu item', async () => {
const user = userEvent.setup()
- renderZoomInOut()
- await user.click(screen.getByRole('button', { name: '100%' }))
- const item = screen.getByRole('menuitem', { name: '200%' })
- act(() => item.focus())
- const mod = detectPlatform() === 'mac' ? 'Meta' : 'Control'
- const heldKey = modifier === 'Mod' ? mod : modifier
- await user.keyboard(`{${heldKey}>}${key}{/${heldKey}}`)
- if (zoom === undefined) expect(mockFitView).toHaveBeenCalledTimes(1)
- else expect(mockZoomTo).toHaveBeenCalledExactlyOnceWith(zoom)
- expect(mockHandleSyncWorkflowDraft).toHaveBeenCalledTimes(1)
- expect(screen.queryByRole('menu')).not.toBeInTheDocument()
- })
+ const { store, doSyncWorkflowDraft } = renderZoomInOut()
+ const menu = await openZoomMenu(user)
- it('zooms out and zooms in when the viewport is within the supported range', () => {
- renderZoomInOut()
-
- const { zoomOutTrigger, zoomInTrigger } = getZoomControls()
-
- fireEvent.click(zoomOutTrigger)
- fireEvent.click(zoomInTrigger)
+ await user.click(menu.getByRole('menuitem', { name: /^workflow\.operator\.zoomToFit/ }))
- expect(mockZoomOut).toHaveBeenCalledTimes(1)
- expect(mockZoomIn).toHaveBeenCalledTimes(1)
+ await waitFor(() => expect(getZoomControls().label).toHaveAccessibleName('25%'))
+ expect(screen.queryByRole('menu')).not.toBeInTheDocument()
+ act(() => store.getState().flushPendingSync())
+ expect(doSyncWorkflowDraft).toHaveBeenCalledTimes(1)
})
- it('zooms to a preset value and syncs the draft', () => {
+ it('zooms out and in through the inline controls and reports the real viewport', async () => {
+ const user = userEvent.setup()
renderZoomInOut()
- const menu = openZoomMenu()
- fireEvent.click(menu.getByText('50%'))
+ await user.click(getZoomControls().zoomOutTrigger)
+ await waitFor(() => expect(getZoomControls().label).toHaveAccessibleName('83%'))
- expect(mockZoomTo).toHaveBeenCalledWith(0.5)
- expect(mockHandleSyncWorkflowDraft).toHaveBeenCalledTimes(1)
+ await user.click(getZoomControls().zoomInTrigger)
+ await waitFor(() => expect(getZoomControls().label).toHaveAccessibleName('100%'))
})
it.each([
- ['100%', 1],
- ['200%', 2],
- ])('zooms to %s and syncs the draft', (label, zoom) => {
- renderZoomInOut()
-
- const menu = openZoomMenu()
- fireEvent.click(menu.getByText(label))
-
- expect(mockZoomTo).toHaveBeenCalledWith(zoom)
- expect(mockHandleSyncWorkflowDraft).toHaveBeenCalledTimes(1)
- })
-
- it('toggles collaboration options without syncing the draft', () => {
- renderZoomInOut(
- <ZoomInOut
- onToggleMiniMap={mockToggleMiniMap}
- onToggleUserComments={mockToggleUserComments}
- onToggleUserCursors={mockToggleUserCursors}
- />,
- )
-
- let menu = openZoomMenu()
- fireEvent.click(menu.getByText('workflow.operator.showMiniMap'))
- expect(mockToggleMiniMap).toHaveBeenCalledTimes(1)
- expect(mockHandleSyncWorkflowDraft).not.toHaveBeenCalled()
+ { itemLabel: '50%', initialZoom: 1 },
+ { itemLabel: '100%', initialZoom: 0.75 },
+ { itemLabel: '200%', initialZoom: 1 },
+ ])('zooms to the $itemLabel preset through its menu item', async ({ itemLabel, initialZoom }) => {
+ const user = userEvent.setup()
+ const { store, doSyncWorkflowDraft } = renderZoomInOut({ initialZoom })
- menu = openZoomMenu()
- fireEvent.click(menu.getByText('workflow.operator.showUserComments'))
- expect(mockToggleUserComments).toHaveBeenCalledTimes(1)
+ const menu = await openZoomMenu(user)
+ await user.click(menu.getByRole('menuitem', { name: new RegExp(`^${itemLabel}`) }))
- menu = openZoomMenu()
- fireEvent.click(menu.getByText('workflow.operator.showUserCursors'))
- expect(mockToggleUserCursors).toHaveBeenCalledTimes(1)
+ await waitFor(() => expect(getZoomControls().label).toHaveAccessibleName(itemLabel))
+ act(() => store.getState().flushPendingSync())
+ expect(doSyncWorkflowDraft).toHaveBeenCalledTimes(1)
})
- it('exposes display settings as checked menu items and updates them with the keyboard', async () => {
+ it('updates controlled collaboration settings without saving the graph', async () => {
const user = userEvent.setup()
const DisplaySettings = () => {
const [showMiniMap, setShowMiniMap] = useState(true)
+ const [showUserCursors, setShowUserCursors] = useState(false)
+ const [showUserComments, setShowUserComments] = useState(true)
return (
<ZoomInOut
showMiniMap={showMiniMap}
onToggleMiniMap={() => setShowMiniMap((value) => !value)}
- showUserCursors={false}
- showUserComments
+ showUserCursors={showUserCursors}
+ onToggleUserCursors={() => setShowUserCursors((value) => !value)}
+ showUserComments={showUserComments}
+ onToggleUserComments={() => setShowUserComments((value) => !value)}
/>
)
}
- renderZoomInOut(<DisplaySettings />)
+ const { store, doSyncWorkflowDraft } = renderZoomInOut({ ui: <DisplaySettings /> })
- await user.click(screen.getByRole('button', { name: '100%' }))
- const miniMap = screen.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' })
- expect(miniMap).toBeChecked()
+ let menu = await openZoomMenu(user)
+ expect(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }),
+ ).toBeChecked()
expect(
- screen.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserCursors' }),
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserCursors' }),
).not.toBeChecked()
expect(
- screen.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserComments' }),
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserComments' }),
).toBeChecked()
- expect(screen.getByRole('menuitem', { name: '200%' })).toBeInTheDocument()
- miniMap.focus()
+ await user.click(menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }))
+ menu = await openZoomMenu(user)
+ expect(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }),
+ ).not.toBeChecked()
+ act(() => menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }).focus())
await user.keyboard('{Enter}')
- await user.click(screen.getByRole('button', { name: '100%' }))
+ menu = await openZoomMenu(user)
+ expect(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }),
+ ).toBeChecked()
+ await user.click(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserCursors' }),
+ )
+ menu = await openZoomMenu(user)
expect(
- screen.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }),
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserCursors' }),
+ ).toBeChecked()
+ await user.click(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserComments' }),
+ )
+ menu = await openZoomMenu(user)
+ expect(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showUserComments' }),
).not.toBeChecked()
- expect(mockHandleSyncWorkflowDraft).not.toHaveBeenCalled()
+ act(() => store.getState().flushPendingSync())
+ expect(doSyncWorkflowDraft).not.toHaveBeenCalled()
})
- it('keeps the show-user-comments action disabled in comment mode', () => {
- renderZoomInOut(<ZoomInOut isCommentMode onToggleUserComments={mockToggleUserComments} />)
-
- const menu = openZoomMenu()
- fireEvent.click(menu.getByText('workflow.operator.showUserComments'))
-
- expect(mockToggleUserComments).not.toHaveBeenCalled()
+ it('keeps the show-user-comments action disabled in comment mode', async () => {
+ const user = userEvent.setup()
+ const onToggleUserComments = vi.fn()
+ renderZoomInOut({
+ ui: <ZoomInOut isCommentMode onToggleUserComments={onToggleUserComments} />,
+ })
+
+ const menu = await openZoomMenu(user)
+ const comments = menu.getByRole('menuitemcheckbox', {
+ name: 'workflow.operator.showUserComments',
+ })
+ expect(comments).toHaveAttribute('aria-disabled', 'true')
+ await user.click(comments)
+ expect(onToggleUserComments).not.toHaveBeenCalled()
})
- it('does not open the menu when the workflow is read only', () => {
+ it('does not open the menu when the workflow is read only', async () => {
+ const user = userEvent.setup()
workflowReadOnly = true
renderZoomInOut()
- fireEvent.click(getZoomControls().label)
-
+ expect(getZoomControls().label).toBeDisabled()
+ await user.click(getZoomControls().label)
expect(screen.queryByRole('menu')).not.toBeInTheDocument()
})
- it('blocks inline zooming out at the minimum viewport scale', () => {
- mockViewport.zoom = 0.25
+ it('disables inline zoom controls at the supported viewport bounds', async () => {
+ const user = userEvent.setup()
renderZoomInOut()
- fireEvent.click(getZoomControls().zoomOutTrigger)
- expect(mockZoomOut).not.toHaveBeenCalled()
- })
-
- it('blocks inline zooming in at the maximum viewport scale', () => {
- mockViewport.zoom = 2
- renderZoomInOut()
+ let menu = await openZoomMenu(user)
+ await user.click(menu.getByRole('menuitem', { name: '25%' }))
+ await waitFor(() => expect(getZoomControls().zoomOutTrigger).toBeDisabled())
- fireEvent.click(getZoomControls().zoomInTrigger)
- expect(mockZoomIn).not.toHaveBeenCalled()
+ menu = await openZoomMenu(user)
+ await user.click(menu.getByRole('menuitem', { name: '200%' }))
+ await waitFor(() => expect(getZoomControls().zoomInTrigger).toBeDisabled())
})
- it('renders collaboration menu entries only when collaboration is enabled', () => {
+ it('renders collaboration menu entries only when collaboration is enabled', async () => {
+ const user = userEvent.setup()
collaborationEnabled = false
renderZoomInOut()
- const menu = openZoomMenu()
- expect(menu.getByText('workflow.operator.showMiniMap')).toBeInTheDocument()
- expect(menu.queryByText('workflow.operator.showUserComments')).not.toBeInTheDocument()
- expect(menu.queryByText('workflow.operator.showUserCursors')).not.toBeInTheDocument()
+ const menu = await openZoomMenu(user)
+ expect(
+ menu.getByRole('menuitemcheckbox', { name: 'workflow.operator.showMiniMap' }),
+ ).toBeInTheDocument()
+ expect(
+ menu.queryByRole('menuitemcheckbox', { name: 'workflow.operator.showUserComments' }),
+ ).not.toBeInTheDocument()
+ expect(
+ menu.queryByRole('menuitemcheckbox', { name: 'workflow.operator.showUserCursors' }),
+ ).not.toBeInTheDocument()
})
})