@wise/dynamic-flow-client 5.8.1 → 5.9.0

package/build/tests/Polling.test.js

@@ -0,0 +1,617 @@
+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" (spec next)',
+        {
+            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',
+        {
+            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);
+        });
+    });
+});