@wise/dynamic-flow-client 5.12.1 → 5.13.0-experimental-13d828c

package/build/tests/Polling.test.js

@@ -1,702 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { act, screen, waitFor } from '@testing-library/react';
-import { userEvent } from '@testing-library/user-event';
-import { vi } from 'vitest';
-import { renderWithProviders, wait } from '../test-utils';
-import DynamicFlowWise from '../test-utils/DynamicFlowWise';
-import { abortableDelay, respondWith, respondWithDelay } from '../test-utils/fetch-utils';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-const cases = [
-    [
-        'a config with onError.behavior of type "action" (current behavior spec)',
-        {
-            url: '/polling',
-            interval: 2,
-            maxAttempts: 10,
-            onError: {
-                behavior: {
-                    type: 'action',
-                    action: { url: '/failure', data: { what: 'there was an error' }, skipValidation: true },
-                },
-            },
-        },
-    ],
-    [
-        'a config with onError.behavior.action (deprecated behavior spec)',
-        {
-            url: '/polling',
-            interval: 2,
-            maxAttempts: 10,
-            onError: {
-                behavior: {
-                    action: { url: '/failure', data: { what: 'there was an error' }, skipValidation: true },
-                },
-            },
-        },
-    ],
-    [
-        'a config with onError.action (deprecated polling spec)',
-        {
-            url: '/polling',
-            interval: 2,
-            maxAttempts: 10,
-            onError: {
-                action: { url: '/failure', data: { what: 'there was an error' }, skipValidation: true },
-            },
-        },
-    ],
-];
-describe.each(cases)('Given %s', (_, pollingConfig) => {
-    const initialStep = (config = pollingConfig) => ({
-        id: 'polling',
-        title: 'polling title',
-        polling: config,
-        schemas: [],
-        layout: [],
-    });
-    it('will poll with the configuration provided (initialAction)', async () => {
-        const mockHttpClient = vi.fn(async (input) => {
-            if (input === '/initial') {
-                return respondWith(initialStep(), { status: 200 });
-            }
-            if (input === '/polling') {
-                return respondWith({}, { status: 200 });
-            }
-            return respondWith({}, { status: 404 });
-        });
-        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialAction: {
-                url: '/initial',
-                method: 'GET',
-            }, onError: () => { }, onCompletion: () => { } }));
-        await waitFor(() => {
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-        });
-        expect(mockHttpClient).toHaveBeenCalledTimes(2); // initial + first poll
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(mockHttpClient).toHaveBeenCalledTimes(3); // second poll
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(mockHttpClient).toHaveBeenCalledTimes(4); // third poll
-    });
-    it('will poll with the configuration provided (initialStep)', async () => {
-        const mockHttpClient = vi.fn().mockResolvedValue(new Response('', { status: 200 }));
-        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-        await waitFor(() => {
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-        });
-        expect(mockHttpClient).toHaveBeenCalledTimes(1);
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(mockHttpClient).toHaveBeenCalledTimes(2);
-        await vi.advanceTimersByTimeAsync(2000);
-        expect(mockHttpClient).toHaveBeenCalledTimes(3);
-    });
-    describe('when an action is triggered by the user', () => {
-        it('polling continues until the step is replaced', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({}, { status: 200 });
-                    case '/user-action':
-                        return respondWithDelay({
-                            id: 'second-step',
-                            title: 'Second step',
-                            layout: [],
-                            schemas: [],
-                        }, 4500);
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: Object.assign(Object.assign({}, initialStep()), { layout: [
-                        {
-                            type: 'button',
-                            action: {
-                                url: '/user-action',
-                                title: 'Submit',
-                            },
-                        },
-                    ] }), onError: () => { }, onCompletion: () => { } }));
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            await user.click(screen.getByText('Submit'));
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/user-action', expect.any(Object));
-            // after submitting we continue polling
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/polling', expect.anything());
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/polling', expect.anything());
-            mockHttpClient.mockClear();
-            await waitFor(() => {
-                expect(screen.getByText('Second step')).toBeInTheDocument();
-            });
-            // once the submission returns with a new step, no more polling!
-            await vi.advanceTimersByTimeAsync(4000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(0);
-        });
-    });
-    describe('when the polling (eventually) returns an action', () => {
-        const getMockHttpClient = () => {
-            let pollingAttempts = 0;
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        if (pollingAttempts <= 1) {
-                            pollingAttempts += 1;
-                            return respondWith({}, { status: 200 });
-                        }
-                        return respondWith({ action: { url: '/success', data: { all: 'good' } } });
-                    case '/success':
-                        return respondWith({
-                            id: 'second-step',
-                            title: 'Second step',
-                            layout: [],
-                            schemas: [],
-                        });
-                }
-            });
-            return mockHttpClient;
-        };
-        it('triggers the action, using the action data WITHOUT using the current model', async () => {
-            const mockHttpClient = getMockHttpClient();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: Object.assign(Object.assign({}, initialStep()), { schemas: [
-                        {
-                            $id: '#schema',
-                            type: 'object',
-                            displayOrder: ['name'],
-                            required: ['name'],
-                            properties: {
-                                name: {
-                                    type: 'string',
-                                    title: 'Name',
-                                    default: 'Bob Loblaw',
-                                },
-                            },
-                        },
-                    ], layout: [
-                        {
-                            type: 'form',
-                            schemaId: '#schema',
-                        },
-                        {
-                            type: 'button',
-                            action: {
-                                url: '/user-action',
-                                title: 'Submit',
-                            },
-                        },
-                    ] }), onError: () => { }, onCompletion: () => { } }));
-            await act(async () => vi.advanceTimersByTimeAsync(4000));
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/success', expect.any(Object));
-            const lastRequestBody = mockHttpClient.mock.calls[mockHttpClient.mock.calls.length - 1][1].body;
-            expect(JSON.parse(lastRequestBody)).toHaveProperty('all', 'good'); // action data
-            expect(JSON.parse(lastRequestBody)).not.toHaveProperty('name', 'Bob Loblaw'); // current model
-        });
-        it('polling is stopped', async () => {
-            const mockHttpClient = getMockHttpClient();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: Object.assign(Object.assign({}, initialStep()), { layout: [
-                        {
-                            type: 'button',
-                            action: {
-                                url: '/user-action',
-                                title: 'Submit',
-                            },
-                        },
-                    ] }), onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            await act(async () => vi.advanceTimersByTimeAsync(2000));
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/success', expect.any(Object));
-            expect(mockHttpClient).toHaveBeenCalledTimes(4);
-            await waitFor(() => {
-                expect(screen.getByText('Second step')).toBeInTheDocument();
-            });
-            await vi.advanceTimersByTimeAsync(4000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(4);
-        });
-        describe('and the action fails', () => {
-            it('polling should not restart', async () => {
-                let pollingAttempts = 0;
-                const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                    switch (input) {
-                        case '/polling':
-                            if (pollingAttempts <= 1) {
-                                pollingAttempts += 1;
-                                return respondWith({}, { status: 200 });
-                            }
-                            pollingAttempts = 0;
-                            return respondWith({ action: { url: '/action-fail' } });
-                        case '/action-fail':
-                            return respondWith('', { status: 500 });
-                    }
-                });
-                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: Object.assign(Object.assign({}, initialStep()), { layout: [
-                            {
-                                type: 'button',
-                                action: {
-                                    url: '/user-action',
-                                    title: 'Submit',
-                                },
-                            },
-                        ] }), onError: () => { }, onCompletion: () => { } }));
-                await waitFor(() => {
-                    expect(screen.getByText('polling title')).toBeInTheDocument();
-                });
-                expect(mockHttpClient).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(2000);
-                expect(mockHttpClient).toHaveBeenCalledTimes(2);
-                await act(async () => vi.advanceTimersByTimeAsync(2000));
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/action-fail', expect.any(Object));
-                await waitFor(() => {
-                    expect(screen.getByText('Something went wrong, please try again.')).toBeInTheDocument();
-                });
-                await act(async () => vi.advanceTimersByTimeAsync(2000));
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/action-fail', expect.any(Object));
-            });
-        });
-    });
-    describe('when the polling response contains an error status code', () => {
-        const makeInitialStep = () => (Object.assign(Object.assign({}, initialStep()), { polling: pollingConfig, layout: [{ type: 'form', schemaId: '#schema' }], schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['name'],
-                    required: ['name'],
-                    properties: {
-                        name: {
-                            type: 'string',
-                            title: 'Name',
-                            default: 'Too Short',
-                            minLength: 20,
-                        },
-                    },
-                },
-            ] }));
-        const makeMockHttpClient = () => vi.fn().mockImplementation(async (input) => {
-            await wait(100);
-            switch (input) {
-                case '/polling':
-                    return respondWith(null, { status: 401 });
-                case '/failure':
-                    return respondWith({}, { status: 404 });
-            }
-        });
-        it('calls Polling.onError and stops Polling', async () => {
-            const mockHttpClient = makeMockHttpClient();
-            const onEvent = vi.fn();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: makeInitialStep(), onEvent: onEvent, onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.anything());
-            });
-            expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Polling Failed', expect.objectContaining({ url: '/polling', statusCode: 401 }));
-            mockHttpClient.mockClear();
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(2500); // 2000 is the polling interval
-            });
-            expect(mockHttpClient).not.toHaveBeenCalledWith('/polling', expect.anything());
-        });
-        it('calls Polling.onError action with the schema model, even if invalid', async () => {
-            const mockHttpClient = makeMockHttpClient();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: makeInitialStep(), onEvent: () => { }, onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.anything());
-            });
-            const lastCall = mockHttpClient.mock.calls[mockHttpClient.mock.calls.length - 1];
-            const lastRequestBody = lastCall[1].body;
-            expect(JSON.parse(lastRequestBody)).toMatchObject({
-                what: 'there was an error',
-            });
-        });
-    });
-    describe('when (for some absurd reason) the step has polling AND refresh on change', () => {
-        const refreshingStep = Object.assign(Object.assign({}, initialStep()), { polling: Object.assign(Object.assign({}, pollingConfig), { maxAttempts: 5 }), layout: [
-                { type: 'form', schemaId: '#schema' },
-                {
-                    type: 'button',
-                    action: {
-                        url: '/user-action',
-                        title: 'Submit',
-                    },
-                },
-            ], schemas: [
-                {
-                    $id: '#schema',
-                    type: 'string',
-                    title: 'Refreshing Schema',
-                    refreshStepOnChange: true,
-                },
-            ], refreshUrl: '/refresh' });
-        it('polling continues on a 304', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({}, { status: 200 });
-                    case '/refresh':
-                        return respondWith(null, { status: 304 });
-                    case '/failure':
-                        return respondWith({}, { status: 200 });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: refreshingStep, onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            // poll once
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            // type in the schema + wait for debounce time
-            await user.type(screen.getByText('Refreshing Schema'), 'some random text to refresh');
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/refresh', expect.any(Object));
-            // wait until polling is complete
-            await act(async () => vi.advanceTimersByTimeAsync(20000));
-            // we should have
-            // poll x2
-            // refresh <---
-            // poll x3
-            // fail
-            //
-            // i.e. polling runs 5 times even though a refresh has happened in the middle
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.any(Object));
-            expect(mockHttpClient).toHaveBeenCalledTimes(7);
-        });
-        it('polling restarts on a new step that has polling (regardless of if the config is different)', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({}, { status: 200 });
-                    case '/refresh':
-                        return respondWith(refreshingStep, {
-                            status: 200,
-                        });
-                    case '/failure':
-                        return respondWith({}, { status: 200 });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: refreshingStep, onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            // poll twice
-            await vi.advanceTimersByTimeAsync(2000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            // type in the schema + wait for debounce time
-            await user.type(screen.getByText('Refreshing Schema'), 'some random text to refresh');
-            await vi.advanceTimersByTimeAsync(500);
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenCalledWith('/refresh', expect.any(Object));
-            });
-            // wait until polling is complete
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(20000);
-            });
-            // we should have
-            // poll x2
-            // refresh <---
-            // poll x5
-            // fail
-            //
-            // i.e. polling runs twice, but is restarted when the refresh completes
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.any(Object));
-            expect(mockHttpClient).toHaveBeenCalledTimes(9);
-        });
-        it('polling is stopped on a new step without polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({}, { status: 200 });
-                    case '/refresh':
-                        return respondWith(Object.assign(Object.assign({}, refreshingStep), { polling: undefined }), {
-                            status: 200,
-                        });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: refreshingStep, onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            // poll twice
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(2000);
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            // type in the schema + wait for debounce time
-            await user.type(screen.getByText('Refreshing Schema'), 'some random text to refresh');
-            await vi.advanceTimersByTimeAsync(500);
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/refresh', expect.any(Object));
-            });
-            // wait until polling would have triggered
-            await act(async () => {
-                await vi.advanceTimersByTimeAsync(2000);
-            });
-            // we should have
-            // poll
-            // poll
-            // refresh <---
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/refresh', expect.any(Object));
-            expect(mockHttpClient).toHaveBeenCalledTimes(3);
-        });
-    });
-    describe('when an action trigger (e.g. button or decision) and polling are on the same step', () => {
-        describe('and the polling request is made, but doesnt return before polling is stopped when the action succeeds', () => {
-            it('prevents the returned action from triggering', async () => {
-                const mockFetch = async (input, init) => {
-                    var _a;
-                    const signal = (_a = init === null || init === void 0 ? void 0 : init.signal) !== null && _a !== void 0 ? _a : null;
-                    switch (input) {
-                        case '/polling':
-                            return abortableDelay(1000, signal).then(async () => respondWith({ action: { url: '/polling-result' } }));
-                        case '/action':
-                            return respondWith(Object.assign(Object.assign({}, initialStep()), { title: 'second step', polling: undefined }));
-                        case '/polling-result':
-                            return respondWith(Object.assign(Object.assign({}, initialStep()), { title: 'polling result step', polling: undefined }));
-                        default:
-                            return Promise.reject(new Error('Invalid endpoint'));
-                    }
-                };
-                const mockHttpClient = vi.fn().mockImplementation(mockFetch);
-                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: Object.assign(Object.assign({}, initialStep()), { layout: [
-                            {
-                                type: 'button',
-                                action: {
-                                    url: '/action',
-                                },
-                            },
-                        ] }), onError: () => { }, onCompletion: () => { } }));
-                await waitFor(() => {
-                    expect(screen.getByText('polling title')).toBeInTheDocument();
-                });
-                expect(mockHttpClient).toHaveBeenCalledTimes(1);
-                await vi.advanceTimersByTimeAsync(200);
-                await user.click(screen.getByRole('button'));
-                await waitFor(() => {
-                    expect(mockHttpClient).toHaveBeenLastCalledWith('/action', expect.anything());
-                });
-                await waitFor(() => {
-                    expect(screen.getByText('second step')).toBeInTheDocument();
-                });
-                await vi.advanceTimersByTimeAsync(10000);
-                expect(mockHttpClient).toHaveBeenCalledTimes(2);
-                expect(screen.queryByText('polling result step')).not.toBeInTheDocument();
-            });
-        });
-    });
-    describe('when the response is an action', () => {
-        it('triggers the action provided and stops polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({ action: { url: '/action', method: 'GET' } }, { status: 200 });
-                    case '/action':
-                        return respondWith({
-                            id: 'second-step',
-                            title: 'Second step',
-                            layout: [],
-                            schemas: [],
-                        });
-                }
-            });
-            const onEvent = vi.fn();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onEvent: onEvent, onCompletion: () => { } }));
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Triggered', expect.anything());
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/action', expect.anything());
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('when the response has an action X-DF-Response-Type header, but the body is not an ActionResponseBody', () => {
-        it('calls Polling.onError and stops Polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith(null, { headers: { 'X-DF-Response-Type': 'action' } });
-                    case '/failure':
-                        return respondWith(null, { headers: { 'X-DF-Response-Type': 'step' } });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.anything());
-            });
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('when the response is a step', () => {
-        it('replaces the current step with the one provided and stops polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({
-                            id: 'second-step',
-                            title: 'Second step',
-                            layout: [],
-                            schemas: [],
-                        }, { headers: { 'X-DF-Response-Type': 'step' } });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(screen.getByText('Second step')).toBeInTheDocument();
-            });
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('when the response has a step X-DF-Response-Type header, but the body is not a Step', () => {
-        it('calls Polling.onError and stops Polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith(null, { headers: { 'X-DF-Response-Type': 'step' } });
-                    case '/failure':
-                        return respondWith({}, { status: 200 });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(mockHttpClient).toHaveBeenLastCalledWith('/failure', expect.anything());
-            });
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('when the response is an exit', () => {
-        it('triggers onCompletion and stops polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({
-                            key1: 'value1',
-                            key2: 'value2',
-                        }, { headers: { 'X-DF-Response-Type': 'exit' } });
-                }
-            });
-            const onCompletion = vi.fn();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: onCompletion }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenLastCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(onCompletion).toHaveBeenCalled();
-            });
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('when the response is a modal', () => {
-        it('renders the modal content and stops polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({ title: 'Modal Title', content: [{ type: 'paragraph', text: 'Modal content' }] }, { headers: { 'X-DF-Response-Type': 'modal' } });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(screen.getByText('Modal Title')).toBeInTheDocument();
-            });
-            expect(screen.getByText('Modal content')).toBeInTheDocument();
-            // original step remains visible behind the modal
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            // polling stops after the modal is shown
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('when the response is a no-op', () => {
-        it('stops polling without changing the UI', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith(null, { headers: { 'X-DF-Response-Type': 'no-op' } });
-                }
-            });
-            const onError = vi.fn();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: onError, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            // polling stops, but nothing changes in the UI
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(1);
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            // the flow doesn't fail
-            expect(onError).not.toHaveBeenCalled();
-        });
-    });
-    describe('when the response is a subflow', () => {
-        it('launches the subflow modally and stops polling', async () => {
-            const mockHttpClient = vi.fn().mockImplementation(async (input) => {
-                switch (input) {
-                    case '/polling':
-                        return respondWith({
-                            referrerId: 'polling-flow',
-                            launchConfig: {
-                                type: 'dynamic',
-                                request: { url: '/subflow-start', method: 'GET' },
-                                presentation: { type: 'modal' },
-                            },
-                        }, { headers: { 'X-DF-Response-Type': 'subflow' } });
-                    case '/subflow-start':
-                        return respondWith({
-                            id: 'subflow-step',
-                            title: 'Subflow Step',
-                            schemas: [],
-                            layout: [],
-                        });
-                }
-            });
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "polling-flow", httpClient: mockHttpClient, initialStep: initialStep(), onError: () => { }, onCompletion: () => { } }));
-            await waitFor(() => {
-                expect(screen.getByText('polling title')).toBeInTheDocument();
-            });
-            expect(mockHttpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            await waitFor(() => {
-                expect(screen.getByText('Subflow Step')).toBeInTheDocument();
-            });
-            // original step still visible behind the subflow modal
-            expect(screen.getByText('polling title')).toBeInTheDocument();
-            // polling stops after the subflow is launched
-            await vi.advanceTimersByTimeAsync(5000);
-            expect(mockHttpClient).toHaveBeenCalledTimes(2); // one poll + one subflow start
-        });
-    });
-});