@wise/dynamic-flow-client-internal 5.28.1 → 5.28.2

package/build/tests/Subflow.Wise.test.js

@@ -0,0 +1,650 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderWithProviders, respondWith, wait } from '../test-utils';
+import { DynamicFlow } from '../dynamicFlow/DynamicFlow';
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from '@testing-library/react';
+import { act } from 'react';
+import { respondWithDelay } from '../test-utils/respond-with';
+const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTimeAsync });
+describe('Subflow', () => {
+    const getDefaultProps = () => ({
+        flowId: 'flow-id',
+        customFetch: vi.fn(),
+        onCompletion: vi.fn(),
+        onError: vi.fn(),
+        onEvent: vi.fn(),
+        onLog: vi.fn(),
+    });
+    const cases = [
+        [
+            'given a subflow behavior on a trigger',
+            (subflow) => ({
+                mockHttpClient: vi.fn(),
+                initialStep: {
+                    id: 'my-step',
+                    title: 'Step',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            title: 'Open subflow',
+                            behavior: subflow,
+                        },
+                    ],
+                },
+            }),
+        ],
+        [
+            'given a subflow response',
+            (subflow) => ({
+                mockHttpClient: vi
+                    .fn()
+                    .mockImplementationOnce(async () => respondWith(subflow, { headers: [['X-DF-Response-Type', 'subflow']] })),
+                initialStep: {
+                    id: 'my-step',
+                    title: 'Step',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            title: 'Open subflow',
+                            behavior: {
+                                type: 'action',
+                                action: {
+                                    url: '/start-subflow',
+                                    method: 'POST',
+                                },
+                            },
+                        },
+                    ],
+                },
+            }),
+        ],
+    ];
+    const modallyPresentedSubflow = {
+        type: 'subflow',
+        referrerId: 'flow-a',
+        launchConfig: {
+            type: 'dynamic',
+            request: {
+                url: '/subflow-url',
+                method: 'GET',
+            },
+            presentation: {
+                type: 'modal',
+            },
+        },
+    };
+    describe.each(cases)('%s', (name, getProps) => {
+        describe('given the subflow is modally presented', () => {
+            const subflow = modallyPresentedSubflow;
+            it('displays the subflow modally with the correct events', async () => {
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [],
+                }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                await waitFor(() => {
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                });
+                // content is still behind the modal
+                expect(screen.getByText('Open subflow')).toBeInTheDocument();
+                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
+                    integrationId: 'flow-id',
+                    referrerId: 'flow-a',
+                }));
+            });
+            it('the modal close button cancels the subflow', async () => {
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [],
+                }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                await waitFor(() => {
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                });
+                await user.click(screen.getByRole('button', { name: /close/i }));
+                await waitFor(() => {
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+            });
+            it('refreshAfter is suspended when the subflow modal is open', async () => {
+                const refreshAfter = new Date(Date.now() + 1000).toISOString();
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockImplementation(async (input) => {
+                    if (input === '/polling-url') {
+                        return respondWith('', { status: 200 });
+                    }
+                    return respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [],
+                    });
+                });
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: Object.assign(Object.assign({}, initialStep), { refreshAfter, refreshUrl: '/refresh' }), customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                await act(async () => vi.advanceTimersByTimeAsync(1100));
+                expect(httpClient).not.toHaveBeenCalledWith('/refresh', expect.anything());
+                httpClient.mockClear();
+                await user.click(screen.getByRole('button', { name: /close/i }));
+            });
+            it('refreshAfter is resumed when the subflow modal is closed', async () => {
+                const refreshAfter = new Date(Date.now() + 2000).toISOString();
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockReturnValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [],
+                }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: Object.assign(Object.assign({}, initialStep), { refreshAfter, refreshUrl: '/refresh' }), customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                await act(async () => vi.advanceTimersByTimeAsync(5000));
+                await user.click(screen.getByRole('button', { name: /close/i }));
+                // the timer isn't being started reliably in before the assertions
+                // (i.e. there are no fake timers to advance yet), so adding a manual wait
+                await act(async () => wait(500));
+                await waitFor(() => {
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+                await act(async () => {
+                    await vi.advanceTimersByTimeAsync(1000);
+                });
+                await waitFor(async () => {
+                    expect(httpClient).toHaveBeenCalledWith('/refresh', expect.anything());
+                });
+            });
+        });
+        describe('given the subflow is push presented', () => {
+            const subflow = {
+                type: 'subflow',
+                referrerId: 'flow-a',
+                launchConfig: {
+                    type: 'dynamic',
+                    request: {
+                        url: '/subflow-url',
+                        method: 'GET',
+                    },
+                    presentation: {
+                        type: 'push',
+                    },
+                },
+            };
+            it('displays the subflow with the correct events', async () => {
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [],
+                }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                // parent content is gone
+                expect(screen.queryByText('Open subflow')).not.toBeInTheDocument();
+                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
+                    integrationId: 'flow-id',
+                    referrerId: 'flow-a',
+                }));
+            });
+            it('displays the back button which cancels the subflow', async () => {
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [],
+                }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                await user.click(screen.getByRole('button', { name: /back/i }));
+                expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+            });
+        });
+        describe('when a subflow completes', () => {
+            describe('the onCompletion behavior is an action', () => {
+                const subflow = {
+                    type: 'subflow',
+                    referrerId: 'flow-a',
+                    launchConfig: {
+                        type: 'dynamic',
+                        request: {
+                            url: '/subflow-url',
+                            method: 'GET',
+                        },
+                        presentation: {
+                            type: 'push',
+                        },
+                    },
+                    onCompletion: {
+                        type: 'action',
+                        action: {
+                            url: '/subflow-completion',
+                            data: {
+                                parentData: 'asdf',
+                                duplicatedData: 'abc',
+                            },
+                        },
+                    },
+                };
+                it('removes the subflow and the action is triggered merging the parent content with the subflow result', async () => {
+                    const onEvent = vi.fn();
+                    const { initialStep, mockHttpClient } = getProps(subflow);
+                    const httpClient = mockHttpClient
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [
+                            {
+                                type: 'button',
+                                title: 'Complete subflow',
+                                behavior: {
+                                    type: 'action',
+                                    action: {
+                                        exit: true,
+                                        result: {
+                                            subflowData: 'asdf',
+                                            duplicatedData: 'def',
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    }))
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'step-2',
+                        title: 'Step 2',
+                        schemas: [],
+                        layout: [],
+                    }));
+                    renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { features: { nativeBack: true }, initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                    await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    await user.click(screen.getByRole('button', { name: 'Complete subflow' }));
+                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Succeeded', expect.objectContaining({
+                        referrerId: 'flow-a',
+                        integrationId: 'flow-id',
+                    }));
+                    expect(httpClient).toHaveBeenCalledWith('/subflow-completion', expect.objectContaining({
+                        body: JSON.stringify({
+                            parentData: 'asdf',
+                            duplicatedData: 'def',
+                            subflowData: 'asdf',
+                        }),
+                    }));
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+                it('shows the loader on the final step of the subflow, while the onCompletion behavior is running', async () => {
+                    const onEvent = vi.fn();
+                    const { initialStep, mockHttpClient } = getProps(subflow);
+                    const httpClient = mockHttpClient
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [
+                            {
+                                type: 'button',
+                                title: 'Complete subflow',
+                                behavior: {
+                                    type: 'action',
+                                    action: {
+                                        exit: true,
+                                        result: {
+                                            subflowData: 'asdf',
+                                            duplicatedData: 'def',
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    }))
+                        .mockImplementationOnce(async () => {
+                        return respondWithDelay({ id: 'second-step', title: 'Next parent step', layout: [], schemas: [] }, 1000);
+                    });
+                    renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                    await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                    await waitFor(() => {
+                        expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    });
+                    await user.click(screen.getByRole('button', { name: 'Complete subflow' }));
+                    // the button label is replaced with 'loading' when it's loading...
+                    expect(screen.getByRole('button', { name: 'loading' })).toBeDisabled();
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    await waitFor(() => {
+                        expect(screen.getByText('Next parent step')).toBeInTheDocument();
+                    });
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+            });
+            describe('when the behavior is a refresh', () => {
+                const subflow = {
+                    type: 'subflow',
+                    referrerId: 'flow-a',
+                    launchConfig: {
+                        type: 'dynamic',
+                        request: {
+                            url: '/subflow-url',
+                            method: 'GET',
+                        },
+                        presentation: {
+                            type: 'push',
+                        },
+                    },
+                    onCompletion: {
+                        type: 'refresh',
+                    },
+                };
+                it('removes the subflow and does not merge the result into the request', async () => {
+                    const onEvent = vi.fn();
+                    const { initialStep, mockHttpClient } = getProps(subflow);
+                    const httpClient = mockHttpClient
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [
+                            {
+                                type: 'button',
+                                title: 'Complete subflow',
+                                behavior: {
+                                    type: 'action',
+                                    action: {
+                                        exit: true,
+                                        result: {
+                                            subflowData: 'asdf',
+                                            duplicatedData: 'def',
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    }))
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'step-2',
+                        title: 'Step 2',
+                        schemas: [],
+                        layout: [],
+                    }));
+                    renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { features: { nativeBack: true }, initialStep: Object.assign(Object.assign({}, initialStep), { refreshUrl: '/refresh' }), customFetch: httpClient, onEvent: onEvent })));
+                    await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    await user.click(screen.getByRole('button', { name: 'Complete subflow' }));
+                    expect(httpClient).toHaveBeenCalledWith('/refresh', expect.objectContaining({
+                        body: 'null',
+                    }));
+                });
+                it('immediately closes the subflow, and shows the loader on the parent', async () => {
+                    const onEvent = vi.fn();
+                    const { initialStep, mockHttpClient } = getProps(subflow);
+                    const httpClient = mockHttpClient
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [
+                            {
+                                type: 'button',
+                                title: 'Complete subflow',
+                                behavior: {
+                                    type: 'refresh',
+                                },
+                            },
+                        ],
+                    }))
+                        .mockImplementationOnce(async () => {
+                        return respondWithDelay({ id: 'second-step', title: 'Next parent step', layout: [], schemas: [] }, 1000);
+                    });
+                    renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                    await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    await user.click(screen.getByRole('button', { name: 'Complete subflow' }));
+                    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+                    await waitFor(() => {
+                        expect(screen.getByText('Next parent step')).toBeInTheDocument();
+                    });
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+            });
+        });
+        describe('when a subflow fails', () => {
+            describe('and the onError behavior is an action', () => {
+                const subflow = {
+                    type: 'subflow',
+                    referrerId: 'flow-a',
+                    launchConfig: {
+                        type: 'dynamic',
+                        request: {
+                            url: '/subflow-url',
+                            method: 'GET',
+                        },
+                        presentation: {
+                            type: 'push',
+                        },
+                    },
+                    onError: {
+                        type: 'action',
+                        action: {
+                            url: '/subflow-error',
+                        },
+                    },
+                };
+                it('removes the subflow and triggers the behavior', async () => {
+                    const onEvent = vi.fn();
+                    const { initialStep, mockHttpClient } = getProps(subflow);
+                    const httpClient = mockHttpClient
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        refreshUrl: '/bad-refresh',
+                        layout: [
+                            {
+                                type: 'button',
+                                title: 'Trigger flow error',
+                                behavior: {
+                                    type: 'refresh',
+                                },
+                            },
+                        ],
+                    }))
+                        .mockResolvedValueOnce(respondWith({}, { status: 400 }))
+                        .mockResolvedValueOnce(respondWith({
+                        id: 'step-2',
+                        title: 'Step 2',
+                        schemas: [],
+                        layout: [],
+                    }));
+                    renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { features: { nativeBack: true }, initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                    await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                    await user.click(screen.getByRole('button', { name: 'Trigger flow error' }));
+                    expect(httpClient).toHaveBeenCalledWith('/subflow-error', expect.objectContaining({
+                        body: undefined,
+                    }));
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+            });
+        });
+        describe('when that subflow launches another subflow', () => {
+            const subflow = {
+                type: 'subflow',
+                referrerId: 'flow-a',
+                resultKey: 'child-data',
+                launchConfig: {
+                    type: 'dynamic',
+                    request: {
+                        url: '/subflow-url',
+                        method: 'GET',
+                    },
+                    presentation: {
+                        type: 'modal',
+                    },
+                },
+                onCompletion: {
+                    type: 'action',
+                    action: {
+                        url: '/subflow-submit',
+                        data: { subflow1: 'abc' },
+                    },
+                },
+                onError: {
+                    type: 'action',
+                    action: {
+                        url: '/subflow-error',
+                    },
+                },
+            };
+            const subflow2 = {
+                type: 'subflow',
+                referrerId: 'flow-b',
+                launchConfig: {
+                    type: 'dynamic',
+                    request: {
+                        url: '/subflow-url',
+                        method: 'GET',
+                    },
+                    presentation: {
+                        type: 'modal',
+                    },
+                },
+                onCompletion: {
+                    type: 'action',
+                    action: {
+                        exit: true,
+                        result: { subflow2: 'def' },
+                    },
+                },
+                onError: {
+                    type: 'action',
+                    action: {
+                        url: '/subflow-error',
+                    },
+                },
+            };
+            it('uses correct referrerId and merges data according to the resultKey', async () => {
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient
+                    .mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            title: 'Another subflow',
+                            behavior: {
+                                type: 'action',
+                                action: {
+                                    url: '/test',
+                                },
+                            },
+                        },
+                    ],
+                }))
+                    .mockResolvedValueOnce(respondWith(subflow2, { headers: [['X-DF-Response-Type', 'subflow']] }))
+                    .mockResolvedValueOnce(respondWith({
+                    id: 'subflow-step',
+                    title: 'Subflow Step 2',
+                    schemas: [],
+                    layout: [
+                        {
+                            type: 'button',
+                            title: 'Close subflow',
+                            behavior: {
+                                type: 'action',
+                                action: {
+                                    exit: true,
+                                },
+                            },
+                        },
+                    ],
+                }))
+                    .mockResolvedValueOnce(respondWith({ value1: 'abc' }, { headers: [['X-DF-Response-Type', 'exit']] }));
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: initialStep, customFetch: httpClient, onEvent: onEvent })));
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                await waitFor(() => {
+                    expect(screen.getByText('Subflow Step')).toBeInTheDocument();
+                });
+                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
+                    referrerId: 'flow-a',
+                }));
+                await user.click(screen.getByRole('button', { name: 'Another subflow' }));
+                await waitFor(() => {
+                    expect(screen.getByText('Subflow Step 2')).toBeInTheDocument();
+                });
+                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
+                    referrerId: 'flow-b',
+                }));
+                await user.click(screen.getByRole('button', { name: 'Close subflow' }));
+                await waitFor(() => {
+                    expect(httpClient).toHaveBeenLastCalledWith('/subflow-submit', expect.objectContaining({
+                        body: JSON.stringify({ subflow1: 'abc', 'child-data': { subflow2: 'def' } }),
+                    }));
+                });
+            });
+        });
+    });
+    describe.each([cases[0]])('%s', (name, getProps) => {
+        describe('given the subflow is modally presented', () => {
+            const subflow = modallyPresentedSubflow;
+            it('any polling requests are paused when the subflow modal is open, and resumed when the subflow modal is closed', async () => {
+                const polling = {
+                    url: '/polling-url',
+                    maxAttempts: 100,
+                    interval: 200,
+                    onError: { behavior: { type: 'link', url: '/error' } },
+                };
+                const onEvent = vi.fn();
+                const { initialStep, mockHttpClient } = getProps(subflow);
+                const httpClient = mockHttpClient.mockImplementation(async (input) => {
+                    if (input === '/polling-url') {
+                        return respondWith('', { status: 200 });
+                    }
+                    if (input === '/start-subflow') {
+                        return respondWith(subflow, { headers: [['X-DF-Response-Type', 'subflow']] });
+                    }
+                    return respondWith({
+                        id: 'subflow-step',
+                        title: 'Subflow Step',
+                        schemas: [],
+                        layout: [],
+                    });
+                });
+                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, getDefaultProps(), { initialStep: Object.assign(Object.assign({}, initialStep), { polling }), customFetch: httpClient, onEvent: onEvent })));
+                await act(async () => vi.advanceTimersByTimeAsync(200));
+                expect(httpClient).toHaveBeenCalledWith('/polling-url', expect.anything());
+                httpClient.mockClear();
+                await user.click(screen.getByRole('button', { name: 'Open subflow' }));
+                // await act(async () => vi.advanceTimersByTimeAsync(400));
+                expect(httpClient).not.toHaveBeenCalledWith('/polling-url', expect.anything());
+                httpClient.mockClear();
+                await user.click(screen.getByRole('button', { name: /close/i }));
+                await waitFor(() => {
+                    expect(screen.queryByText('Subflow Step')).not.toBeInTheDocument();
+                });
+                await act(async () => vi.advanceTimersByTimeAsync(200));
+                expect(httpClient).toHaveBeenCalledWith('/polling-url', expect.anything());
+            });
+        });
+    });
+});