Skip to content

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

17.8 KB
Raw Blame
import { ActivepiecesError, ErrorCode } from '@activepieces/core-utils'
import { TriggerStrategy } from '@activepieces/pieces-framework'
import { ApEnvironment, EngineResponseStatus, TriggerHookType, TriggerSourceScheduleType } from '@activepieces/shared'
import { beforeEach, describe, expect, it, vi } from 'vitest'

const mockSubmitAndWaitForResponse = vi.fn()
const mockGetPlatformId = vi.fn().mockResolvedValue('platform-1')
const mockDeleteListeners = vi.fn()
const mockRemoveRepeatingJob = vi.fn()
const mockAddJob = vi.fn()

vi.mock('../../../../../src/app/helper/system/system', () => ({
    system: {
        getOrThrow: vi.fn().mockReturnValue(ApEnvironment.PRODUCTION),
        getNumber: vi.fn().mockReturnValue(5),
        getNumberOrThrow: vi.fn().mockReturnValue(5),
    },
}))

vi.mock('../../../../../src/app/project/project-service', () => ({
    projectService: vi.fn(() => ({
        getPlatformId: mockGetPlatformId,
    })),
}))

vi.mock('../../../../../src/app/workers/user-interaction-watcher', () => ({
    userInteractionWatcher: {
        submitAndWaitForResponse: (...args: unknown[]) => mockSubmitAndWaitForResponse(...args),
    },
}))

vi.mock('../../../../../src/app/workers/job-queue/job-queue', () => ({
    jobQueue: vi.fn(() => ({
        removeRepeatingJob: mockRemoveRepeatingJob,
        add: mockAddJob,
    })),
    JobType: { ONE_TIME: 'ONE_TIME', REPEATING: 'REPEATING' },
}))

vi.mock('../../../../../src/app/trigger/app-event-routing/app-event-routing.service', () => ({
    appEventRoutingService: {
        deleteListeners: (...args: unknown[]) => mockDeleteListeners(...args),
    },
}))

import { system } from '../../../../../src/app/helper/system/system'
import { AppSystemProp } from '../../../../../src/app/helper/system/system-props'
import { flowTriggerSideEffect } from '../../../../../src/app/trigger/trigger-source/flow-trigger-side-effect'

const mockLog = {
    info: vi.fn(),
    debug: vi.fn(),
    error: vi.fn(),
    warn: vi.fn(),
    child: vi.fn(),
    fatal: vi.fn(),
    trace: vi.fn(),
    silent: vi.fn(),
    level: 'info',
} as any

const BASE_PARAMS = {
    flowId: 'flow-1',
    flowVersionId: 'fv-1',
    pieceName: '@activepieces/piece-test',
    projectId: 'proj-1',
    simulate: false,
}

function makePollingTrigger() {
    return {
        name: 'test_trigger',
        displayName: 'Test Trigger',
        description: 'Test',
        props: {},
        requireAuth: false,
        type: TriggerStrategy.POLLING,
        sampleData: {},
        testStrategy: 'TEST_FUNCTION',
    } as any
}

function makeManualTrigger() {
    return {
        ...makePollingTrigger(),
        type: TriggerStrategy.MANUAL,
    }
}

function okEngineResponse() {
    return {
        status: EngineResponseStatus.OK,
        response: {},
        error: undefined,
    }
}

function failedEngineResponse() {
    return {
        status: EngineResponseStatus.ERROR,
        response: undefined,
        error: 'Engine failed',
    }
}

function timedOutEngineResponse() {
    return {
        status: EngineResponseStatus.TIMEOUT,
        response: undefined,
        error: undefined,
    }
}

describe('flowTriggerSideEffect', () => {
    beforeEach(() => {
        vi.clearAllMocks()
        mockGetPlatformId.mockResolvedValue('platform-1')
    })

    describe('enable', () => {
        it('should default polling schedule to a rolling interval', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())
            const expectedSchedule = {
                type: TriggerSourceScheduleType.INTERVAL,
                intervalMs: 5 * 60_000,
            }

            const result = await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
            })

            expect(result.scheduleOptions).toEqual(expectedSchedule)
            expect(mockAddJob).toHaveBeenCalledWith(expect.objectContaining({
                scheduleOptions: expectedSchedule,
            }))
        })

        it('should honor poll interval overrides that do not divide 60', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())
            vi.mocked(system.getNumberOrThrow).mockReturnValueOnce(45)

            const result = await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
            })

            expect(result.scheduleOptions).toEqual({
                type: TriggerSourceScheduleType.INTERVAL,
                intervalMs: 45 * 60_000,
            })
        })

        it('should throw when the worker skipped the enable hook (OK with undefined response)', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue({ ...okEngineResponse(), response: undefined })

            await expect(
                flowTriggerSideEffect(mockLog).enable({
                    ...BASE_PARAMS,
                    pieceTrigger: makePollingTrigger(),
                }),
            ).rejects.toThrow(ActivepiecesError)

            expect(mockAddJob).not.toHaveBeenCalled()
        })

        it('should report a timeout when the enable hook times out without an engine error', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(timedOutEngineResponse())

            await expect(
                flowTriggerSideEffect(mockLog).enable({
                    ...BASE_PARAMS,
                    pieceTrigger: makePollingTrigger(),
                }),
            ).rejects.toMatchObject({
                error: {
                    code: ErrorCode.TRIGGER_UPDATE_STATUS,
                    params: { standardError: 'The trigger timed out after 5 seconds without responding' },
                },
            })
            expect(system.getNumberOrThrow).toHaveBeenCalledWith(AppSystemProp.TRIGGER_HOOKS_TIMEOUT_SECONDS)

            expect(mockAddJob).not.toHaveBeenCalled()
        })

        it('should keep the engine error when a timed out enable hook reports one', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue({ ...timedOutEngineResponse(), error: 'Engine failed' })

            await expect(
                flowTriggerSideEffect(mockLog).enable({
                    ...BASE_PARAMS,
                    pieceTrigger: makePollingTrigger(),
                }),
            ).rejects.toMatchObject({
                error: { params: { standardError: 'Engine failed' } },
            })
        })

        it('should keep engine-provided schedule options untouched', async () => {
            const engineSchedule = {
                type: TriggerSourceScheduleType.CRON_EXPRESSION,
                cronExpression: '0 12 * * *',
                timezone: 'UTC',
            }
            mockSubmitAndWaitForResponse.mockResolvedValue({
                status: EngineResponseStatus.OK,
                response: { scheduleOptions: engineSchedule },
                error: undefined,
            })

            const result = await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
            })

            expect(result.scheduleOptions).toEqual(engineSchedule)
        })
    })

    describe('disable', () => {
        it('should complete successfully when engine responds OK', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makeManualTrigger(),
                ignoreError: false,
            })

            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledOnce()
        })

        it('should throw when engine response is bad and ignoreError is false', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(failedEngineResponse())

            await expect(
                flowTriggerSideEffect(mockLog).disable({
                    ...BASE_PARAMS,
                    pieceTrigger: makeManualTrigger(),
                    ignoreError: false,
                }),
            ).rejects.toThrow(ActivepiecesError)
        })

        it('should report a timeout when the disable hook times out and ignoreError is false', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(timedOutEngineResponse())

            await expect(
                flowTriggerSideEffect(mockLog).disable({
                    ...BASE_PARAMS,
                    pieceTrigger: makeManualTrigger(),
                    ignoreError: false,
                }),
            ).rejects.toMatchObject({
                error: {
                    code: ErrorCode.TRIGGER_UPDATE_STATUS,
                    params: { standardError: 'The trigger timed out after 5 seconds without responding' },
                },
            })
            expect(system.getNumberOrThrow).toHaveBeenCalledWith(AppSystemProp.TRIGGER_HOOKS_TIMEOUT_SECONDS)
        })

        it('should not throw when engine response is bad and ignoreError is true', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(failedEngineResponse())

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makeManualTrigger(),
                ignoreError: true,
            })

            expect(mockLog.warn).toHaveBeenCalledWith(
                expect.objectContaining({ flow: { id: 'flow-1' }, error: 'Engine failed' }),
                expect.stringContaining('Ignored error'),
            )
        })

        it('should log only the plain message when the ignored engine error carries http details', async () => {
            const serializedPieceError = JSON.stringify({
                __apErrorVersion: 1,
                message: 'Authentication required, not authenticated - You need to authenticate to access this operation.',
                errorName: '_',
                status: 401,
                responseHeaders: { 'set-cookie': 'session=super-secret-value' },
                requestBody: { apiKey: 'lin_api_should_never_be_logged' },
                raw: 'Error: Authentication required\n    at j (/usr/src/app/cache/v14/common/node_modules/...)',
            })
            mockSubmitAndWaitForResponse.mockResolvedValue({
                status: EngineResponseStatus.ERROR,
                response: undefined,
                error: serializedPieceError,
            })

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makeManualTrigger(),
                ignoreError: true,
            })

            expect(mockLog.warn).toHaveBeenCalledWith(
                {
                    flow: { id: 'flow-1' },
                    error: 'Authentication required, not authenticated - You need to authenticate to access this operation.',
                },
                expect.stringContaining('Ignored error'),
            )
            const logged = JSON.stringify(vi.mocked(mockLog.warn).mock.calls)
            expect(logged).not.toContain('super-secret-value')
            expect(logged).not.toContain('lin_api_should_never_be_logged')
            expect(logged).not.toContain('set-cookie')
        })

        it('should throw when submitAndWaitForResponse throws and ignoreError is false', async () => {
            mockSubmitAndWaitForResponse.mockRejectedValue(
                new ActivepiecesError({
                    code: ErrorCode.ENGINE_OPERATION_FAILURE,
                    params: { message: 'Worker did not respond within the safety timeout' },
                }),
            )

            await expect(
                flowTriggerSideEffect(mockLog).disable({
                    ...BASE_PARAMS,
                    pieceTrigger: makeManualTrigger(),
                    ignoreError: false,
                }),
            ).rejects.toThrow(ActivepiecesError)
        })

        it('should not throw when submitAndWaitForResponse throws and ignoreError is true', async () => {
            mockSubmitAndWaitForResponse.mockRejectedValue(
                new ActivepiecesError({
                    code: ErrorCode.ENGINE_OPERATION_FAILURE,
                    params: { message: 'Worker did not respond within the safety timeout' },
                }),
            )

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makeManualTrigger(),
                ignoreError: true,
            })

            expect(mockLog.warn).toHaveBeenCalledWith(
                expect.objectContaining({ flow: { id: 'flow-1' } }),
                expect.stringContaining('Ignored error'),
            )
        })

        it('should still remove repeating job for polling trigger when engine call fails and ignoreError is true', async () => {
            mockSubmitAndWaitForResponse.mockRejectedValue(new Error('timeout'))

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                ignoreError: true,
            })

            expect(mockRemoveRepeatingJob).toHaveBeenCalledWith({
                flowVersionId: 'fv-1',
            })
        })

        it('should still delete app event listeners when engine call fails and ignoreError is true', async () => {
            mockSubmitAndWaitForResponse.mockRejectedValue(new Error('timeout'))

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: {
                    ...makePollingTrigger(),
                    type: TriggerStrategy.APP_WEBHOOK,
                },
                ignoreError: true,
            })

            expect(mockDeleteListeners).toHaveBeenCalledWith({
                projectId: 'proj-1',
                flowId: 'flow-1',
            })
        })
    })

    describe('republish with an unchanged trigger', () => {
        const previousSchedule = {
            type: TriggerSourceScheduleType.CRON_EXPRESSION,
            cronExpression: '*/15 * * * *',
            timezone: 'UTC',
        }

        it('keeps a polling trigger running on the previous schedule without calling onEnable', async () => {
            const result = await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                isRepublish: true,
                isTriggerUnchanged: true,
                previousSchedule,
            })

            expect(mockSubmitAndWaitForResponse).not.toHaveBeenCalled()
            expect(result.scheduleOptions).toEqual(previousSchedule)
            expect(mockAddJob).toHaveBeenCalledWith(expect.objectContaining({
                id: BASE_PARAMS.flowVersionId,
                scheduleOptions: previousSchedule,
            }))
        })

        it('skips onDisable for a polling trigger but still removes the old poll job', async () => {
            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                ignoreError: true,
                isRepublish: true,
                isTriggerUnchanged: true,
            })

            expect(mockSubmitAndWaitForResponse).not.toHaveBeenCalled()
            expect(mockRemoveRepeatingJob).toHaveBeenCalledWith({ flowVersionId: BASE_PARAMS.flowVersionId })
        })

        it('runs onEnable when there is no previous schedule to keep', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())

            await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                isRepublish: true,
                isTriggerUnchanged: true,
            })

            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledOnce()
        })

        it('skips the old onDisable but runs onEnable with isRepublish on a piece upgrade', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                ignoreError: true,
                isRepublish: true,
                isTriggerUnchanged: false,
            })
            await flowTriggerSideEffect(mockLog).enable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                isRepublish: true,
                isTriggerUnchanged: false,
                previousSchedule,
            })

            expect(mockRemoveRepeatingJob).toHaveBeenCalledWith({ flowVersionId: BASE_PARAMS.flowVersionId })
            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledOnce()
            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledWith(expect.objectContaining({ hookType: TriggerHookType.ON_ENABLE, isRepublish: true }), mockLog)
        })

        it('runs onDisable for a polling trigger when the flow is not republished', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makePollingTrigger(),
                ignoreError: true,
            })

            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledWith(expect.objectContaining({ hookType: TriggerHookType.ON_DISABLE }), mockLog)
        })

        it('still runs the hooks for a trigger that is not polling', async () => {
            mockSubmitAndWaitForResponse.mockResolvedValue(okEngineResponse())

            await flowTriggerSideEffect(mockLog).disable({
                ...BASE_PARAMS,
                pieceTrigger: makeManualTrigger(),
                ignoreError: true,
                isRepublish: true,
                isTriggerUnchanged: true,
            })

            expect(mockSubmitAndWaitForResponse).toHaveBeenCalledOnce()
        })
    })
})