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 real workflow variable and single-run behavior (#44641)

Stephen Zhoub2bd99af1130
diff --git a/web/app/components/workflow/hooks/__tests__/use-fetch-workflow-inspect-vars.spec.ts b/web/app/components/workflow/hooks/__tests__/use-fetch-workflow-inspect-vars.spec.ts
index 22f51cf3e1d..cb2c4cc3c77 100644
--- a/web/app/components/workflow/hooks/__tests__/use-fetch-workflow-inspect-vars.spec.ts
+++ b/web/app/components/workflow/hooks/__tests__/use-fetch-workflow-inspect-vars.spec.ts
@@ -1,17 +1,17 @@
import type { SchemaDefinitionItemResponse } from '@dify/contracts/api/console/spec/types.gen'
import type { ToolWithProvider } from '../../types'
import type { VarInInspect } from '@/types/workflow'
-import { act, waitFor } from '@testing-library/react'
+import { act } from '@testing-library/react'
+import { useReactFlow } from 'reactflow'
+import { consoleQuery } from '@/service/console'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { seedToolProviders } from '@/test/console/tool-providers'
import { createNode } from '../../__tests__/fixtures'
-import { renderWorkflowFlowHook } from '../../__tests__/workflow-test-env'
-import { BlockEnum, VarType } from '../../types'
+import { renderWorkflowCanvasHook } from '../../__tests__/workflow-test-env'
+import { BlockEnum, NodeRunningStatus, VarType } from '../../types'
import { useSetWorkflowVarsWithValue } from '../use-fetch-workflow-inspect-vars'
const mockFetchAllInspectVars = vi.hoisted(() => vi.fn())
-const mockInvalidateConversationVarValues = vi.hoisted(() => vi.fn())
-const mockInvalidateSysVarValues = vi.hoisted(() => vi.fn())
-const mockHandleCancelAllNodeSuccessStatus = vi.hoisted(() => vi.fn())
-
const schemaTypeDefinitions: SchemaDefinitionItemResponse[] = [
{
name: 'simple',
@@ -22,47 +22,10 @@ const schemaTypeDefinitions: SchemaDefinitionItemResponse[] = [
},
]
-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, {
- 'workspaces.current.tools.builtin.get': async () => [],
- 'workspaces.current.tools.api.get': async () => [],
- 'workspaces.current.tools.workflow.get': async () => [],
- 'workspaces.current.tools.mcp.get': async () => [],
- }),
- }
-})
-
-vi.mock('@/service/use-workflow', () => ({
- useInvalidateConversationVarValues: () => mockInvalidateConversationVarValues,
- useInvalidateSysVarValues: () => mockInvalidateSysVarValues,
-}))
-
vi.mock('@/service/workflow', () => ({
fetchAllInspectVars: (...args: unknown[]) => mockFetchAllInspectVars(...args),
}))
-vi.mock('../use-nodes-interactions-without-sync', () => ({
- useNodesInteractionsWithoutSync: () => ({
- handleCancelAllNodeSuccessStatus: mockHandleCancelAllNodeSuccessStatus,
- }),
-}))
-
-vi.mock(
- '@/app/components/workflow/nodes/_base/components/variable/use-match-schema-type',
- async (importOriginal) => ({
- ...(await importOriginal<
- typeof import('@/app/components/workflow/nodes/_base/components/variable/use-match-schema-type')
- >()),
- default: () => ({
- schemaTypeDefinitions,
- }),
- }),
-)
-
const createInspectVar = (overrides: Partial<VarInInspect> = {}): VarInInspect => ({
id: 'var-1',
type: 'node',
@@ -89,13 +52,47 @@ const nodes = [
title: 'Code',
desc: '',
outputs: { answer: { type: VarType.string } },
+ _runningStatus: NodeRunningStatus.Succeeded,
},
}),
]
+const variableQueryKeys = [
+ consoleQuery.apps.byAppId.workflows.draft.conversationVariables.get,
+ consoleQuery.apps.byAppId.workflows.draft.systemVariables.get,
+].map((endpoint) => endpoint.queryKey({ input: { params: { app_id: 'app-1' } } }))
+
+function setup(canvasNodes = nodes) {
+ const { queryClient } = createConsoleQueryWrapper()
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
+ queryClient.setQueryData(
+ consoleQuery.spec.schemaDefinitions.get.queryKey(),
+ schemaTypeDefinitions,
+ )
+ for (const key of variableQueryKeys)
+ queryClient.setQueryData(key, {
+ items: [{ ...createInspectVar(), value: 'cached', full_content: null }],
+ })
+ return {
+ ...renderWorkflowCanvasHook(
+ () => ({
+ ...useSetWorkflowVarsWithValue(),
+ getNodes: useReactFlow().getNodes,
+ }),
+ { nodes: canvasNodes, queryClient, initialStoreState: { dataSourceList: [] } },
+ ),
+ queryClient,
+ }
+}
+
describe('use-fetch-workflow-inspect-vars', () => {
beforeEach(() => {
- vi.resetAllMocks()
+ mockFetchAllInspectVars.mockReset()
})
it('fetches inspect vars, invalidates cached values, and stores node vars with their real output metadata', async () => {
@@ -107,25 +104,20 @@ describe('use-fetch-workflow-inspect-vars', () => {
}),
])
- const { result, store } = renderWorkflowFlowHook(() => useSetWorkflowVarsWithValue(), {
- nodes,
- initialStoreState: {
- dataSourceList: [],
- },
- })
+ const { result, store, queryClient } = setup()
await act(async () => {
await result.current.fetchInspectVars({})
})
- expect(mockInvalidateConversationVarValues).toHaveBeenCalledTimes(1)
- expect(mockInvalidateSysVarValues).toHaveBeenCalledTimes(1)
+ for (const key of variableQueryKeys)
+ expect(queryClient.getQueryState(key)?.isInvalidated).toBe(true)
expect(mockFetchAllInspectVars).toHaveBeenCalledWith({
kind: 'app',
appId: 'app-1',
mode: 'workflow',
})
- expect(mockHandleCancelAllNodeSuccessStatus).toHaveBeenCalledTimes(1)
+ expect(result.current.getNodes()[0]!.data._runningStatus).toBeUndefined()
expect(store.getState().nodesWithInspectVars).toEqual([
expect.objectContaining({
nodeId: 'node-1',
@@ -158,12 +150,7 @@ describe('use-fetch-workflow-inspect-vars', () => {
dataSourceList: [],
}
- const { result, store } = renderWorkflowFlowHook(() => useSetWorkflowVarsWithValue(), {
- nodes,
- initialStoreState: {
- dataSourceList: [],
- },
- })
+ const { result, store } = setup()
await act(async () => {
await result.current.fetchInspectVars({
@@ -174,13 +161,11 @@ describe('use-fetch-workflow-inspect-vars', () => {
})
})
- await waitFor(() => {
- expect(mockFetchAllInspectVars).not.toHaveBeenCalled()
- expect(store.getState().nodesWithInspectVars[0]?.vars[0]).toMatchObject({
- id: 'var-2',
- value: 'passed-in',
- schemaType: undefined,
- })
+ expect(mockFetchAllInspectVars).not.toHaveBeenCalled()
+ expect(store.getState().nodesWithInspectVars[0]?.vars[0]).toMatchObject({
+ id: 'var-2',
+ value: 'passed-in',
+ schemaType: undefined,
})
})
})
@@ -225,9 +210,7 @@ it('derives schema enrichment from the passed-in tool catalog and schema definit
},
],
}
- const { result, store } = renderWorkflowFlowHook(() => useSetWorkflowVarsWithValue(), {
- nodes: toolNodes,
- })
+ const { result, store } = setup(toolNodes)
await act(async () =>
result.current.fetchInspectVars({
passInVars: true,
diff --git a/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.ts b/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.ts
deleted file mode 100644
index 87c121bc9be..00000000000
--- a/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.ts
+++ /dev/null
@@ -1,295 +0,0 @@
-import type { Node, NodeOutPutVar, Var } from '../../types'
-import { useSnippetDraftStore } from '@/app/components/snippets/draft-store'
-import { renderEditorHook as renderHook } from '@/app/components/workflow/editor-resource/__tests__/render'
-import { PipelineInputVarType } from '@/models/pipeline'
-import { BlockEnum, VarType } from '../../types'
-import useNodesAvailableVarList, {
- useGetNodesAvailableVarList,
-} from '../use-nodes-available-var-list'
-
-const mockGetTreeLeafNodes = vi.hoisted(() => vi.fn())
-const mockGetBeforeNodesInSameBranchIncludeParent = vi.hoisted(() => vi.fn())
-const mockGetNodeAvailableVars = vi.hoisted(() => vi.fn())
-vi.mock('../use-workflow', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../use-workflow')>()
-
- return {
- ...actual,
-
- useWorkflow: () => ({
- getTreeLeafNodes: mockGetTreeLeafNodes,
- getBeforeNodesInSameBranchIncludeParent: mockGetBeforeNodesInSameBranchIncludeParent,
- }),
- }
-})
-
-vi.mock('../use-workflow-variables', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../use-workflow-variables')>()
-
- return {
- ...actual,
- useWorkflowVariables: () => ({
- getNodeAvailableVars: mockGetNodeAvailableVars,
- }),
- }
-})
-
-const createNode = (overrides: Partial<Node> = {}): Node =>
- ({
- id: 'node-1',
- type: 'custom',
- position: { x: 0, y: 0 },
- data: {
- type: BlockEnum.LLM,
- title: 'Node',
- desc: '',
- },
- ...overrides,
- }) as Node
-
-const outputVars: NodeOutPutVar[] = [
- {
- nodeId: 'vars-node',
- title: 'Vars',
- vars: [
- {
- variable: 'name',
- type: VarType.string,
- },
- ] satisfies Var[],
- },
-]
-
-const outputVarsWithSystemVars: NodeOutPutVar[] = [
- {
- nodeId: 'vars-node',
- title: 'Vars',
- vars: [
- {
- variable: 'answer',
- type: VarType.string,
- },
- {
- variable: 'sys.files',
- type: VarType.arrayFile,
- },
- ] satisfies Var[],
- },
- {
- nodeId: 'global',
- title: 'SYSTEM',
- vars: [
- {
- variable: 'sys.user_id',
- type: VarType.string,
- },
- ] satisfies Var[],
- },
-]
-
-describe('useNodesAvailableVarList', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- useSnippetDraftStore.getState().reset()
- mockGetBeforeNodesInSameBranchIncludeParent.mockImplementation((nodeId: string) => [
- createNode({ id: `before-${nodeId}` }),
- ])
- mockGetTreeLeafNodes.mockImplementation((nodeId: string) => [
- createNode({ id: `leaf-${nodeId}` }),
- ])
- mockGetNodeAvailableVars.mockReturnValue(outputVars)
- })
- afterEach(() => useSnippetDraftStore.getState().reset())
-
- it('builds availability per node, carrying loop nodes and parent iteration context', () => {
- const loopNode = createNode({
- id: 'loop-1',
- data: {
- type: BlockEnum.Loop,
- title: 'Loop',
- desc: '',
- },
- })
- const childNode = createNode({
- id: 'child-1',
- parentId: 'loop-1',
- data: {
- type: BlockEnum.LLM,
- title: 'Writer',
- desc: '',
- },
- })
- const filterVar = vi.fn(() => true)
-
- const { result } = renderHook(
- () =>
- useNodesAvailableVarList([loopNode, childNode], {
- filterVar,
- hideEnv: true,
- hideChatVar: true,
- }),
- { resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' } },
- )
-
- expect(mockGetBeforeNodesInSameBranchIncludeParent).toHaveBeenCalledWith('loop-1')
- expect(mockGetBeforeNodesInSameBranchIncludeParent).toHaveBeenCalledWith('child-1')
- expect(result.current['loop-1']?.availableNodes.map((node) => node.id)).toEqual([
- 'before-loop-1',
- 'loop-1',
- ])
- expect(result.current['child-1']?.availableVars).toEqual(outputVars)
- expect(mockGetNodeAvailableVars).toHaveBeenNthCalledWith(
- 2,
- expect.objectContaining({
- parentNode: loopNode,
- isChatflow: true,
- filterVar,
- hideEnv: true,
- hideChatVar: true,
- }),
- )
- })
-
- it('adds snippet input fields as virtual start variables on snippet canvases', () => {
- useSnippetDraftStore.getState().setInputFields([
- {
- type: PipelineInputVarType.textInput,
- label: 'Topic',
- variable: 'topic',
- required: true,
- },
- ])
-
- const currentNode = createNode({ id: 'node-a' })
-
- const { result } = renderHook(
- () =>
- useNodesAvailableVarList([currentNode], {
- filterVar: () => true,
- }),
- { resource: { kind: 'snippet', snippetId: 'snippet-1' } },
- )
-
- expect(result.current['node-a']?.availableNodes[0]).toEqual(
- expect.objectContaining({
- id: 'start',
- data: expect.objectContaining({
- type: BlockEnum.Start,
- }),
- }),
- )
- expect(result.current['node-a']?.availableVars[0]).toEqual(
- expect.objectContaining({
- nodeId: 'start',
- isStartNode: true,
- vars: [
- expect.objectContaining({
- variable: 'topic',
- type: VarType.string,
- }),
- ],
- }),
- )
- })
-
- it('filters system variables on snippet canvases', () => {
- mockGetNodeAvailableVars.mockReturnValue(outputVarsWithSystemVars)
-
- const currentNode = createNode({ id: 'node-a' })
-
- const { result } = renderHook(
- () =>
- useNodesAvailableVarList([currentNode], {
- filterVar: () => true,
- }),
- { resource: { kind: 'snippet', snippetId: 'snippet-1' } },
- )
-
- expect(result.current['node-a']?.availableVars).toEqual([
- {
- nodeId: 'vars-node',
- title: 'Vars',
- vars: [
- {
- variable: 'answer',
- type: VarType.string,
- },
- ],
- },
- ])
- })
-
- it('keeps system variables outside snippet canvases', () => {
- mockGetNodeAvailableVars.mockReturnValue(outputVarsWithSystemVars)
-
- const currentNode = createNode({ id: 'node-a' })
-
- const { result } = renderHook(
- () =>
- useNodesAvailableVarList([currentNode], {
- filterVar: () => true,
- }),
- { resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' } },
- )
-
- expect(result.current['node-a']?.availableVars).toEqual(outputVarsWithSystemVars)
- })
-
- it('returns a callback version that can use leaf nodes or caller-provided nodes', () => {
- const firstNode = createNode({ id: 'node-a' })
- const secondNode = createNode({ id: 'node-b' })
- const filterVar = vi.fn(() => true)
- const passedInAvailableNodes = [createNode({ id: 'manual-node' })]
-
- const { result } = renderHook(() => useGetNodesAvailableVarList(), {
- resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' },
- })
-
- const leafMap = result.current.getNodesAvailableVarList([firstNode], {
- onlyLeafNodeVar: true,
- filterVar,
- })
- const manualMap = result.current.getNodesAvailableVarList([secondNode], {
- filterVar,
- passedInAvailableNodes,
- })
-
- expect(mockGetTreeLeafNodes).toHaveBeenCalledWith('node-a')
- expect(leafMap['node-a']?.availableNodes.map((node) => node.id)).toEqual(['leaf-node-a'])
- expect(manualMap['node-b']?.availableNodes).toBe(passedInAvailableNodes)
- })
- it('keeps caller-provided nodes unchanged and isolates each loop availability list', () => {
- const first = createNode({
- id: 'loop-a',
- data: { type: BlockEnum.Loop, title: 'First', desc: '' },
- })
- const second = createNode({
- id: 'loop-b',
- data: { type: BlockEnum.Loop, title: 'Second', desc: '' },
- })
- const source = createNode({ id: 'source' })
- const passedInAvailableNodes = [source]
- const { result, rerender } = renderHook(
- () => ({
- availability: useNodesAvailableVarList([first, second], {
- passedInAvailableNodes,
- filterVar: () => true,
- }),
- getAvailability: useGetNodesAvailableVarList().getNodesAvailableVarList,
- }),
- { resource: { kind: 'app', appId: 'app-1', mode: 'workflow' } },
- )
- rerender()
- for (const availability of [
- result.current.availability,
- result.current.getAvailability([first, second], {
- passedInAvailableNodes,
- filterVar: () => true,
- }),
- ]) {
- expect(availability['loop-a']!.availableNodes).toEqual([source, first])
- expect(availability['loop-b']!.availableNodes).toEqual([source, second])
- }
- expect(passedInAvailableNodes).toEqual([source])
- })
-})
diff --git a/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.tsx b/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.tsx
new file mode 100644
index 00000000000..4b602dbf6c1
--- /dev/null
+++ b/web/app/components/workflow/hooks/__tests__/use-nodes-available-var-list.spec.tsx
@@ -0,0 +1,204 @@
+import type { ReactNode } from 'react'
+import { useSnippetDraftStore } from '@/app/components/snippets/draft-store'
+import { PipelineInputVarType } from '@/models/pipeline'
+import { consoleQuery } from '@/service/console'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { seedToolProviders } from '@/test/console/tool-providers'
+import { CanvasNodesCatalogProbe } from '../../__tests__/canvas-nodes-catalog-probe'
+import { createEdge, createNode } from '../../__tests__/fixtures'
+import { renderWorkflowCanvasHook } from '../../__tests__/workflow-test-env'
+import { BlockEnum, VarType } from '../../types'
+import useNodesAvailableVarList, {
+ useGetNodesAvailableVarList,
+} from '../use-nodes-available-var-list'
+
+const source = createNode({ id: 'source', data: { outputs: { answer: { type: VarType.string } } } })
+const current = createNode({ id: 'current' })
+const edges = [createEdge({ source: source.id, target: current.id })]
+
+function options() {
+ const { queryClient } = createConsoleQueryWrapper()
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
+ queryClient.setQueryData(consoleQuery.spec.schemaDefinitions.get.queryKey(), [])
+ return { queryClient, nodes: [source, current], edges }
+}
+
+describe('useNodesAvailableVarList', () => {
+ it('includes loop variables for the loop and its child while hiding environment and chat variables', () => {
+ const loop = createNode({
+ id: 'loop',
+ data: {
+ type: BlockEnum.Loop,
+ loop_variables: [
+ {
+ id: 'counter',
+ label: 'counter',
+ var_type: VarType.number,
+ value_type: 'constant',
+ value: 0,
+ },
+ ],
+ },
+ })
+ const child = createNode({ id: 'child', parentId: loop.id, data: { isInLoop: true } })
+ const { result } = renderWorkflowCanvasHook(
+ () =>
+ useNodesAvailableVarList([loop, child], {
+ filterVar: () => true,
+ hideEnv: true,
+ hideChatVar: true,
+ }),
+ {
+ ...options(),
+ nodes: [source, loop, child],
+ edges: [createEdge({ source: source.id, target: loop.id })],
+ resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' },
+ initialStoreState: {
+ environmentVariables: [
+ { id: 'env', name: 'secret', value: 'hidden', value_type: 'string', description: '' },
+ ],
+ conversationVariables: [
+ { id: 'chat', name: 'history', value: '', value_type: VarType.string, description: '' },
+ ],
+ },
+ },
+ )
+ for (const id of [loop.id, child.id]) {
+ expect(result.current[id]!.availableNodes.map((node) => node.id)).toEqual(['source', 'loop'])
+ const vars = result.current[id]!.availableVars
+ expect(vars.find((group) => group.nodeId === 'source')?.vars).toEqual([
+ expect.objectContaining({ variable: 'answer', type: VarType.string }),
+ ])
+ expect(vars.find((group) => group.nodeId === 'loop')?.vars).toEqual([
+ expect.objectContaining({ variable: 'counter', type: VarType.number }),
+ ])
+ expect(vars.some((group) => group.nodeId === 'env' || group.nodeId === 'conversation')).toBe(
+ false,
+ )
+ }
+ })
+
+ it('adds snippet input fields as virtual start variables on snippet canvases', () => {
+ useSnippetDraftStore
+ .getState()
+ .setInputFields([
+ { type: PipelineInputVarType.textInput, label: 'Topic', variable: 'topic', required: true },
+ ])
+ const { result } = renderWorkflowCanvasHook(() => useNodesAvailableVarList([current]), {
+ ...options(),
+ resource: { kind: 'snippet', snippetId: 'snippet-1' },
+ })
+ expect(result.current.current!.availableNodes.map((node) => node.id)).toEqual([
+ 'start',
+ 'source',
+ ])
+ expect(result.current.current!.availableVars[0]).toMatchObject({
+ nodeId: 'start',
+ isStartNode: true,
+ vars: [{ variable: 'topic', type: VarType.string }],
+ })
+ })
+
+ it('filters system variables on snippet canvases', () => {
+ const { result } = renderWorkflowCanvasHook(() => useNodesAvailableVarList([current]), {
+ ...options(),
+ resource: { kind: 'snippet', snippetId: 'snippet-1' },
+ })
+ expect(result.current.current!.availableVars).toEqual([
+ expect.objectContaining({
+ nodeId: 'source',
+ vars: [expect.objectContaining({ variable: 'answer', type: VarType.string })],
+ }),
+ ])
+ })
+
+ it('keeps system variables outside snippet canvases', () => {
+ const { result } = renderWorkflowCanvasHook(() => useNodesAvailableVarList([current]), {
+ ...options(),
+ resource: { kind: 'app', appId: 'app-1', mode: 'advanced-chat' },
+ })
+ expect(
+ result.current.current!.availableVars.find((group) => group.nodeId === 'global')?.vars,
+ ).toEqual(expect.arrayContaining([expect.objectContaining({ variable: 'sys.user_id' })]))
+ expect(
+ result.current.current!.availableVars.find((group) => group.nodeId === 'source')?.vars,
+ ).toEqual([expect.objectContaining({ variable: 'answer' })])
+ })
+
+ it('returns leaf variables or caller-provided variables through the callback API', () => {
+ const start = createNode({ id: 'start', data: { type: BlockEnum.Start, variables: [] } })
+ const manual = createNode({
+ id: 'manual',
+ data: { outputs: { count: { type: VarType.number } } },
+ })
+ function Catalog({ children }: { children: ReactNode }) {
+ return (
+ <>
+ <CanvasNodesCatalogProbe />
+ {children}
+ </>
+ )
+ }
+ const { result } = renderWorkflowCanvasHook(() => useGetNodesAvailableVarList(), {
+ ...options(),
+ nodes: [start, source, current, manual],
+ edges: [createEdge({ source: start.id, target: source.id }), ...edges],
+ wrapper: Catalog,
+ })
+ const leaf = result.current.getNodesAvailableVarList([current], {
+ onlyLeafNodeVar: true,
+ filterVar: () => true,
+ }).current!
+ const supplied = result.current.getNodesAvailableVarList([current], {
+ passedInAvailableNodes: [manual],
+ filterVar: () => true,
+ }).current!
+ expect(leaf.availableNodes.map((node) => node.id)).toEqual(['source'])
+ expect(leaf.availableVars.find((group) => group.nodeId === 'source')?.vars).toEqual([
+ expect.objectContaining({ variable: 'answer' }),
+ ])
+ expect(supplied.availableNodes.map((node) => node.id)).toEqual(['manual'])
+ expect(supplied.availableVars.find((group) => group.nodeId === 'manual')?.vars).toEqual([
+ expect.objectContaining({ variable: 'count', type: VarType.number }),
+ ])
+ })
+
+ it('keeps caller-provided nodes unchanged and isolates each loop availability list', () => {
+ const first = createNode({ id: 'loop-a', data: { type: BlockEnum.Loop } })
+ const second = createNode({ id: 'loop-b', data: { type: BlockEnum.Loop } })
+ const passedInAvailableNodes = [source]
+ const { result, rerender } = renderWorkflowCanvasHook(
+ () => ({
+ availability: useNodesAvailableVarList([first, second], {
+ passedInAvailableNodes,
+ filterVar: () => true,
+ }),
+ getAvailability: useGetNodesAvailableVarList().getNodesAvailableVarList,
+ }),
+ { ...options(), nodes: [source, first, second], edges: [] },
+ )
+ rerender()
+ for (const availability of [
+ result.current.availability,
+ result.current.getAvailability([first, second], {
+ passedInAvailableNodes,
+ filterVar: () => true,
+ }),
+ ]) {
+ expect(availability['loop-a']!.availableNodes.map((node) => node.id)).toEqual([
+ 'source',
+ 'loop-a',
+ ])
+ expect(availability['loop-b']!.availableNodes.map((node) => node.id)).toEqual([
+ 'source',
+ 'loop-b',
+ ])
+ }
+ expect(passedInAvailableNodes).toEqual([source])
+ })
+})
diff --git a/web/app/components/workflow/nodes/__tests__/single-run-graph-options.ts b/web/app/components/workflow/nodes/__tests__/single-run-graph-options.ts
new file mode 100644
index 00000000000..7a0018fbeb6
--- /dev/null
+++ b/web/app/components/workflow/nodes/__tests__/single-run-graph-options.ts
@@ -0,0 +1,52 @@
+import type { CommonNodeType } from '../../types'
+import { ModelFeatureEnum } from '@/app/components/header/account-setting/model-provider-page/declarations'
+import { consoleQuery } from '@/service/console'
+import {
+ createCatalogModelFixture,
+ createModelCatalogFixture,
+ seedModelProviderQueries,
+} from '@/test/console/model-provider'
+import { createConsoleQueryWrapper } from '@/test/console/query-data'
+import { seedToolProviders } from '@/test/console/tool-providers'
+import { createEdge, createNode, createStartNode } from '../../__tests__/fixtures'
+import { InputVarType, VarType } from '../../types'
+
+// Both single-run form owners resolve vision capabilities and file types from these real inputs.
+export function createSingleRunGraphOptions(payload: CommonNodeType, vision = true) {
+ const { queryClient } = createConsoleQueryWrapper()
+ seedModelProviderQueries(queryClient, [
+ createModelCatalogFixture({
+ models: [
+ createCatalogModelFixture({
+ model: 'gpt-4o',
+ features: vision ? [ModelFeatureEnum.vision] : [],
+ }),
+ ],
+ }),
+ ])
+ seedToolProviders(queryClient, {
+ builtInTools: [],
+ customTools: [],
+ workflowTools: [],
+ mcpTools: [],
+ })
+ queryClient.setQueryData(consoleQuery.spec.schemaDefinitions.get.queryKey(), [])
+ const nodes = [
+ createStartNode({
+ id: 'node-3',
+ data: {
+ title: 'Vision Source',
+ variables: [
+ { variable: 'image', label: 'Image', type: InputVarType.singleFile, required: false },
+ ],
+ },
+ }),
+ createNode({ id: 'node-1', data: { outputs: { query: { type: VarType.string } } } }),
+ createNode({ id: 'node-2', data: { outputs: { answer: { type: VarType.string } } } }),
+ createNode({ id: 'current-node', data: payload }),
+ ]
+ const edges = nodes
+ .slice(1)
+ .map((node, i) => createEdge({ source: nodes[i]!.id, target: node.id }))
+ return { queryClient, nodes, edges }
+}
diff --git a/web/app/components/workflow/nodes/iteration/__tests__/use-single-run-form-params.spec.ts b/web/app/components/workflow/nodes/iteration/__tests__/use-single-run-form-params.spec.ts
index b52ff510641..58ccdc4bb27 100644
--- a/web/app/components/workflow/nodes/iteration/__tests__/use-single-run-form-params.spec.ts
+++ b/web/app/components/workflow/nodes/iteration/__tests__/use-single-run-form-params.spec.ts
@@ -1,23 +1,12 @@
-import type { InputVar, Node } from '../../../types'
+import type { InputVar, Variable } from '../../../types'
import type { IterationNodeType } from '../types'
-import { act, renderHook } from '@testing-library/react'
+import { act } from '@testing-library/react'
import { useState } from 'react'
import { BlockEnum, ErrorHandleMode, InputVarType, VarType } from '@/app/components/workflow/types'
+import { createEdge, createNode } from '../../../__tests__/fixtures'
+import { renderWorkflowCanvasHook as renderHook } from '../../../__tests__/workflow-test-env'
import useSingleRunFormParams from '../use-single-run-form-params'
-const mockUseIsNodeInIteration = vi.hoisted(() => vi.fn())
-const mockUseWorkflow = vi.hoisted(() => vi.fn())
-
-vi.mock('../../../hooks/use-workflow', async (importOriginal) => {
- const actual = await importOriginal<typeof import('../../../hooks/use-workflow')>()
-
- return {
- ...actual,
- useIsNodeInIteration: (...args: unknown[]) => mockUseIsNodeInIteration(...args),
- useWorkflow: () => mockUseWorkflow(),
- }
-})
-
const createInputVar = (variable: string): InputVar => ({
type: InputVarType.textInput,
label: variable,
@@ -25,33 +14,14 @@ const createInputVar = (variable: string): InputVar => ({
required: false,
})
-const createNode = (id: string, title: string, type: BlockEnum = BlockEnum.Tool): Node =>
- ({
- id,
- position: { x: 0, y: 0 },
- data: {
- title,
- type,
- desc: '',
- tool_parameters:
- id === 'tool-a'
- ? {
- answer: { type: 'variable', value: ['start-node', 'answer'] },
- inner: { type: 'variable', value: ['inner-node', 'secret'] },
- self: { type: 'variable', value: ['iteration-node', 'item'] },
- }
- : {},
- },
- }) as Node
-
const createPayload = (overrides: Partial<IterationNodeType> = {}): IterationNodeType => ({
title: 'Iteration',
desc: '',
type: BlockEnum.Iteration,
- start_node_id: 'start-node',
- iterator_selector: ['start-node', 'items'],
+ start_node_id: 'iteration-start',
+ iterator_selector: ['source-node', 'records'],
iterator_input_type: VarType.arrayString,
- output_selector: ['child-node', 'text'],
+ output_selector: ['inner-node', 'secret'],
output_type: VarType.arrayString,
is_parallel: false,
parallel_nums: 2,
@@ -62,54 +32,89 @@ const createPayload = (overrides: Partial<IterationNodeType> = {}): IterationNod
...overrides,
})
-describe('iteration/use-single-run-form-params', () => {
- beforeEach(() => {
- vi.clearAllMocks()
- mockUseIsNodeInIteration.mockReturnValue({
- isNodeInIteration: (nodeId: string) => nodeId === 'inner-node',
- })
- mockUseWorkflow.mockReturnValue({
- getIterationNodeChildren: () => [
- createNode('tool-a', 'Tool A'),
- createNode('inner-node', 'Inner Node'),
- ],
- getBeforeNodesInSameBranch: () => [createNode('start-node', 'Start Node', BlockEnum.Start)],
- })
- })
+const graph = () => ({
+ nodes: [
+ createNode({
+ id: 'start-node',
+ data: { type: BlockEnum.Start, title: 'Start Node', variables: [createInputVar('answer')] },
+ }),
+ createNode({
+ id: 'source-node',
+ data: {
+ outputs: { records: { type: VarType.arrayString }, next: { type: VarType.arrayString } },
+ },
+ }),
+ createNode({ id: 'iteration-node', data: createPayload() }),
+ createNode({
+ id: 'iteration-start',
+ type: 'custom-iteration-start',
+ parentId: 'iteration-node',
+ data: { type: BlockEnum.IterationStart, isInIteration: true },
+ }),
+ createNode({
+ id: 'tool-a',
+ parentId: 'iteration-node',
+ data: {
+ type: BlockEnum.Tool,
+ title: 'Tool A',
+ isInIteration: true,
+ tool_parameters: {
+ answer: { type: 'variable', value: ['start-node', 'answer'] },
+ inner: { type: 'variable', value: ['inner-node', 'secret'] },
+ self: { type: 'variable', value: ['iteration-node', 'item'] },
+ },
+ },
+ }),
+ createNode({
+ id: 'inner-node',
+ parentId: 'iteration-node',
+ data: {
+ title: 'Inner Node',
+ isInIteration: true,
+ outputs: { secret: { type: VarType.string } },
+ },
+ }),
+ ],
+ edges: [
+ createEdge({ source: 'start-node', target: 'source-node' }),
+ createEdge({ source: 'source-node', target: 'iteration-node' }),
+ createEdge({ source: 'iteration-start', target: 'inner-node' }),
+ createEdge({ source: 'inner-node', target: 'tool-a' }),
+ ],
+})
+describe('iteration/use-single-run-form-params', () => {
it('should build single-run forms from external vars and keep iterator state in a dedicated form', () => {
- const toVarInputs = vi.fn(() => [createInputVar('#start-node.answer#')])
+ // The caller owns field conversion; preserve the selectors discovered by the real graph.
+ const toVarInputs = (variables: Variable[]) =>
+ variables.map((variable) => createInputVar(`#${variable.value_selector.join('.')}#`))
- const { result } = renderHook(() =>
- useSingleRunFormParams({
- id: 'iteration-node',
- payload: createPayload(),
- runInputData: {
- query: 'hello',
- 'iteration-node.input_selector': ['start-node', 'items'],
- },
- runInputDataRef: { current: {} },
- getInputVars: vi.fn(),
- setRunInputData: vi.fn(),
- toVarInputs,
- iterationRunResult: [],
- }),
+ const { result } = renderHook(
+ () =>
+ useSingleRunFormParams({
+ id: 'iteration-node',
+ payload: createPayload(),
+ runInputData: {
+ query: 'hello',
+ 'iteration-node.input_selector': ['source-node', 'records'],
+ },
+ runInputDataRef: { current: {} },
+ getInputVars: () => [],
+ setRunInputData: vi.fn(),
+ toVarInputs,
+ iterationRunResult: [],
+ }),
+ graph(),
)
- expect(toVarInputs).toHaveBeenCalledWith([
- expect.objectContaining({
- variable: 'start-node.answer',
- value_selector: ['start-node', 'answer'],
- }),
- ])
expect(result.current.forms).toHaveLength(2)
expect(result.current.forms[0]!.inputs).toEqual([createInputVar('#start-node.answer#')])
expect(result.current.forms[0]!.values).toEqual({
query: 'hello',
- 'iteration-node.input_selector': ['start-node', 'items'],
+ 'iteration-node.input_selector': ['source-node', 'records'],
})
expect(result.current.forms[1]!.values).toEqual({
- 'iteration-node.input_selector': ['start-node', 'items'],
+ 'iteration-node.input_selector': ['source-node', 'records'],
})
expect(result.current.allVarObject).toEqual({
'start-node.answer@@@tool-a@@@0': {
@@ -130,12 +135,12 @@ describe('iteration/use-single-run-form-params', () => {
payload: createPayload({ iterator_selector: ['source-node', 'records'] }),
runInputData,
runInputDataRef: { current: runInputData },
- getInputVars: vi.fn(),
+ getInputVars: () => [],
setRunInputData,
toVarInputs: () => [],
iterationRunResult: [],
})
- })
+ }, graph())
act(() =>
result.current.forms[0]!.onChange({
...result.current.forms[0]!.values,
diff --git a/web/app/components/workflow/nodes/parameter-extractor/__tests__/use-single-run-form-params.spec.ts b/web/app/components/workflow/nodes/parameter-extractor/__tests__/use-single-run-form-params.spec.ts
index 094075d1615..618668bdc9e 100644
--- a/web/app/components/workflow/nodes/parameter-extractor/__tests__/use-single-run-form-params.spec.ts
+++ b/web/app/components/workflow/nodes/parameter-extractor/__tests__/use-single-run-form-params.spec.ts
@@ -1,26 +1,14 @@
import type { ParameterExtractorNodeType } from '../types'
import type { InputVar } from '@/app/components/workflow/types'
-import { renderWorkflowFlowHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
-import { BlockEnum, InputVarType, VarType } from '@/app/components/workflow/types'
+import { act } from '@testing-library/react'
+import { useState } from 'react'
+import { renderWorkflowCanvasHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { BlockEnum, InputVarType } from '@/app/components/workflow/types'
import { Resolution } from '@/types/app'
-import useConfigVision from '../../../hooks/use-config-vision'
-import useAvailableVarList from '../../_base/hooks/use-available-var-list'
+import { createSingleRunGraphOptions } from '../../__tests__/single-run-graph-options'
import { ParamType, ReasoningModeType } from '../types'
import useSingleRunFormParams from '../use-single-run-form-params'
-vi.mock('../../../hooks/use-config-vision', () => ({
- __esModule: true,
- default: vi.fn(),
-}))
-
-vi.mock('../../_base/hooks/use-available-var-list', () => ({
- __esModule: true,
- default: vi.fn(),
-}))
-
-const mockUseConfigVision = vi.mocked(useConfigVision)
-const mockUseAvailableVarList = vi.mocked(useAvailableVarList)
-
const createData = (
overrides: Partial<ParameterExtractorNodeType> = {},
): ParameterExtractorNodeType => ({
@@ -32,7 +20,7 @@ const createData = (
name: 'gpt-4o',
mode: 'chat' as const,
completion_params: {},
- } as ParameterExtractorNodeType['model'],
+ },
query: ['node-1', 'query'],
reasoning_mode: ReasoningModeType.prompt,
parameters: [
@@ -55,58 +43,33 @@ const createData = (
})
describe('parameter-extractor/use-single-run-form-params', () => {
- beforeEach(() => {
- vi.clearAllMocks()
-
- mockUseConfigVision.mockReturnValue({
- isVisionModel: true,
- } as ReturnType<typeof useConfigVision>)
- mockUseAvailableVarList.mockReturnValue({
- availableVars: [
- {
- nodeId: 'node-3',
- title: 'Vision Source',
- vars: [
- {
- variable: 'image',
- type: VarType.file,
- },
- ],
- },
- ],
- } as unknown as ReturnType<typeof useAvailableVarList>)
- })
-
it('builds variable and vision single-run forms and returns dependent vars', () => {
- const runInputDataRef = {
- current: { query: 'hello', '#context#': 'ctx', '#files#': ['file-1'] } as Record<
- string,
- unknown
- >,
- }
- const setRunInputData = vi.fn((next: Record<string, unknown>) => {
- runInputDataRef.current = next
- })
- const getInputVars = vi.fn<() => InputVar[]>(() => [
+ const getInputVars = (): InputVar[] => [
{
label: 'Answer',
variable: '#node-2.answer#',
type: InputVarType.textInput,
required: true,
},
- ])
+ ]
- const { result } = renderHook(() =>
- useSingleRunFormParams({
- id: 'node-1',
- payload: createData(),
- runInputData: { query: 'hello', '#context#': 'ctx', '#files#': ['file-1'] },
- runInputDataRef,
+ const payload = createData()
+ const { result } = renderHook(() => {
+ const [runInputData, setRunInputData] = useState<Record<string, unknown>>({
+ query: 'hello',
+ '#context#': 'ctx',
+ '#files#': ['file-1'],
+ })
+ return useSingleRunFormParams({
+ id: 'current-node',
+ payload,
+ runInputData,
+ runInputDataRef: { current: runInputData },
getInputVars,
setRunInputData,
toVarInputs: () => [],
- }),
- )
+ })
+ }, createSingleRunGraphOptions(payload))
expect(result.current.forms).toHaveLength(2)
expect(result.current.forms[0]!.inputs).toEqual(
@@ -129,19 +92,12 @@ describe('parameter-extractor/use-single-run-form-params', () => {
},
])
- result.current.forms[0]!.onChange({ query: 'updated' })
- result.current.forms[1]!.onChange({ '#files#': ['file-2'] })
-
- expect(setRunInputData).toHaveBeenNthCalledWith(1, {
- query: 'updated',
- '#context#': 'ctx',
- '#files#': ['file-1'],
- })
- expect(setRunInputData).toHaveBeenNthCalledWith(2, {
- query: 'updated',
- '#context#': 'ctx',
- '#files#': ['file-2'],
- })
+ act(() => result.current.forms[0]!.onChange({ query: 'updated' }))
+ expect(result.current.forms[0]!.values).toMatchObject({ query: 'updated' })
+ expect(result.current.forms[1]!.values).toEqual({ '#files#': ['file-1'] })
+ act(() => result.current.forms[1]!.onChange({ '#files#': ['file-2'] }))
+ expect(result.current.forms[0]!.values).toMatchObject({ query: 'updated' })
+ expect(result.current.forms[1]!.values).toEqual({ '#files#': ['file-2'] })
expect(result.current.getDependentVars()).toEqual([
['node-1', 'query'],
['node-2', 'answer'],
@@ -153,16 +109,19 @@ describe('parameter-extractor/use-single-run-form-params', () => {
})
it('omits vision inputs and dependencies when vision is disabled', () => {
- const { result } = renderHook(() =>
- useSingleRunFormParams({
- id: 'node-1',
- payload: createData({ instruction: '', vision: { enabled: false } }),
- runInputData: {},
- runInputDataRef: { current: {} },
- getInputVars: () => [],
- setRunInputData: vi.fn(),
- toVarInputs: () => [],
- }),
+ const payload = createData({ instruction: '', vision: { enabled: false } })
+ const { result } = renderHook(
+ () =>
+ useSingleRunFormParams({
+ id: 'current-node',
+ payload,
+ runInputData: {},
+ runInputDataRef: { current: {} },
+ getInputVars: () => [],
+ setRunInputData: vi.fn(),
+ toVarInputs: () => [],
+ }),
+ createSingleRunGraphOptions(payload),
)
expect(result.current.forms).toHaveLength(1)
expect(result.current.forms[0]!.inputs.map((input) => input.variable)).toEqual(['query'])
diff --git a/web/app/components/workflow/nodes/question-classifier/__tests__/use-single-run-form-params.spec.ts b/web/app/components/workflow/nodes/question-classifier/__tests__/use-single-run-form-params.spec.ts
index eab33ae6219..2da2ba92531 100644
--- a/web/app/components/workflow/nodes/question-classifier/__tests__/use-single-run-form-params.spec.ts
+++ b/web/app/components/workflow/nodes/question-classifier/__tests__/use-single-run-form-params.spec.ts
@@ -1,25 +1,13 @@
import type { QuestionClassifierNodeType } from '../types'
import type { InputVar } from '@/app/components/workflow/types'
-import { renderWorkflowFlowHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
-import { BlockEnum, InputVarType, VarType } from '@/app/components/workflow/types'
+import { act } from '@testing-library/react'
+import { useState } from 'react'
+import { renderWorkflowCanvasHook as renderHook } from '@/app/components/workflow/__tests__/workflow-test-env'
+import { BlockEnum, InputVarType } from '@/app/components/workflow/types'
import { Resolution } from '@/types/app'
-import useConfigVision from '../../../hooks/use-config-vision'
-import useAvailableVarList from '../../_base/hooks/use-available-var-list'
+import { createSingleRunGraphOptions } from '../../__tests__/single-run-graph-options'
import useSingleRunFormParams from '../use-single-run-form-params'
-vi.mock('../../../hooks/use-config-vision', () => ({
- __esModule: true,
- default: vi.fn(),
-}))
-
-vi.mock('../../_base/hooks/use-available-var-list', () => ({
- __esModule: true,
- default: vi.fn(),
-}))
-
-const mockUseConfigVision = vi.mocked(useConfigVision)
-const mockUseAvailableVarList = vi.mocked(useAvailableVarList)
-
const createData = (
overrides: Partial<QuestionClassifierNodeType> = {},
): QuestionClassifierNodeType => ({
@@ -31,7 +19,7 @@ const createData = (
name: 'gpt-4o',
mode: 'chat',
completion_params: {},
- } as QuestionClassifierNodeType['model'],
+ },
classes: [{ id: 'topic-1', name: 'Billing questions' }],
query_variable_selector: ['node-1', 'query'],
instruction: 'Route by {{#node-2.answer#}}',
@@ -46,53 +34,32 @@ const createData = (
})
describe('question-classifier/use-single-run-form-params', () => {
- beforeEach(() => {
- vi.clearAllMocks()
-
- mockUseConfigVision.mockReturnValue({
- isVisionModel: true,
- } as ReturnType<typeof useConfigVision>)
- mockUseAvailableVarList.mockReturnValue({
- availableVars: [
- {
- nodeId: 'node-3',
- title: 'Vision Source',
- vars: [
- {
- variable: 'image',
- type: VarType.file,
- },
- ],
- },
- ],
- } as unknown as ReturnType<typeof useAvailableVarList>)
- })
-
it('builds variable and vision forms and exposes dependent variables', () => {
- const runInputDataRef = { current: { query: 'hello', '#files#': ['file-1'] } }
- const setRunInputData = vi.fn((next) => {
- runInputDataRef.current = next
- })
- const getInputVars = vi.fn<() => InputVar[]>(() => [
+ const getInputVars = (): InputVar[] => [
{
label: 'Answer',
variable: '#node-2.answer#',
type: InputVarType.textInput,
required: true,
},
- ])
+ ]
- const { result } = renderHook(() =>
- useSingleRunFormParams({
- id: 'node-1',
- payload: createData(),
- runInputData: { query: 'hello', '#files#': ['file-1'] },
- runInputDataRef,
+ const payload = createData()
+ const { result } = renderHook(() => {
+ const [runInputData, setRunInputData] = useState<Record<string, unknown>>({
+ query: 'hello',
+ '#files#': ['file-1'],
+ })
+ return useSingleRunFormParams({
+ id: 'current-node',
+ payload,
+ runInputData,
+ runInputDataRef: { current: runInputData },
getInputVars,
setRunInputData,
toVarInputs: () => [],
- }),
- )
+ })
+ }, createSingleRunGraphOptions(payload))
expect(result.current.forms).toHaveLength(2)
expect(result.current.forms[0]!.inputs).toEqual(
@@ -115,17 +82,12 @@ describe('question-classifier/use-single-run-form-params', () => {
},
])
- result.current.forms[0]!.onChange({ query: 'updated' })
- result.current.forms[1]!.onChange({ '#files#': ['file-2'] })
-
- expect(setRunInputData).toHaveBeenNthCalledWith(1, {
- query: 'updated',
- '#files#': ['file-1'],
- })
- expect(setRunInputData).toHaveBeenNthCalledWith(2, {
- query: 'updated',
- '#files#': ['file-2'],
- })
+ act(() => result.current.forms[0]!.onChange({ query: 'updated' }))
+ expect(result.current.forms[0]!.values).toMatchObject({ query: 'updated' })
+ expect(result.current.forms[1]!.values).toEqual({ '#files#': ['file-1'] })
+ act(() => result.current.forms[1]!.onChange({ '#files#': ['file-2'] }))
+ expect(result.current.forms[0]!.values).toMatchObject({ query: 'updated' })
+ expect(result.current.forms[1]!.values).toEqual({ '#files#': ['file-2'] })
expect(result.current.getDependentVars()).toEqual([
['node-1', 'query'],
['node-2', 'answer'],
@@ -137,20 +99,19 @@ describe('question-classifier/use-single-run-form-params', () => {
})
it('omits the vision form when the selected model does not support vision', () => {
- mockUseConfigVision.mockReturnValue({
- isVisionModel: false,
- } as ReturnType<typeof useConfigVision>)
-
- const { result } = renderHook(() =>
- useSingleRunFormParams({
- id: 'node-1',
- payload: createData(),
- runInputData: {},
- runInputDataRef: { current: {} },
- getInputVars: () => [],
- setRunInputData: vi.fn(),
- toVarInputs: () => [],
- }),
+ const payload = createData()
+ const { result } = renderHook(
+ () =>
+ useSingleRunFormParams({
+ id: 'current-node',
+ payload,
+ runInputData: {},
+ runInputDataRef: { current: {} },
+ getInputVars: () => [],
+ setRunInputData: vi.fn(),
+ toVarInputs: () => [],
+ }),
+ createSingleRunGraphOptions(payload, false),
)
expect(result.current.forms).toHaveLength(1)