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
// @vitest-environment jsdom
import { tryCatch } from '@activepieces/core-utils';
import {
CodeAction,
EmptyTrigger,
FlowActionType,
FlowOperationRequest,
FlowOperationStatus,
FlowOperationType,
FlowRun,
FlowRunStatus,
FlowStatus,
FlowTriggerType,
FlowVersionState,
GetSampleDataRequest,
NoteColorVariant,
PopulatedFlow,
RunEnvironment,
SampleDataFileType,
SampleDataSettings,
flowOperations,
} from '@activepieces/shared';
import { QueryClient } from '@tanstack/react-query';
import { AxiosError, AxiosHeaders } from 'axios';
import { toast } from 'sonner';
import { io } from 'socket.io-client';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { BuilderStore, createBuilderStore } from '@/app/builder/builder-hooks';
import { RightSideBarType } from '@/app/builder/types';
const flowsApiMock = vi.hoisted(() => ({
update: vi.fn(),
get: vi.fn(),
}));
const sampleDataApiMock = vi.hoisted(() => ({
get: vi.fn<(request: GetSampleDataRequest) => Promise<unknown>>(),
}));
vi.mock('i18next', () => ({ t: (key: string) => key }));
vi.mock('@/features/flows/api/flows-api', () => ({
flowsApi: flowsApiMock,
}));
vi.mock('@/features/flows/api/sample-data-api', () => ({
sampleDataApi: sampleDataApiMock,
}));
describe('flow state save path', () => {
beforeEach(() => {
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
it('saves the next edit after a failed save', async () => {
flowsApiMock.update
.mockRejectedValueOnce(httpError({ status: 400 }))
.mockResolvedValue(draftFlow('Second name'));
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await flushPromises();
store.getState().applyOperation(changeName('Second name'));
await flushPromises();
expect(sentOperations()).toEqual([
changeName('First name'),
changeName('Second name'),
]);
});
it('sends the saves behind a failed save before it refetches the draft', async () => {
flowsApiMock.update
.mockRejectedValueOnce(httpError({ status: 400 }))
.mockResolvedValue(draftFlow('Second name'));
flowsApiMock.get.mockResolvedValue(draftFlow('Second name'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
store.getState().applyOperation(changeName('Second name'));
await flushPromises();
expect(sentOperations()).toEqual([
changeName('First name'),
changeName('Second name'),
]);
const [, queuedSaveOrder] = flowsApiMock.update.mock.invocationCallOrder;
const [refetchOrder] = flowsApiMock.get.mock.invocationCallOrder;
expect(refetchOrder).toBeGreaterThan(queuedSaveOrder);
expect(store.getState().flowVersion.displayName).toBe('Second name');
});
it('shows the message of a failed save', async () => {
flowsApiMock.update.mockRejectedValue(
serverError('Loop step parent step_9 not found'),
);
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await flushPromises();
expect(toast.error).toHaveBeenCalledWith(
'Your change was not saved',
expect.objectContaining({
description: 'Loop step parent step_9 not found',
}),
);
});
it('shows the draft on the server after a failed save', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get.mockResolvedValue(draftFlow('Name on the server'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
expect(store.getState().flowVersion.displayName).toBe('First name');
await flushPromises();
expect(store.getState().flowVersion.displayName).toBe('Name on the server');
});
it('clears the saving flag after a failed save', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
expect(store.getState().saving).toBe(true);
await flushPromises();
expect(store.getState().saving).toBe(false);
});
it('shows an error when the draft refetch after a failed save fails', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get.mockRejectedValue(new Error('Network Error'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await flushPromises();
expect(toast.error).toHaveBeenCalledWith(
'Something went wrong',
expect.anything(),
);
});
});
describe('flow state step edits', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
});
afterEach(() => {
vi.useRealTimers();
});
it('saves a long typing burst in one step at least every 5 s', async () => {
const store = createStore(draftFlow('Order lookup'));
for (let elapsed = 0; elapsed < 12_000; elapsed += 200) {
store.getState().applyOperation(renameTrigger(`New order ${elapsed}`));
await vi.advanceTimersByTimeAsync(200);
}
expect(flowsApiMock.update.mock.calls.length).toBeGreaterThanOrEqual(2);
});
it('saves an edit 1 s after it when no keystroke follows', async () => {
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
await vi.advanceTimersByTimeAsync(999);
expect(sentOperations()).toEqual([]);
await vi.advanceTimersByTimeAsync(1);
expect(sentOperations()).toEqual([renameTrigger('New order')]);
});
});
describe('flow state pending edits', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
});
afterEach(() => {
vi.useRealTimers();
});
it('sends an edit inside the debounce at once', async () => {
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
await store.getState().savePendingEdits();
expect(sentOperations()).toEqual([renameTrigger('New order')]);
});
it('settles only after the save of the edit ends', async () => {
const save = Promise.withResolvers<PopulatedFlow>();
flowsApiMock.update.mockReturnValue(save.promise);
const store = createStore(draftFlow('Order lookup'));
const settled = vi.fn();
store.getState().applyOperation(renameTrigger('New order'));
const savingEdits = store.getState().savePendingEdits().then(settled);
await vi.advanceTimersByTimeAsync(0);
expect(settled).not.toHaveBeenCalled();
save.resolve(draftFlow('Order lookup'));
await savingEdits;
expect(settled).toHaveBeenCalled();
});
it('fails when the save of the edit fails, and shows the failed-save message', async () => {
const failure = httpError({ status: 400 });
flowsApiMock.update.mockRejectedValue(failure);
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
vi.spyOn(toast, 'error').mockReset();
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
await expect(store.getState().savePendingEdits()).rejects.toBe(failure);
expect(toast.error).toHaveBeenCalledWith(
'Your change was not saved',
expect.anything(),
);
});
it('sends an edit inside the debounce at once on a flush', async () => {
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
store.getState().flushPendingEdits();
await vi.advanceTimersByTimeAsync(0);
expect(sentOperations()).toEqual([renameTrigger('New order')]);
});
});
describe('flow state note edits', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
});
afterEach(() => {
vi.useRealTimers();
});
it('saves a new note when an edit of it follows within 1 s', async () => {
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(addNote());
await vi.advanceTimersByTimeAsync(300);
store.getState().applyOperation(updateNote('Call the customer'));
await vi.advanceTimersByTimeAsync(1000);
expect(sentOperations()).toEqual([
addNote(),
updateNote('Call the customer'),
]);
});
});
describe('flow state save retries', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
flowsApiMock.get.mockResolvedValue(draftFlow('Name on the server'));
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('retries a save with no response after 1 s, 2 s and 4 s', async () => {
const start = Date.now();
const attemptTimes: number[] = [];
flowsApiMock.update.mockImplementation(async () => {
attemptTimes.push(Date.now() - start);
throw networkError();
});
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(10_000);
expect(attemptTimes).toEqual([0, 1000, 3000, 7000]);
});
it.each([408, 429, 500, 503])(
'retries a save with a %i status',
async (status) => {
flowsApiMock.update.mockRejectedValue(httpError({ status }));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(10_000);
expect(flowsApiMock.update).toHaveBeenCalledTimes(4);
},
);
it.each([400, 404, 409])(
'never retries a save with a %i status',
async (status) => {
flowsApiMock.update.mockRejectedValue(httpError({ status }));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(10_000);
expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
},
);
it('keeps the edit when a retry succeeds', async () => {
flowsApiMock.update
.mockRejectedValueOnce(networkError())
.mockResolvedValue(draftFlow('First name'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(500);
expect(store.getState().saving).toBe(true);
await vi.advanceTimersByTimeAsync(10_000);
expect(store.getState().flowVersion.displayName).toBe('First name');
expect(store.getState().saving).toBe(false);
expect(flowsApiMock.get).not.toHaveBeenCalled();
expect(toast.error).not.toHaveBeenCalled();
});
it('sends later saves after the retries, in order', async () => {
flowsApiMock.update
.mockRejectedValueOnce(networkError())
.mockRejectedValueOnce(networkError())
.mockResolvedValue(draftFlow('Second name'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
store.getState().applyOperation(changeName('Second name'));
await vi.advanceTimersByTimeAsync(10_000);
expect(sentOperations()).toEqual([
changeName('First name'),
changeName('First name'),
changeName('First name'),
changeName('Second name'),
]);
});
it('runs the failure path after the last retry', async () => {
flowsApiMock.update.mockRejectedValue(networkError());
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(6_999);
expect(toast.error).not.toHaveBeenCalled();
expect(flowsApiMock.get).not.toHaveBeenCalled();
await vi.advanceTimersByTimeAsync(1);
expect(toast.error).toHaveBeenCalledWith(
'Your change was not saved',
expect.anything(),
);
expect(store.getState().flowVersion.displayName).toBe('Name on the server');
await vi.advanceTimersByTimeAsync(10_000);
expect(toast.error).toHaveBeenCalledTimes(1);
expect(flowsApiMock.get).toHaveBeenCalledTimes(1);
expect(store.getState().saving).toBe(false);
});
it.each([deleteBranch(), deleteSteps(), saveSampleData()])(
'never retries a $type save',
async (operation) => {
flowsApiMock.update.mockRejectedValue(networkError());
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(operation);
await vi.advanceTimersByTimeAsync(0);
expect(toast.error).toHaveBeenCalledWith(
'Your change was not saved',
expect.anything(),
);
await vi.advanceTimersByTimeAsync(10_000);
expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
},
);
});
describe('flow state edit order', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('sends a step edit that waits in the debounce before a later operation', async () => {
flowsApiMock.update.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
store.getState().applyOperation(changeName('New name'));
await vi.advanceTimersByTimeAsync(0);
expect(sentOperations()).toEqual([
renameTrigger('New order'),
changeName('New name'),
]);
});
});
describe('flow state saving flag', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('stays on while an edit waits in the debounce after a save ends', async () => {
const nameSave = Promise.withResolvers<PopulatedFlow>();
flowsApiMock.update
.mockReturnValueOnce(nameSave.promise)
.mockResolvedValue(draftFlow('New name'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('New name'));
await vi.advanceTimersByTimeAsync(0);
store.getState().applyOperation(renameTrigger('New order'));
nameSave.resolve(draftFlow('New name'));
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().saving).toBe(true);
await vi.advanceTimersByTimeAsync(1000);
expect(store.getState().saving).toBe(false);
});
it('stays on while a pending step edit saves after a failed save', async () => {
const triggerSave = Promise.withResolvers<PopulatedFlow>();
flowsApiMock.update.mockImplementation(
(_flowId: string, operation: FlowOperationRequest) =>
operation.type === FlowOperationType.CHANGE_NAME
? Promise.reject(httpError({ status: 400 }))
: triggerSave.promise,
);
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(renameTrigger('New order'));
store.getState().applyOperation(changeName('Bad name'));
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().saving).toBe(true);
triggerSave.resolve(draftFlow('Order lookup'));
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().saving).toBe(false);
});
});
describe('flow state pending edits made during a save of pending edits', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('settles only after an edit made during the wait is saved', async () => {
const firstSave = Promise.withResolvers<PopulatedFlow>();
const laterSave = Promise.withResolvers<PopulatedFlow>();
flowsApiMock.update
.mockReturnValueOnce(firstSave.promise)
.mockReturnValueOnce(laterSave.promise);
const store = createStore(draftFlow('Order lookup'));
const settled = vi.fn();
store.getState().applyOperation(renameTrigger('New order'));
const savingEdits = store.getState().savePendingEdits().then(settled);
store.getState().applyOperation(renameTrigger('Newer order'));
firstSave.resolve(draftFlow('Order lookup'));
await vi.advanceTimersByTimeAsync(0);
expect(sentOperations()).toEqual([
renameTrigger('New order'),
renameTrigger('Newer order'),
]);
expect(settled).not.toHaveBeenCalled();
laterSave.resolve(draftFlow('Order lookup'));
await savingEdits;
expect(settled).toHaveBeenCalled();
});
});
describe('flow state request timeout', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('fails a save that gets no answer in 60 s', async () => {
flowsApiMock.update.mockReturnValue(new Promise(() => undefined));
flowsApiMock.get.mockResolvedValue(draftFlow('Order lookup'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(deleteSteps());
const savingEdits = tryCatch(() => store.getState().savePendingEdits());
await vi.advanceTimersByTimeAsync(59_999);
expect(toast.error).not.toHaveBeenCalled();
await vi.advanceTimersByTimeAsync(1);
const { error } = await savingEdits;
expect(error?.message).toBe('timeout of 60000ms exceeded');
expect(toast.error).toHaveBeenCalledWith(
'Your change was not saved',
expect.anything(),
);
expect(store.getState().saving).toBe(false);
});
it('retries an idempotent save that gets no answer in 60 s', async () => {
flowsApiMock.update
.mockReturnValueOnce(new Promise(() => undefined))
.mockResolvedValue(draftFlow('New name'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('New name'));
await vi.advanceTimersByTimeAsync(60_999);
expect(flowsApiMock.update).toHaveBeenCalledTimes(1);
await vi.advanceTimersByTimeAsync(1);
expect(flowsApiMock.update).toHaveBeenCalledTimes(2);
expect(toast.error).not.toHaveBeenCalled();
});
it('fails a draft refetch that gets no answer in 60 s, and saves the next edit', async () => {
flowsApiMock.update
.mockRejectedValueOnce(httpError({ status: 400 }))
.mockResolvedValue(draftFlow('Second name'));
flowsApiMock.get.mockReturnValue(new Promise(() => undefined));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('First name'));
await vi.advanceTimersByTimeAsync(60_000);
expect(toast.error).toHaveBeenCalledWith(
'Something went wrong',
expect.anything(),
);
store.getState().applyOperation(changeName('Second name'));
await vi.advanceTimersByTimeAsync(0);
expect(sentOperations()).toEqual([
changeName('First name'),
changeName('Second name'),
]);
});
});
describe('flow state draft check before Publish', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('sends no request when no save failed', async () => {
const store = createStore(draftFlow('Order lookup'));
await store.getState().refreshDraftAfterFailedSave();
expect(flowsApiMock.get).not.toHaveBeenCalled();
});
it('refetches the draft when the refetch after a failed save failed', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get
.mockRejectedValueOnce(networkError())
.mockResolvedValue(draftFlow('Name on the server'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('Bad name'));
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().flowVersion.displayName).toBe('Bad name');
await store.getState().refreshDraftAfterFailedSave();
expect(flowsApiMock.get).toHaveBeenCalledTimes(2);
expect(store.getState().flowVersion.displayName).toBe(
'Name on the server',
);
});
it('fails when the draft cannot be refetched after a failed save', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get.mockRejectedValue(networkError());
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('Bad name'));
await vi.advanceTimersByTimeAsync(0);
const { error } = await tryCatch(() =>
store.getState().refreshDraftAfterFailedSave(),
);
expect(error?.message).toBe('Network Error');
});
it('sends no request after a Draft Refresh showed the failed save', async () => {
flowsApiMock.update.mockRejectedValue(httpError({ status: 400 }));
flowsApiMock.get.mockResolvedValue(draftFlow('Name on the server'));
const store = createStore(draftFlow('Order lookup'));
store.getState().applyOperation(changeName('Bad name'));
await vi.advanceTimersByTimeAsync(0);
await store.getState().refreshDraftAfterFailedSave();
expect(flowsApiMock.get).toHaveBeenCalledTimes(1);
});
});
describe('flow state draft refresh after a failed save', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
vi.spyOn(toast, 'error').mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('keeps the open step panel', async () => {
serveDraft(flowWithLookUpOrderStep());
const store = createStore(flowWithLookUpOrderStep());
store.getState().selectStepByName('step_1');
store.getState().applyOperation(changeName(NAME_THE_SERVER_REJECTS));
await vi.advanceTimersByTimeAsync(0);
expect(store.getState()).toMatchObject({
selectedStep: 'step_1',
rightSidebar: RightSideBarType.PIECE_SETTINGS,
});
expect(store.getState().flowVersion.displayName).toBe('Order lookup');
});
it('saves an edit inside the debounce before the refetch, and shows it', async () => {
serveDraft(flowWithLookUpOrderStep());
const store = createStore(flowWithLookUpOrderStep());
store.getState().applyOperation(renameTrigger('New order'));
store.getState().applyOperation(changeName(NAME_THE_SERVER_REJECTS));
await vi.advanceTimersByTimeAsync(10_000);
expect(store.getState().flowVersion).toMatchObject({
displayName: 'Order lookup',
trigger: { displayName: 'New order' },
});
});
it('does not apply a refetched draft while an edit waits, and fetches again', async () => {
const server = serveDraft(flowWithLookUpOrderStep());
const firstResponse = Promise.withResolvers<void>();
flowsApiMock.get.mockImplementationOnce(async () => {
const draftWithoutTheEdit = server.currentFlow();
await firstResponse.promise;
return draftWithoutTheEdit;
});
const store = createStore(flowWithLookUpOrderStep());
store.getState().applyOperation(changeName(NAME_THE_SERVER_REJECTS));
await vi.advanceTimersByTimeAsync(0);
store.getState().applyOperation(renameTrigger('New order'));
firstResponse.resolve();
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().flowVersion.trigger.displayName).toBe('New order');
await vi.advanceTimersByTimeAsync(10_000);
expect(flowsApiMock.get).toHaveBeenCalledTimes(2);
expect(store.getState().flowVersion).toMatchObject({
displayName: 'Order lookup',
trigger: { displayName: 'New order' },
});
});
it('does not apply a refetched draft when a save ends during the request, and fetches again', async () => {
const server = serveDraft(flowWithLookUpOrderStep());
const firstResponse = Promise.withResolvers<void>();
flowsApiMock.get.mockImplementationOnce(async () => {
const draftWithoutTheSave = server.currentFlow();
await firstResponse.promise;
return draftWithoutTheSave;
});
const store = createStore(flowWithLookUpOrderStep());
store.getState().applyOperation(changeName(NAME_THE_SERVER_REJECTS));
await vi.advanceTimersByTimeAsync(0);
store.getState().applyOperation(changeName('Order lookup by email'));
await vi.advanceTimersByTimeAsync(0);
firstResponse.resolve();
await vi.advanceTimersByTimeAsync(10_000);
expect(flowsApiMock.get).toHaveBeenCalledTimes(2);
expect(store.getState().flowVersion.displayName).toBe(
'Order lookup by email',
);
});
});
describe('flow state draft refresh', () => {
beforeEach(() => {
vi.useFakeTimers();
flowsApiMock.update.mockReset();
flowsApiMock.get.mockReset();
sampleDataApiMock.get.mockReset();
});
afterEach(() => {
vi.useRealTimers();
});
it('waits for a pause in the typing before it fetches the draft again', async () => {
const server = serveDraft(
withDisplayName({
flow: flowWithLookUpOrderStep(),
displayName: 'Order lookup by an agent',
}),
);
const firstResponse = Promise.withResolvers<void>();
flowsApiMock.get.mockImplementationOnce(async () => {
const draftBeforeTheTyping = server.currentFlow();
await firstResponse.promise;
return draftBeforeTheTyping;
});
const store = createStore(flowWithLookUpOrderStep());
const refresh = store.getState().refreshDraft();
await vi.advanceTimersByTimeAsync(0);
store.getState().applyOperation(renameTrigger('N'));
firstResponse.resolve();
for (const displayName of ['Ne', 'New', 'New o', 'New order']) {
await vi.advanceTimersByTimeAsync(300);
store.getState().applyOperation(renameTrigger(displayName));
}
await vi.advanceTimersByTimeAsync(300);
expect(flowsApiMock.get).toHaveBeenCalledTimes(1);
await vi.advanceTimersByTimeAsync(1000);
await refresh;
expect(sentOperations()).toEqual([renameTrigger('New order')]);
expect(flowsApiMock.get).toHaveBeenCalledTimes(2);
expect(store.getState().flowVersion).toMatchObject({
displayName: 'Order lookup by an agent',
trigger: { displayName: 'New order' },
});
});
it('does not replace a run that the tab opens while the draft request runs', async () => {
const response = Promise.withResolvers<PopulatedFlow>();
flowsApiMock.get.mockReturnValue(response.promise);
const store = createStore(flowWithLookUpOrderStep());
const refresh = store.getState().refreshDraft();
await vi.advanceTimersByTimeAsync(0);
store.getState().setRun(testRun(), {
...store.getState().flowVersion,
displayName: 'Order lookup at the time of the run',
});
response.resolve(
withDisplayName({
flow: flowWithLookUpOrderStep(),
displayName: 'Order lookup by an agent',
}),
);
await expect(refresh).resolves.toBe(false);
expect(store.getState().flowVersion.displayName).toBe(
'Order lookup at the time of the run',
);
});
it('ignores the published version that the tab opens after its own save created the draft', async () => {
const published = publishedFlowWithNoDraft();
flowsApiMock.update.mockResolvedValue(flowWithLookUpOrderStep());
flowsApiMock.get.mockResolvedValue(flowWithLookUpOrderStep());
const store = createStore(published);
store.getState().applyOperation(changeName('Order lookup by email'));
await vi.advanceTimersByTimeAsync(0);
store.getState().setVersion(published.version);
await expect(store.getState().refreshDraft()).resolves.toBe(false);
expect(flowsApiMock.get).not.toHaveBeenCalled();
});
it('ignores the published version that the tab opens after it showed a new draft', async () => {
const published = publishedFlowWithNoDraft();
flowsApiMock.get.mockResolvedValue(flowWithLookUpOrderStep());
const store = createStore(published);
store.getState().setVersion(flowWithLookUpOrderStep().version);
store.getState().setVersion(published.version);
await expect(store.getState().refreshDraft()).resolves.toBe(false);
expect(flowsApiMock.get).not.toHaveBeenCalled();
});
it('ignores a version under review that the tab opened by its id', async () => {
const published = publishedFlowWithNoDraft();
const underReview: PopulatedFlow = {
...published,
version: { ...published.version, id: 'version-2' },
};
flowsApiMock.get.mockResolvedValue(flowWithLookUpOrderStep());
const store = createStore(underReview);
await expect(store.getState().refreshDraft()).resolves.toBe(false);
expect(flowsApiMock.get).not.toHaveBeenCalled();
});
it('makes the tab read-only when a different tab submits the draft for approval', async () => {
const draft = flowWithLookUpOrderStep();
flowsApiMock.get.mockResolvedValue(withLockedVersion(draft));
const store = createStore(draft);
await expect(store.getState().refreshDraft()).resolves.toBe(true);
expect(store.getState()).toMatchObject({
readonly: true,
flowVersion: { id: 'draft-1', state: FlowVersionState.LOCKED },
});
});
it('keeps the tab editable when a different tab publishes the draft', async () => {
const draft = flowWithLookUpOrderStep();
flowsApiMock.get.mockResolvedValue({
...withLockedVersion(draft),
publishedVersionId: 'draft-1',
});
const store = createStore(draft);
await expect(store.getState().refreshDraft()).resolves.toBe(true);
expect(store.getState()).toMatchObject({
readonly: false,
flowVersion: { id: 'draft-1', state: FlowVersionState.LOCKED },
});
});
it('shows the test data that a different tab saved for a step', async () => {
flowsApiMock.get.mockResolvedValue(
withLookUpOrderTestData({
sampleDataFileId: 'output-2',
sampleDataInputFileId: 'input-2',
lastTestDate: '2026-01-02T00:00:00.000Z',
}),
);
sampleDataApiMock.get.mockImplementation(async ({ type }) =>
type === SampleDataFileType.OUTPUT
? { orderId: 'order-2' }
: { email: '[email protected]' },
);
const store = createStore(
withLookUpOrderTestData({
sampleDataFileId: 'output-1',
lastTestDate: '2026-01-01T00:00:00.000Z',
}),
);
store.getState().setSampleDataLocally({
stepName: 'step_1',
type: 'output',
value: { orderId: 'order-1' },
});
await store.getState().refreshDraft();
await vi.advanceTimersByTimeAsync(0);
expect(store.getState()).toMatchObject({
outputSampleData: { step_1: { orderId: 'order-2' } },
inputSampleData: { step_1: { email: '[email protected]' } },
});
expect(sampleDataApiMock.get).toHaveBeenCalledWith(
expect.objectContaining({ stepName: 'step_1', flowVersionId: 'draft-1' }),
);
});
it('fetches no test data when the refresh changes no test data', async () => {
const tested = withLookUpOrderTestData({ sampleDataFileId: 'output-1' });
flowsApiMock.get.mockResolvedValue(
withDisplayName({ flow: tested, displayName: 'Order lookup by email' }),
);
const store = createStore(tested);
await store.getState().refreshDraft();
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().flowVersion.displayName).toBe(
'Order lookup by email',
);
expect(sampleDataApiMock.get).not.toHaveBeenCalled();
});
it('keeps the shown test data when the fetch of the new test data fails', async () => {
flowsApiMock.get.mockResolvedValue(
withLookUpOrderTestData({ sampleDataFileId: 'output-2' }),
);
sampleDataApiMock.get.mockRejectedValue(networkError());
const store = createStore(
withLookUpOrderTestData({ sampleDataFileId: 'output-1' }),
);
store.getState().setSampleDataLocally({
stepName: 'step_1',
type: 'output',
value: { orderId: 'order-1' },
});
await store.getState().refreshDraft();
await vi.advanceTimersByTimeAsync(0);
expect(store.getState().outputSampleData.step_1).toEqual({
orderId: 'order-1',
});
});
it('sends one GET at a time when a refresh starts as the previous refresh ends', async () => {
const server = serveDraft(flowWithLookUpOrderStep());
let getsInFlight = 0;
let mostGetsInFlight = 0;
flowsApiMock.get.mockImplementation(async () => {
getsInFlight++;
mostGetsInFlight = Math.max(mostGetsInFlight, getsInFlight);
await new Promise((resolve) => setTimeout(resolve, 100));
getsInFlight--;
return server.currentFlow();
});
const store = createStore(flowWithLookUpOrderStep());
const firstRefresh = store.getState().refreshDraft();
const queuedRefresh = store.getState().refreshDraft();
const refreshAsTheFirstEnds = firstRefresh.then(() =>
store.getState().refreshDraft(),
);
await vi.advanceTimersByTimeAsync(1000);
await Promise.all([queuedRefresh, refreshAsTheFirstEnds]);
expect(mostGetsInFlight).toBe(1);
expect(flowsApiMock.get).toHaveBeenCalledTimes(2);
});
});
function testRun(): FlowRun {
return {
id: 'run-1',
created: '2026-01-01T00:00:00.000Z',
updated: '2026-01-01T00:00:00.000Z',
projectId: 'project-1',
flowId: 'flow-1',
flowVersionId: 'draft-1',
failParentOnFailure: false,
logsFileId: null,
status: FlowRunStatus.SUCCEEDED,
environment: RunEnvironment.TESTING,
steps: {},
tags: [],
archivedAt: null,
};
}
function withDisplayName({
flow,
displayName,
}: {
flow: PopulatedFlow;
displayName: string;
}): PopulatedFlow {
return { ...flow, version: { ...flow.version, displayName } };
}
function withLockedVersion(flow: PopulatedFlow): PopulatedFlow {
return {
...flow,
version: { ...flow.version, state: FlowVersionState.LOCKED },
};
}
function serveDraft(flow: PopulatedFlow) {
let draft = flow.version;
const currentFlow = (): PopulatedFlow => ({ ...flow, version: draft });
flowsApiMock.update.mockImplementation(
async (_flowId: string, operation: FlowOperationRequest) => {
if (
operation.type === FlowOperationType.CHANGE_NAME &&
operation.request.displayName === NAME_THE_SERVER_REJECTS
) {
throw httpError({ status: 400 });
}
draft = flowOperations.apply(draft, operation);
return currentFlow();
},
);
flowsApiMock.get.mockImplementation(async () => currentFlow());
return { currentFlow };
}
function publishedFlowWithNoDraft(): PopulatedFlow {
const flow = flowWithLookUpOrderStep();
return {
...flow,
publishedVersionId: 'version-1',
version: {
...flow.version,
id: 'version-1',
state: FlowVersionState.LOCKED,
},
};
}
function flowWithLookUpOrderStep(): PopulatedFlow {
const flow = draftFlow('Order lookup');
return {
...flow,
version: {
...flow.version,
trigger: { ...flow.version.trigger, nextAction: lookUpOrderStep() },
},
};
}
function withLookUpOrderTestData(
sampleData: SampleDataSettings,
): PopulatedFlow {
const flow = flowWithLookUpOrderStep();
const step = lookUpOrderStep();
return {
...flow,
version: {
...flow.version,
trigger: {
...flow.version.trigger,
nextAction: { ...step, settings: { ...step.settings, sampleData } },
},
},
};
}
function lookUpOrderStep(): CodeAction {
return {
name: 'step_1',
valid: true,
displayName: 'Look up order',
lastUpdatedDate: '2026-01-01T00:00:00.000Z',
type: FlowActionType.CODE,
settings: {
sourceCode: {
code: 'export const code = async (inputs) => inputs;',
packageJson: '{}',
},
input: {},
errorHandlingOptions: {},
},
};
}
function networkError() {
return new AxiosError('Network Error', AxiosError.ERR_NETWORK, undefined, {});
}
function serverError(message: string) {
return httpError({
status: 400,
data: { code: 'FLOW_OPERATION_INVALID', params: { message } },
});
}
function httpError({ status, data = {} }: { status: number; data?: unknown }) {
return new AxiosError(
`Request failed with status code ${status}`,
status >= 500 ? AxiosError.ERR_BAD_RESPONSE : AxiosError.ERR_BAD_REQUEST,
undefined,
{},
{
data,
status,
statusText: '',
headers: {},
config: { headers: new AxiosHeaders() },
},
);
}
function changeName(displayName: string): FlowOperationRequest {
return {
type: FlowOperationType.CHANGE_NAME,
request: { displayName },
};
}
function deleteBranch(): FlowOperationRequest {
return {
type: FlowOperationType.DELETE_BRANCH,
request: { stepName: 'step_1', branchIndex: 0 },
};
}
function deleteSteps(): FlowOperationRequest {
return {
type: FlowOperationType.DELETE_ACTION,
request: { names: ['step_1'] },
};
}
function saveSampleData(): FlowOperationRequest {
return {
type: FlowOperationType.SAVE_SAMPLE_DATA,
request: {
stepName: 'trigger',
payload: { orderId: 'order-1' },
type: SampleDataFileType.OUTPUT,
},
};
}
function addNote(): FlowOperationRequest {
return {
type: FlowOperationType.ADD_NOTE,
request: {
id: 'note-1',
content: '',
color: NoteColorVariant.YELLOW,
position: { x: 0, y: 0 },
size: { width: 200, height: 200 },
},
};
}
function updateNote(content: string): FlowOperationRequest {
return {
type: FlowOperationType.UPDATE_NOTE,
request: {
id: 'note-1',
content,
ownerId: null,
color: NoteColorVariant.YELLOW,
position: { x: 0, y: 0 },
size: { width: 200, height: 200 },
},
};
}
function renameTrigger(displayName: string): FlowOperationRequest {
return {
type: FlowOperationType.UPDATE_TRIGGER,
request: {
name: 'trigger',
valid: false,
displayName,
type: FlowTriggerType.EMPTY,
settings: {},
},
};
}
function sentOperations(): FlowOperationRequest[] {
return flowsApiMock.update.mock.calls.map(([, operation]) => operation);
}
function createStore(flow: PopulatedFlow): BuilderStore {
return createBuilderStore({
flow,
flowVersion: flow.version,
readonly: false,
hideTestWidget: false,
run: null,
outputSampleData: {},
inputSampleData: {},
socket: io({ autoConnect: false }),
queryClient: new QueryClient(),
});
}
async function flushPromises() {
await new Promise((resolve) => setTimeout(resolve, 0));
}
function draftFlow(displayName: string): PopulatedFlow {
const trigger: EmptyTrigger = {
name: 'trigger',
valid: false,
displayName: 'Select Trigger',
type: FlowTriggerType.EMPTY,
settings: {},
lastUpdatedDate: '2026-01-01T00:00:00.000Z',
};
return {
id: 'flow-1',
created: '2026-01-01T00:00:00.000Z',
updated: '2026-01-01T00:00:00.000Z',
projectId: 'project-1',
externalId: 'flow-1',
ownerId: null,
folderId: null,
status: FlowStatus.DISABLED,
publishedVersionId: null,
metadata: null,
operationStatus: FlowOperationStatus.NONE,
timeSavedPerRun: null,
templateId: null,
createdBy: null,
version: {
id: 'draft-1',
created: '2026-01-01T00:00:00.000Z',
updated: '2026-01-01T00:00:00.000Z',
flowId: 'flow-1',
displayName,
trigger,
updatedBy: null,
valid: false,
schemaVersion: null,
agentIds: [],
state: FlowVersionState.DRAFT,
connectionIds: [],
backupFiles: null,
notes: [],
},
};
}
const NAME_THE_SERVER_REJECTS = 'Name the server rejects';