@wise/dynamic-flow-client 5.8.1 → 5.9.0

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

@@ -0,0 +1,557 @@
+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"}' }));
+            });
+        });
+    });
+});