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

package/build/tests/ValidationAsync.test.js

@@ -1,295 +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 } from '../test-utils';
-import DynamicFlowWise from '../test-utils/DynamicFlowWise';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-describe('Validation Async', () => {
-    const getRootSchema = (validationAsync) => ({
-        $id: '#schema',
-        type: 'object',
-        displayOrder: ['iban'],
-        properties: {
-            iban: {
-                $id: '#iban-string-schema',
-                type: 'string',
-                maxLength: 18,
-                title: 'IBAN',
-                validationAsync,
-            },
-        },
-    });
-    const getInitialStep = (validationAsync) => ({
-        id: 'validation-async-step-id',
-        title: 'Validation Async',
-        schemas: [getRootSchema(validationAsync)],
-        layout: [
-            { type: 'form', schemaId: '#schema' },
-            {
-                type: 'button',
-                title: 'Submit',
-                action: { url: '/submit', method: 'POST' },
-            },
-        ],
-    });
-    const getProps = (initialStep) => ({
-        flowId: 'flow-id',
-        initialStep,
-        httpClient: vi.fn(),
-        onCompletion: vi.fn(),
-        onError: vi.fn(),
-        onEvent: vi.fn(),
-        onLog: vi.fn(),
-    });
-    describe('when a value is entered and focus remains on the input', () => {
-        it('triggers validation async after a debounce', async () => {
-            const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-            const { httpClient } = props;
-            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-            const input = screen.getByLabelText('IBAN');
-            await user.type(input, 'AB123456789');
-            await waitFor(() => {
-                expect(httpClient).not.toHaveBeenCalled();
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/validate', expect.objectContaining({ body: `{"myParameter":"AB123456789"}` }));
-            });
-        });
-    });
-    describe('when a value is entered and then the field is blurred', () => {
-        it('flushes the pending validation async', async () => {
-            const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-            const { httpClient } = props;
-            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-            await waitFor(() => {
-                expect(screen.getByLabelText('IBAN')).toBeInTheDocument();
-            });
-            const input = screen.getByLabelText('IBAN');
-            await user.type(input, 'AB123456789');
-            await waitFor(() => {
-                expect(httpClient).not.toHaveBeenCalled();
-            });
-            await act(async () => vi.advanceTimersByTimeAsync(200));
-            await waitFor(() => {
-                expect(httpClient).not.toHaveBeenCalled();
-            });
-            await user.tab();
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/validate', expect.objectContaining({ body: `{"myParameter":"AB123456789"}` }));
-            });
-        });
-    });
-    describe('when the input is blurred and has null value', () => {
-        it('does NOT trigger validation async', async () => {
-            const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-            const { httpClient } = props;
-            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-            await waitFor(() => {
-                expect(screen.getByLabelText('IBAN')).toBeInTheDocument();
-            });
-            const input = screen.getByLabelText('IBAN');
-            await user.clear(input);
-            await user.tab();
-            await waitFor(() => {
-                expect(httpClient).not.toHaveBeenCalled();
-            });
-        });
-    });
-    describe('when the input is blurred and has an invalid value', () => {
-        it('does NOT trigger validation async', async () => {
-            const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-            const { httpClient } = props;
-            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-            const input = screen.getByLabelText('IBAN');
-            await user.type(input, '12345678901234567890'); // longer than 18 characters
-            await user.tab();
-            await waitFor(() => {
-                expect(httpClient).not.toHaveBeenCalled();
-            });
-        });
-    });
-    describe('when the input is blurred and has a valid value', () => {
-        it('triggers validation async with the specified method, url and parameter', async () => {
-            const httpClient = vi
-                .fn()
-                .mockResolvedValue(new Response(JSON.stringify({ message: 'IBAN is valid' })));
-            const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-            renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-            const input = screen.getByLabelText('IBAN');
-            await user.type(input, '123456789012345678');
-            await user.tab();
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/validate', expect.objectContaining({ body: `{"myParameter":"123456789012345678"}` }));
-            });
-        });
-        describe.skip('when the validation-async config does not provide a method property', () => {
-            // I've removed these tests as zod will barf if method is not provided
-        });
-        describe('when the validation-async config specifies the "GET" method', () => {
-            it('calls fetch without a "body" payload', async () => {
-                const props = getProps(getInitialStep({ method: 'GET', url: '/validate', param: 'myParameter' }));
-                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-                const input = screen.getByLabelText('IBAN');
-                await user.type(input, '123456789012345678');
-                await user.tab();
-                await waitFor(() => {
-                    expect(props.httpClient).toHaveBeenCalledWith('/validate', expect.objectContaining({ method: `GET` }));
-                });
-            });
-        });
-        describe('when the validation response is successful with a "message" property', () => {
-            it('displays the validation success message', async () => {
-                const httpClient = vi
-                    .fn()
-                    .mockResolvedValue(new Response(JSON.stringify({ message: 'IBAN is valid' })));
-                const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                const input = screen.getByLabelText('IBAN');
-                await user.type(input, '123456789012345678');
-                await user.tab();
-                await waitFor(() => {
-                    expect(screen.getByText('IBAN is valid')).toBeInTheDocument();
-                });
-            });
-        });
-        describe('when the validation response fails with 422', () => {
-            it('displays the validation error message', async () => {
-                const httpClient = vi.fn().mockResolvedValue(new Response(JSON.stringify({ message: 'Invalid IBAN (422)' }), {
-                    status: 422,
-                }));
-                const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                const input = screen.getByLabelText('IBAN');
-                await user.type(input, '123456789012345678');
-                await user.tab();
-                await waitFor(() => {
-                    expect(screen.getByText('Invalid IBAN (422)')).toBeInTheDocument();
-                });
-            });
-        });
-        describe('when the value is changed after a successful validation async request', () => {
-            it('does not display any messages', async () => {
-                const httpClient = vi
-                    .fn()
-                    .mockResolvedValue(new Response(JSON.stringify({ message: 'IBAN is valid' })));
-                const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                const input = screen.getByLabelText('IBAN');
-                await user.type(input, '12345678901234567');
-                await user.tab();
-                await waitFor(() => {
-                    expect(screen.getByText('IBAN is valid')).toBeInTheDocument();
-                });
-                await user.type(input, '8');
-                await user.tab();
-                await waitFor(() => {
-                    expect(screen.queryByText('IBAN is valid')).not.toBeInTheDocument();
-                });
-            });
-            describe('when the new value is the same as before', () => {
-                it('does not trigger another validation async call', async () => {
-                    const httpClient = vi
-                        .fn()
-                        .mockResolvedValue(new Response(JSON.stringify({ message: 'IBAN is valid' })));
-                    const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                    renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                    const input = screen.getByLabelText('IBAN');
-                    await user.type(input, '123456789012345678');
-                    await user.tab();
-                    await waitFor(() => {
-                        expect(httpClient).toHaveBeenCalledTimes(1);
-                    });
-                    await user.click(input);
-                    await user.tab();
-                    await waitFor(() => {
-                        expect(httpClient).toHaveBeenCalledTimes(1);
-                    });
-                });
-            });
-        });
-        describe('other server responses', () => {
-            const otherCases = [
-                {
-                    description: 'when the validation response is successful without a body',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(null))),
-                    // Original:
-                    // expectedTrackingEvent: 'failure',
-                    // Modification:
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Succeeded',
-                    doNotExpect: 'Error',
-                },
-                {
-                    description: 'when the validation response is successful with a string body',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(`Everything is fine`))),
-                    // Original:
-                    // expectedTrackingEvent: 'failure',
-                    // Modification:
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Succeeded',
-                    doNotExpect: 'Everything is fine',
-                },
-                {
-                    description: 'when the validation response fails with 500',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(`Internal server error`, { status: 500 }))),
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Failed',
-                    doNotExpect: 'Internal server error',
-                },
-                {
-                    description: 'when the validation response fails with 403',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(`{ "messsage": "Forbidden" }`, { status: 403 }))),
-                    // Original:
-                    // expectedTrackingEvent: 'success',
-                    // Modification:
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Failed',
-                    doNotExpect: 'Forbidden',
-                },
-                {
-                    description: 'when the validation response JSON does not parse as an object',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(`1234567890`, { status: 422 }))),
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Failed',
-                    doNotExpect: '1234567890',
-                },
-                {
-                    description: 'when the validation response does not even parse as JSON',
-                    httpClient: vi.fn(async () => Promise.resolve(new Response(`non-json-string`, { status: 422 }))),
-                    expectedTrackingEvent: 'Dynamic Flow - ValidationAsync Failed',
-                    doNotExpect: 'non-json-string',
-                },
-            ];
-            describe.each(otherCases)('$description', ({ httpClient, expectedTrackingEvent, doNotExpect }) => {
-                it('does NOT display a validation message', async () => {
-                    const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                    renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                    const input = screen.getByLabelText('IBAN');
-                    await user.type(input, '123456789012345678');
-                    await user.tab();
-                    await waitFor(() => {
-                        expect(screen.queryByText(doNotExpect)).not.toBeInTheDocument();
-                    });
-                });
-                it(`triggers analytics event with {status: "${expectedTrackingEvent}"}`, async () => {
-                    const props = getProps(getInitialStep({ method: 'POST', url: '/validate', param: 'myParameter' }));
-                    renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props, { httpClient: httpClient })));
-                    const input = screen.getByLabelText('IBAN');
-                    await user.type(input, '123456789012345678');
-                    await user.tab();
-                    await waitFor(() => {
-                        expect(props.onEvent).toHaveBeenLastCalledWith(expectedTrackingEvent, expect.objectContaining({
-                            flowId: 'flow-id',
-                            schema: '#iban-string-schema',
-                            stepId: 'validation-async-step-id',
-                        }));
-                    });
-                    // Original
-                    // await waitFor(() => {
-                    //   expect(props.onEvent).toHaveBeenLastCalledWith(
-                    //     'Dynamic Flow - ValidationAsync',
-                    //     expect.objectContaining({ status: expectedTrackingEvent }),
-                    //   );
-                    // });
-                });
-            });
-        });
-    });
-});

package/build/tests/legacy/Actions.test.js

@@ -1,158 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen, waitFor } from '@testing-library/react';
-import { userEvent } from '@testing-library/user-event';
-import { vi } from 'vitest';
-import { renderWithProviders } from '../../test-utils';
-import DynamicFlowWise from '../../test-utils/DynamicFlowWise';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-describe('Actions', () => {
-    // TODO: Add more tests here / copy over to revamp when ready.
-    describe('given an action with `exit: true`', () => {
-        describe('when the response is OK', () => {
-            describe('and the body can be parsed to a JSON object', () => {
-                it('should exit the flow with the response body as a result when the action has no result', async () => {
-                    const onError = vi.fn();
-                    const onCompletion = vi.fn();
-                    const httpClient = vi.fn(async () => Promise.resolve(new Response('body', { status: 200 })));
-                    const step = {
-                        id: 'step-id',
-                        title: 'Step Title',
-                        layout: [{ type: 'button', action: { url: '/submit', exit: true } }],
-                        schemas: [],
-                    };
-                    renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                    await user.click(await screen.findByRole('button'));
-                    await waitFor(() => {
-                        expect(onCompletion).toHaveBeenCalledTimes(1);
-                    });
-                    expect(onError).not.toHaveBeenCalled();
-                });
-                it('should exit the flow with a merged object of the response body and result when the action has a result', async () => {
-                    const onError = vi.fn();
-                    const onCompletion = vi.fn();
-                    const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ key: 'response body value', extra_key: 'value' }), {
-                        status: 200,
-                    })));
-                    const step = {
-                        id: 'step-id',
-                        title: 'Step Title',
-                        layout: [
-                            {
-                                type: 'button',
-                                action: { url: '/submit', exit: true, result: { key: 'action result value' } },
-                            },
-                        ],
-                        schemas: [],
-                    };
-                    renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                    await user.click(await screen.findByRole('button'));
-                    await waitFor(() => {
-                        expect(onCompletion).toHaveBeenCalledTimes(1);
-                    });
-                    expect(onCompletion).toHaveBeenCalledWith(expect.objectContaining({ key: 'action result value', extra_key: 'value' }));
-                    expect(onError).not.toHaveBeenCalled();
-                });
-            });
-            describe('and the body cannot be parsed to a JSON object', () => {
-                it('should exit the flow with the contents of the action result', async () => {
-                    const onError = vi.fn();
-                    const onCompletion = vi.fn();
-                    const httpClient = vi.fn(async () => Promise.resolve(new Response(']} not valid json {[', { status: 200 })));
-                    const step = {
-                        id: 'step-id',
-                        title: 'Step Title',
-                        layout: [
-                            { type: 'button', action: { url: '/submit', exit: true, result: { key: 'value' } } },
-                        ],
-                        schemas: [],
-                    };
-                    renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                    await user.click(await screen.findByRole('button'));
-                    await waitFor(() => {
-                        expect(onCompletion).toHaveBeenCalledTimes(1);
-                    });
-                    expect(onCompletion).toHaveBeenCalledWith(expect.objectContaining({ key: 'value' }));
-                    expect(onError).not.toHaveBeenCalled();
-                });
-            });
-        });
-        describe('when the response is NOT OK', () => {
-            it('should not exit the flow, and handle the error response as normal', async () => {
-                const onError = vi.fn();
-                const onCompletion = vi.fn();
-                const httpClient = vi.fn(async () => Promise.resolve(new Response('body', { status: 400 })));
-                const step = {
-                    id: 'step-id',
-                    title: 'Step Title',
-                    layout: [{ type: 'button', action: { url: '/submit', exit: true } }],
-                    schemas: [],
-                };
-                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                await user.click(await screen.findByRole('button'));
-                await waitFor(() => {
-                    expect(screen.getByText(/something went wrong, please try again/i)).toBeInTheDocument();
-                });
-                expect(onCompletion).not.toHaveBeenCalled();
-            });
-        });
-    });
-    describe('given an non-exit action', () => {
-        describe('when the response contains "X-DF-ResponseType: exit" header', () => {
-            it('should exit the flow with a merged object of the response body and result when the action has a result', async () => {
-                const onError = vi.fn();
-                const onCompletion = vi.fn();
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ key: 'response body value', extra_key: 'value' }), {
-                    status: 200,
-                    headers: { 'X-DF-Response-Type': 'exit' },
-                })));
-                const step = {
-                    id: 'step-id',
-                    title: 'Step Title',
-                    layout: [
-                        {
-                            type: 'button',
-                            action: { url: '/submit', result: { key: 'action result value' } },
-                        },
-                    ],
-                    schemas: [],
-                };
-                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                await user.click(await screen.findByRole('button'));
-                await waitFor(() => {
-                    expect(onCompletion).toHaveBeenCalledTimes(1);
-                });
-                expect(onCompletion).toHaveBeenCalledWith(expect.objectContaining({ key: 'action result value', extra_key: 'value' }));
-                expect(onError).not.toHaveBeenCalled();
-                expect(httpClient).toHaveBeenCalledTimes(1);
-            });
-        });
-        describe('when the response contains an exiting action', () => {
-            it('should exit the flow with the result of the exiting action and not make an additional network request', async () => {
-                const onError = vi.fn();
-                const onCompletion = vi.fn();
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ action: { exit: true, result: { abc: '123' } } }), {
-                    status: 200,
-                })));
-                const step = {
-                    id: 'step-id',
-                    title: 'Step Title',
-                    layout: [
-                        {
-                            type: 'button',
-                            action: { url: '/submit', result: { key: 'action result value' } },
-                        },
-                    ],
-                    schemas: [],
-                };
-                renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", initialStep: step, httpClient: httpClient, onCompletion: onCompletion, onError: onError }));
-                await user.click(await screen.findByRole('button'));
-                await waitFor(() => {
-                    expect(onCompletion).toHaveBeenCalledTimes(1);
-                });
-                expect(onCompletion).toHaveBeenCalledWith(expect.objectContaining({ abc: '123' }));
-                expect(onError).not.toHaveBeenCalled();
-                expect(httpClient).toHaveBeenCalledTimes(1);
-            });
-        });
-    });
-});

package/build/tests/legacy/BackButton.test.js

@@ -1,114 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen } from '@testing-library/react';
-import { userEvent } from '@testing-library/user-event';
-import DynamicFlowWise from '../../test-utils/DynamicFlowWise';
-import { renderWithProviders, respondWith } from '../../test-utils';
-import { vi } from 'vitest';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-const getStepWithBack = (navigation) => ({
-    id: 'back-button-step',
-    title: 'Basic step',
-    navigation,
-    schemas: [
-        {
-            $id: 'schema',
-            type: 'object',
-            displayOrder: ['name'],
-            required: ['name'],
-            properties: {
-                name: {
-                    title: 'Full name',
-                    type: 'string',
-                },
-            },
-        },
-    ],
-    layout: [
-        {
-            type: 'form',
-            schemaId: 'schema',
-        },
-    ],
-});
-describe('DynamicFlow / Back Button', () => {
-    const onCompletion = vi.fn();
-    const onError = vi.fn();
-    const httpClient = vi.fn();
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('when the step contains a back navigation property', () => {
-        it('renders a back button', () => {
-            const backLabel = 'Back to payment methods';
-            const backAction = {
-                method: 'GET',
-                url: '/back',
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", httpClient: httpClient, initialStep: getStepWithBack({ back: { title: backLabel, action: backAction } }), onCompletion: onCompletion, onError: onError }));
-            expect(screen.getByRole('button', { name: backLabel })).toBeInTheDocument();
-        });
-    });
-    describe('when the step contains the deprecated backButton navigation property', () => {
-        it('renders a back button', () => {
-            const backLabel = 'Back to payment methods';
-            const backAction = {
-                method: 'GET',
-                url: '/back',
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", httpClient: httpClient, initialStep: getStepWithBack({ backButton: { title: backLabel, action: backAction } }), onCompletion: onCompletion, onError: onError }));
-            expect(screen.getByRole('button', { name: backLabel })).toBeInTheDocument();
-        });
-    });
-    it('performs (GET) action on back', async () => {
-        const backLabel = 'Back to payment methods';
-        const backAction = {
-            method: 'GET',
-            url: '/back',
-        };
-        const mockHttpClient = vi.fn();
-        mockHttpClient.mockImplementationOnce(async () => respondWith({
-            // once again bad steps in old tests!!
-            id: 'next-step',
-            title: 'Next step',
-            schemas: [],
-            layout: [],
-        }));
-        renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", httpClient: mockHttpClient, initialStep: getStepWithBack({ back: { title: backLabel, action: backAction } }), onCompletion: onCompletion, onError: onError }));
-        const backButton = screen.getByRole('button', { name: backLabel });
-        await user.click(backButton);
-        expect(mockHttpClient).toHaveBeenCalledWith('/back', expect.objectContaining({ method: 'GET' }));
-        await expect(screen.findByRole('heading', { name: 'Next step' })).resolves.toBeInTheDocument();
-    });
-    describe('when the backButton action specified the POST method', () => {
-        const backLabel = 'Back to payment methods';
-        const backAction = {
-            method: 'POST',
-            url: '/back',
-        };
-        const mockHttpClient = vi.fn();
-        beforeEach(() => {
-            mockHttpClient.mockImplementationOnce(async () => respondWith({
-                // added
-                id: 'next-step',
-                title: 'Next step',
-                schemas: [],
-                layout: [],
-            }));
-        });
-        const initialStep = getStepWithBack({ back: { title: backLabel, action: backAction } });
-        it('performs (POST) action on back', async () => {
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", httpClient: mockHttpClient, initialStep: initialStep, onCompletion: onCompletion, onError: onError }));
-            const backButton = screen.getByRole('button', { name: backLabel });
-            await user.click(backButton);
-            expect(mockHttpClient).toHaveBeenCalledWith('/back', expect.objectContaining({ method: 'POST' }));
-            await expect(screen.findByRole('heading', { name: 'Next step' })).resolves.toBeInTheDocument();
-        });
-        it('does not display client-side validation errors', async () => {
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "the-flow-id", httpClient: mockHttpClient, initialStep: initialStep, onCompletion: onCompletion, onError: onError }));
-            const backButton = screen.getByRole('button', { name: backLabel });
-            await user.click(backButton);
-            expect(screen.queryByText('Please fill out this field.')).not.toBeInTheDocument();
-            await expect(screen.findByRole('heading', { name: 'Next step' })).resolves.toBeInTheDocument();
-        });
-    });
-});