@wise/dynamic-flow-client 5.11.0 → 5.12.0

package/build/tests/Submission.ResponseHandling.test.js

@@ -1,557 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-/* eslint-disable testing-library/render-result-naming-convention */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-import { screen, waitFor } from '@testing-library/react';
-import { userEvent } from '@testing-library/user-event';
-import { vi } from 'vitest';
-import { getMockHttpClient, renderWithProviders, respondWith } from '../test-utils';
-import DynamicFlowWise from '../test-utils/DynamicFlowWise';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-const getProps = () => ({
-    flowId: 'flow-id',
-    onCompletion: vi.fn(),
-    onError: vi.fn(),
-    onEvent: vi.fn(),
-    onLog: vi.fn(),
-});
-const initialSchema = {
-    $id: '#form',
-    type: 'object',
-    displayOrder: ['name', 'age'],
-    required: ['name'],
-    properties: {
-        name: {
-            title: 'Name',
-            type: 'string',
-        },
-        age: {
-            title: 'Age',
-            type: 'number',
-        },
-    },
-};
-const initialStep = {
-    id: 'step-id',
-    title: 'Submission test',
-    layout: [
-        {
-            type: 'form',
-            schemaId: '#form',
-        },
-        {
-            type: 'button',
-            title: 'Submit',
-            action: { id: 'action-id', url: '/submit', method: 'POST' },
-        },
-    ],
-    schemas: [initialSchema],
-};
-const newStep = {
-    id: 'new-step',
-    title: 'New step title',
-    layout: [],
-    schemas: [],
-};
-const renderInitialStepAndSubmit = async (httpClient) => {
-    const props = Object.assign(Object.assign({}, getProps()), { initialStep, httpClient });
-    renderWithProviders(_jsx(DynamicFlowWise, Object.assign({}, props)));
-    await waitFor(() => {
-        expect(screen.getByText(initialStep.title)).toBeInTheDocument();
-    });
-    await user.type(screen.getByLabelText('Name'), 'Marty');
-    await user.click(screen.getByText('Submit'));
-    return props;
-};
-describe('Submission response handling', () => {
-    describe('Status 2xx (response.ok)', () => {
-        describe('Without response type headers', () => {
-            describe('when the response is a valid step', () => {
-                it('should render the new step, and trigger the "Action Succeeded" and "Step Shown" events', async () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith(newStep));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(screen.getByText('New step title')).toBeInTheDocument();
-                    });
-                    expect(screen.queryByText(props.initialStep.title)).not.toBeInTheDocument();
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                    }));
-                    expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Step Shown', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'new-step',
-                        stepCount: 1,
-                        isFirstStep: false,
-                    }));
-                });
-            });
-            describe('when the response is an invalid step', () => {
-                it('should trigger onError and the "Action Failed" and "Failed" events', async () => {
-                    var _a;
-                    const httpClient = vi.fn().mockResolvedValue(respondWith("I'm not a step"));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(props.onError).toHaveBeenCalledWith(expect.any(Error), undefined);
-                    });
-                    expect((_a = props.onError.mock.lastCall) === null || _a === void 0 ? void 0 : _a[0].message).toMatch(/Incorrect response body/);
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                        errorMessage: expect.stringContaining('Incorrect response body'),
-                    }));
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                    }));
-                });
-            });
-        });
-        describe('With X-Df-Response-Type header: "step"', () => {
-            const headers = { 'X-Df-Response-Type': 'step' };
-            describe('when the response is a valid step', () => {
-                it('should render the new step and trigger the "Action Succeeded" and "Step Shown" events', async () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith(newStep, { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(screen.getByText('New step title')).toBeInTheDocument();
-                    });
-                    expect(screen.queryByText(props.initialStep.title)).not.toBeInTheDocument();
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                    }));
-                    expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Step Shown', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'new-step',
-                        stepCount: 1,
-                        isFirstStep: false,
-                    }));
-                });
-            });
-            describe('when the response is an invalid step', () => {
-                it('should trigger onError and the "Action Failed" and "Failed" events', async () => {
-                    var _a;
-                    const httpClient = vi.fn().mockResolvedValue(respondWith("I'm not a step", { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(props.onError).toHaveBeenCalledWith(expect.any(Error), undefined);
-                    });
-                    expect((_a = props.onError.mock.lastCall) === null || _a === void 0 ? void 0 : _a[0].message).toMatch(/Incorrect response body/);
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                        errorMessage: expect.stringContaining('Incorrect response body'),
-                    }));
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                    }));
-                });
-            });
-        });
-        describe('With X-Df-Response-Type header: "action"', () => {
-            const headers = { 'X-Df-Response-Type': 'action' };
-            describe('when the response body is a valid action', () => {
-                it('should trigger a new action, including its data, and a "Action Succeeded" event', async () => {
-                    const httpClient = vi
-                        .fn()
-                        .mockResolvedValue(respondWith({ action: { url: '/action-url', data: { foo: 'bar' } } }, { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(httpClient).toHaveBeenCalledWith('/action-url', expect.objectContaining({ body: '{"foo":"bar"}' }));
-                    });
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                    }));
-                });
-            });
-            describe('when the response body is NOT a valid action', () => {
-                it('should call onError, and trigger "Action Failed" and "Failed" events', async () => {
-                    var _a;
-                    const httpClient = vi
-                        .fn()
-                        .mockResolvedValue(respondWith("I'm not an action", { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(props.onError).toHaveBeenCalledWith(expect.any(Error), undefined);
-                    });
-                    expect((_a = props.onError.mock.lastCall) === null || _a === void 0 ? void 0 : _a[0].message).toMatch(/Incorrect response body/);
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                        errorMessage: expect.stringContaining('Incorrect response body'),
-                    }));
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                    }));
-                });
-            });
-        });
-        describe('With X-Df-Response-Type header: "exit"', () => {
-            const headers = { 'X-Df-Response-Type': 'exit' };
-            it('should trigger onCompletion, and the "Action Succeeded" and "Succeeded" events', async () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({ foo: 'bar' }, { headers }));
-                const props = await renderInitialStepAndSubmit(httpClient);
-                await waitFor(() => {
-                    expect(props.onCompletion).toHaveBeenCalledWith({ foo: 'bar' });
-                });
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    stepCount: 0,
-                    actionId: 'action-id',
-                }));
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Succeeded', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    stepCount: 0,
-                }));
-            });
-        });
-        describe('With X-Df-Response-Type header: "modal"', () => {
-            const headers = { 'X-Df-Response-Type': 'modal' };
-            describe('when the response body is a valid modal behavior', () => {
-                it('should render the modal, and trigger an "Action Succeeded" event', async () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith({
-                        title: 'Modal Title',
-                        content: [{ type: 'paragraph', text: 'This is a modal' }],
-                    }, { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(screen.getByText('Modal Title')).toBeInTheDocument();
-                    });
-                    expect(screen.getByText('This is a modal')).toBeInTheDocument();
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                    }));
-                });
-            });
-            describe('when the response body is NOT a valid modal behavior', () => {
-                it('should call onError, and trigger "Action Failed" and "Failed" events', async () => {
-                    var _a;
-                    const httpClient = vi
-                        .fn()
-                        .mockResolvedValue(respondWith({ banana: 'not a modal' }, { headers }));
-                    const props = await renderInitialStepAndSubmit(httpClient);
-                    await waitFor(() => {
-                        expect(props.onError).toHaveBeenCalledWith(expect.any(Error), undefined);
-                    });
-                    expect((_a = props.onError.mock.lastCall) === null || _a === void 0 ? void 0 : _a[0].message).toMatch(/Incorrect response body/);
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                        actionId: 'action-id',
-                        errorMessage: expect.stringContaining('Incorrect response body'),
-                    }));
-                    expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        stepCount: 0,
-                    }));
-                });
-            });
-        });
-        describe('With X-Df-Exit header', () => {
-            const headers = { 'X-Df-Exit': 'true' };
-            it('should trigger onCompletion, and the "Action Succeeded" and "Succeeded" events', async () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({ foo: 'bar' }, { headers }));
-                const props = await renderInitialStepAndSubmit(httpClient);
-                await waitFor(() => {
-                    expect(props.onCompletion).toHaveBeenCalledWith({ foo: 'bar' });
-                });
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Succeeded', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    stepCount: 0,
-                    actionId: 'action-id',
-                }));
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Succeeded', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    stepCount: 0,
-                }));
-            });
-        });
-    });
-    describe('Status 4xx or 5xx', () => {
-        describe('When the response body can be parsed as an ErrorResponseBody', () => {
-            const getHttpClient = () => vi.fn().mockResolvedValue(respondWith({
-                error: 'Global Error',
-                validation: { name: 'Your name is wrong' },
-                analytics: { shopping: 'list' },
-            }, { status: 422 }));
-            it('should not trigger onError', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(props.onError).not.toHaveBeenCalled();
-                });
-            });
-            it('should display the errors', async () => {
-                await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(screen.getByText('Global Error')).toBeInTheDocument();
-                });
-                expect(screen.getByText('Your name is wrong')).toBeInTheDocument();
-            });
-            it('should retain the user input', async () => {
-                await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(screen.getByText('Your name is wrong')).toBeInTheDocument();
-                });
-                expect(screen.getByDisplayValue('Marty')).toBeInTheDocument();
-            });
-            it('should trigger an "Action failed" event with the expected properties and analytics', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    actionId: 'action-id',
-                    shopping: 'list',
-                }));
-            });
-        });
-        describe('When the ErrorResponseBody contains a "refreshUrl" property', () => {
-            const getHttpClient = () => vi.fn().mockImplementation(async (input) => {
-                if (input === '/submit') {
-                    return respondWith({
-                        error: 'This is a global error',
-                        validation: { name: 'Your name is wrong (server-side)' },
-                        refreshUrl: '/refresh',
-                        analytics: { shopping: 'list' },
-                    }, { status: 422 });
-                }
-                if (input === '/refresh') {
-                    return respondWith(Object.assign(Object.assign({}, initialStep), { title: 'Refreshed step title' }));
-                }
-                return respondWith('Not found', { status: 404 });
-            });
-            it('should not trigger onError', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(props.onError).not.toHaveBeenCalled();
-                });
-            });
-            it('should trigger a refresh', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(screen.getByText('Refreshed step title')).toBeInTheDocument();
-                });
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Refresh Succeeded', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    stepCount: 0,
-                }));
-                expect(props.onEvent).toHaveBeenCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    actionId: 'action-id',
-                    shopping: 'list',
-                    statusCode: 422,
-                }));
-            });
-            it('should display the global and validation errors from the response', async () => {
-                await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(screen.getByText('This is a global error')).toBeInTheDocument();
-                });
-                expect(screen.getByText('Your name is wrong (server-side)')).toBeInTheDocument();
-            });
-            it('should not display client-side validation until a subsequent submission', async () => {
-                const httpClient = getMockHttpClient({
-                    '/submit': async () => respondWith({
-                        error: 'This is a global error',
-                        validation: {
-                            name: 'Your name is wrong (server-side)',
-                            city: 'You now need to enter a city as well (server-side)',
-                        },
-                        refreshUrl: '/refresh',
-                        analytics: { shopping: 'list' },
-                    }, { status: 422 }),
-                    '/refresh': async () => respondWith(Object.assign(Object.assign({}, initialStep), { model: { name: 'Marty' }, title: 'Refreshed step title', schemas: [
-                            {
-                                $id: '#form',
-                                type: 'object',
-                                displayOrder: ['name', 'age', 'city'],
-                                required: ['name', 'city'],
-                                properties: {
-                                    name: {
-                                        title: 'Name',
-                                        type: 'string',
-                                        validationMessages: { required: 'Please enter a name.' },
-                                    },
-                                    age: {
-                                        title: 'Age',
-                                        type: 'number',
-                                    },
-                                    city: {
-                                        title: 'City',
-                                        type: 'string',
-                                        validationMessages: { required: 'Please enter a city.' },
-                                    },
-                                },
-                            },
-                        ] })),
-                });
-                await renderInitialStepAndSubmit(httpClient);
-                await waitFor(() => {
-                    expect(screen.getByText('City')).toBeInTheDocument();
-                });
-                expect(screen.getByDisplayValue('Marty')).toBeInTheDocument();
-                // server-side validation errors
-                expect(screen.getByText('Your name is wrong (server-side)')).toBeInTheDocument();
-                expect(screen.getByText('You now need to enter a city as well (server-side)')).toBeInTheDocument();
-                expect(screen.queryByText('Please enter a name.')).not.toBeInTheDocument();
-                expect(screen.queryByText('Please enter a city.')).not.toBeInTheDocument();
-                await user.click(screen.getByText('Submit'));
-                // we expect a client-side validation error, because the city is missing
-                expect(screen.getByText('Please enter a city.')).toBeInTheDocument();
-                await user.type(screen.getByLabelText('City'), 'Hill Valley');
-                await user.click(screen.getByText('Submit'));
-                // we expect the same server-side validation errors
-                expect(screen.getByText('Your name is wrong (server-side)')).toBeInTheDocument();
-                expect(screen.getByText('You now need to enter a city as well (server-side)')).toBeInTheDocument();
-                // we don't expect the client-side validation error anymore
-                expect(screen.queryByText('Please enter a name.')).not.toBeInTheDocument();
-                expect(screen.queryByText('Please enter a city.')).not.toBeInTheDocument();
-            });
-        });
-        describe('When the response body can NOT be parsed as an ErrorResponseBody', () => {
-            const getHttpClient = () => vi.fn().mockResolvedValue(respondWith('', { status: 422 }));
-            it('should display a generic global error', async () => {
-                await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(screen.getByText('Something went wrong, please try again.')).toBeInTheDocument();
-                });
-            });
-            it('should not trigger onError', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(props.onError).not.toHaveBeenCalled();
-                });
-            });
-            it('should trigger an "Action Failed"', async () => {
-                const props = await renderInitialStepAndSubmit(getHttpClient());
-                await waitFor(() => {
-                    expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                        flowId: 'flow-id',
-                        stepId: 'step-id',
-                        actionId: 'action-id',
-                        statusCode: 422,
-                    }));
-                });
-                expect(props.onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Failed', expect.anything());
-            });
-            it('should allow the user to try (submit) again', async () => {
-                const httpClient = getHttpClient();
-                const props = await renderInitialStepAndSubmit(httpClient);
-                await waitFor(() => {
-                    expect(props.onError).not.toHaveBeenCalled();
-                });
-                await user.type(screen.getByLabelText('Name'), ' McFly');
-                await user.click(screen.getByText('Submit'));
-                await waitFor(() => {
-                    expect(httpClient).toHaveBeenLastCalledWith('/submit', expect.objectContaining({ body: '{"name":"Marty McFly"}' }));
-                });
-            });
-        });
-    });
-    describe('When the request Promise rejects', () => {
-        const getHttpClient = () => vi.fn().mockRejectedValue(new Error('Network error: Failed to fetch'));
-        it('should display a generic global error', async () => {
-            await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(screen.getByText('Something went wrong, please try again.')).toBeInTheDocument();
-            });
-        });
-        it('should not trigger onError', async () => {
-            const props = await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(props.onError).not.toHaveBeenCalled();
-            });
-        });
-        it('should trigger an "Action Failed"', async () => {
-            const props = await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    actionId: 'action-id',
-                }));
-            });
-            expect(props.onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Failed', expect.anything());
-        });
-        it('should allow the user to try (submit) again', async () => {
-            const httpClient = getHttpClient();
-            const props = await renderInitialStepAndSubmit(httpClient);
-            await waitFor(() => {
-                expect(props.onError).not.toHaveBeenCalled();
-            });
-            await user.type(screen.getByLabelText('Name'), ' McFly');
-            await user.click(screen.getByText('Submit'));
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenLastCalledWith('/submit', expect.objectContaining({ body: '{"name":"Marty McFly"}' }));
-            });
-        });
-    });
-    describe('When the call to httpClient throws', () => {
-        const getHttpClient = () => vi.fn(() => {
-            throw new Error('Network error: Failed to fetch');
-        });
-        it('should display a generic global error', async () => {
-            await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(screen.getByText('Something went wrong, please try again.')).toBeInTheDocument();
-            });
-        });
-        it('should not trigger onError', async () => {
-            const props = await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(props.onError).not.toHaveBeenCalled();
-            });
-        });
-        it('should trigger an "Action Failed"', async () => {
-            const props = await renderInitialStepAndSubmit(getHttpClient());
-            await waitFor(() => {
-                expect(props.onEvent).toHaveBeenLastCalledWith('Dynamic Flow - Action Failed', expect.objectContaining({
-                    flowId: 'flow-id',
-                    stepId: 'step-id',
-                    actionId: 'action-id',
-                }));
-            });
-            expect(props.onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Failed', expect.anything());
-        });
-        it('should allow the user to try (submit) again', async () => {
-            const httpClient = getHttpClient();
-            const props = await renderInitialStepAndSubmit(httpClient);
-            await waitFor(() => {
-                expect(props.onError).not.toHaveBeenCalled();
-            });
-            await user.type(screen.getByLabelText('Name'), ' McFly');
-            await user.click(screen.getByText('Submit'));
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenLastCalledWith('/submit', expect.objectContaining({ body: '{"name":"Marty McFly"}' }));
-            });
-        });
-    });
-});