AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents
TypeScript ai-agentai-agent-toolsai-agentsai-agents-frameworkmcpmcp-servermcp-toolsmcpsn8n-alternativeno-code-automationworkflowworkflow-automationworkflows
import { FlowAction, FlowRunStatus, LoopStepOutput } from '@activepieces/shared'
import { FlowExecutorContext } from '../../src/lib/handler/context/flow-execution-context'
import { flowExecutor } from '../../src/lib/handler/flow-executor'
import { buildCodeAction, buildSimpleLoopAction, generateMockEngineConstants } from './test-helper'
describe('flow with looping', () => {
it('should execute iterations', async () => {
const codeAction = buildCodeAction({
name: 'echo_step',
input: {
'index': '{{loop.output.index}}',
},
})
const result = await flowExecutor.execute({
action: buildSimpleLoopAction({
name: 'loop',
loopItems: '{{ [4,5,6] }}',
firstLoopAction: codeAction,
}),
executionState: FlowExecutorContext.empty(),
constants: generateMockEngineConstants({ stepNames: ['loop'] }),
})
const loopOut = result.steps.loop as LoopStepOutput
expect(result.verdict.status).toBe(FlowRunStatus.RUNNING)
expect(loopOut.output?.iterations.length).toBe(3)
expect(loopOut.output?.index).toBe(3)
expect(loopOut.output?.item).toBe(6)
})
it('should execute iterations and fail on first iteration', async () => {
const generateArray = buildCodeAction({
name: 'echo_step',
input: {
'array': '{{ [4,5,6] }}',
},
nextAction: buildSimpleLoopAction({
name: 'loop',
loopItems: '{{ echo_step.output.array }}',
firstLoopAction: buildCodeAction({
name: 'runtime',
input: {},
}),
}),
})
const result = await flowExecutor.execute({
action: generateArray,
executionState: FlowExecutorContext.empty(),
constants: generateMockEngineConstants({ stepNames: ['echo_step'] }),
})
const loopOut = result.steps.loop as LoopStepOutput
expect(result.verdict.status).toBe(FlowRunStatus.FAILED)
expect(loopOut.output?.iterations.length).toBe(1)
expect(loopOut.output?.index).toBe(1)
expect(loopOut.output?.item).toBe(4)
})
it('should skip loop', async () => {
const result = await flowExecutor.execute({
action: buildSimpleLoopAction({ name: 'loop', loopItems: '{{ [4,5,6] }}', skip: true }), executionState: FlowExecutorContext.empty(), constants: generateMockEngineConstants(),
})
expect(result.verdict.status).toBe(FlowRunStatus.RUNNING)
expect(result.steps.loop).toBeUndefined()
})
it('should skip loop in flow', async () => {
const flow: FlowAction = {
...buildSimpleLoopAction({ name: 'loop', loopItems: '{{ [4,5,6] }}', skip: true }),
nextAction: {
...buildCodeAction({
name: 'echo_step',
skip: false,
input: {
'key': '{{ 1 + 2 }}',
},
}),
nextAction: undefined,
},
}
const result = await flowExecutor.execute({
action: flow, executionState: FlowExecutorContext.empty(), constants: generateMockEngineConstants(),
})
expect(result.verdict.status).toBe(FlowRunStatus.RUNNING)
expect(result.steps.loop).toBeUndefined()
expect(result.steps.echo_step.output).toEqual({ 'key': 3 })
})
it('should keep every nested step output inside its iteration', async () => {
const result = await flowExecutor.execute({
action: buildSimpleLoopAction({
name: 'loop',
loopItems: '{{ [4,5,6] }}',
firstLoopAction: buildCodeAction({
name: 'echo_step',
input: {
'index': '{{loop.output.index}}',
},
}),
}),
executionState: FlowExecutorContext.empty(),
constants: generateMockEngineConstants({ stepNames: ['loop'] }),
})
const loopOut = result.steps.loop as LoopStepOutput
expect(loopOut.output?.iterations.map((iteration) => iteration.echo_step?.output)).toEqual([
{ index: 1 },
{ index: 2 },
{ index: 3 },
])
})
it('should not build a circular graph when a nested step references the loop output', async () => {
const result = await flowExecutor.execute({
action: buildSimpleLoopAction({
name: 'loop',
loopItems: '{{ [4,5,6] }}',
firstLoopAction: buildCodeAction({
name: 'echo_step',
input: {
'data': '{{loop.output}}',
},
}),
}),
executionState: FlowExecutorContext.empty(),
constants: generateMockEngineConstants({ stepNames: ['loop'] }),
})
expect(() => JSON.stringify(result.steps)).not.toThrow()
})
it('should yield to the event loop between iterations', async () => {
const iterationCount = 50
let macrotaskTicks = 0
let keepTicking = true
const tick = (): void => {
if (!keepTicking) {
return
}
macrotaskTicks++
setImmediate(tick)
}
setImmediate(tick)
const ticksAtLoopUpserts: number[] = []
const originalUpsertStep = FlowExecutorContext.prototype.upsertStep
const upsertSpy = vi.spyOn(FlowExecutorContext.prototype, 'upsertStep').mockImplementation(function (this: FlowExecutorContext, stepName, stepOutput) {
if (stepName === 'loop') {
ticksAtLoopUpserts.push(macrotaskTicks)
}
return originalUpsertStep.call(this, stepName, stepOutput)
})
const result = await flowExecutor.execute({
action: buildSimpleLoopAction({
name: 'loop',
loopItems: `{{ Array.from({ length: ${iterationCount} }, (_, i) => i) }}`,
}),
executionState: FlowExecutorContext.empty(),
constants: generateMockEngineConstants({ stepNames: ['loop'] }),
}).finally(() => {
keepTicking = false
upsertSpy.mockRestore()
})
const loopOut = result.steps.loop as LoopStepOutput
expect(loopOut.output?.iterations.length).toBe(iterationCount)
expect(new Set(ticksAtLoopUpserts).size).toBeGreaterThanOrEqual(iterationCount)
})
})