@wise/dynamic-flow-client-internal 5.28.2 → 5.28.4

package/build/tests/events.test.js

@@ -1,124 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen, waitFor } from '@testing-library/react';
-import { vi } from 'vitest';
-import { DynamicFlow } from '../dynamicFlow/DynamicFlow';
-import { renderWithProviders } from '../test-utils/rtl-utils';
-describe('events', () => {
-    describe('when an event is triggered from core', () => {
-        describe('is a theme required event', () => {
-            it('triggers an onEvent callback, but not an onAnalytics callback', async () => {
-                const onEvent = vi.fn();
-                const onAnalytics = vi.fn();
-                renderWithProviders(_jsx(DynamicFlow, { flowId: "test-flow", customFetch: fetch, initialStep: {
-                        id: 'celebration',
-                        title: '',
-                        control: 'splash-celebration',
-                        layout: [],
-                        schemas: [],
-                    }, onCompletion: () => { }, onError: () => { }, onEvent: onEvent, onAnalytics: onAnalytics }));
-                await waitFor(() => {
-                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Theme Required', expect.objectContaining({ theme: 'forest-green' }));
-                });
-                expect(onAnalytics).not.toHaveBeenCalledWith('Dynamic Flow - Theme Required', expect.anything());
-            });
-        });
-        describe('it is a documented flow event', () => {
-            it('triggers onAnalytics and onEvent', async () => {
-                const onEvent = vi.fn();
-                const onAnalytics = vi.fn();
-                renderWithProviders(_jsx(DynamicFlow, { flowId: "test-flow", customFetch: fetch, initialStep: {
-                        id: 'regular-step',
-                        title: '',
-                        layout: [],
-                        schemas: [],
-                    }, onCompletion: () => { }, onError: () => { }, onEvent: onEvent, onAnalytics: onAnalytics }));
-                await waitFor(() => {
-                    expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Step Shown', expect.anything());
-                });
-                expect(onAnalytics).toHaveBeenCalledWith('Dynamic Flow - Step Shown', expect.anything());
-            });
-        });
-    });
-    describe('onAnalytics', () => {
-        let originalMixpanel;
-        beforeEach(() => {
-            originalMixpanel = window.mixpanel;
-        });
-        afterEach(() => {
-            window.mixpanel = originalMixpanel;
-            vi.clearAllMocks();
-        });
-        const initialStep = {
-            id: 'step',
-            title: 'Step',
-            layout: [],
-            schemas: [],
-        };
-        const getProps = () => ({
-            flowId: 'test-flow',
-            customFetch: vi.fn(),
-            initialStep,
-            onCompletion: () => { },
-            onError: () => { },
-        });
-        describe('When onAnalytics is provided', () => {
-            it('calls onAnalytics with the correct event name and properties', async () => {
-                const props = getProps();
-                const onAnalyticsMock = vi.fn();
-                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, props, { onAnalytics: onAnalyticsMock })));
-                await waitFor(() => {
-                    expect(screen.getByText('Step')).toBeInTheDocument();
-                });
-                expect(onAnalyticsMock).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
-                    flowId: 'test-flow',
-                    integrationId: 'test-flow',
-                    stepCount: 0,
-                    stepId: 'step',
-                }));
-            });
-        });
-        describe('When onAnalytics is not provided but onEvent is provided', () => {
-            it('calls onEvent with the correct event name and properties, and the window.mixpanel.track with an $insert_id', async () => {
-                const props = getProps();
-                const onEventMock = vi.fn();
-                const mixpanelTrackMock = vi.fn();
-                window.mixpanel = { track: mixpanelTrackMock };
-                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, props, { onEvent: onEventMock })));
-                await waitFor(() => {
-                    expect(screen.getByText('Step')).toBeInTheDocument();
-                });
-                expect(onEventMock).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
-                    flowId: 'test-flow',
-                    integrationId: 'test-flow',
-                    stepCount: 0,
-                    stepId: 'step',
-                }));
-                expect(mixpanelTrackMock).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    $insert_id: expect.any(String),
-                    dfFallbackAnalytics: true,
-                }));
-            });
-        });
-        describe('When onAnalytics and onEvent are not provided', () => {
-            it('calls window.mixpanel.track with the correct event name and properties, including an extra dfFallbackAnalytics property', async () => {
-                const props = getProps();
-                const mixpanelTrackMock = vi.fn();
-                window.mixpanel = { track: mixpanelTrackMock };
-                renderWithProviders(_jsx(DynamicFlow, Object.assign({}, props)));
-                await waitFor(() => {
-                    expect(screen.getByText('Step')).toBeInTheDocument();
-                });
-                expect(mixpanelTrackMock).toHaveBeenCalledWith('Dynamic Flow - Initiated', expect.objectContaining({
-                    dfFallbackAnalytics: true,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    $insert_id: expect.any(String),
-                    flowId: 'test-flow',
-                    integrationId: 'test-flow',
-                    stepCount: 0,
-                    stepId: 'step',
-                }));
-            });
-        });
-    });
-});

package/build/tests/logging.test.js

@@ -1,12 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { vi } from 'vitest';
-import { DynamicFlow } from '../dynamicFlow/DynamicFlow';
-import { renderWithProviders } from '../test-utils/rtl-utils';
-describe('logging', () => {
-    it(`supresses invalid-step "info" events coming from core`, () => {
-        const onLog = vi.fn();
-        const invalidStep = {};
-        renderWithProviders(_jsx(DynamicFlow, { flowId: "flow-id", initialStep: invalidStep, customFetch: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onEvent: vi.fn(), onLog: onLog }));
-        expect(onLog).not.toHaveBeenCalledWith('info', expect.anything(), expect.anything());
-    });
-});

package/build/tests/onNotification.test.js

@@ -1,96 +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 { DynamicFlow } from '../dynamicFlow/DynamicFlow';
-import { renderWithProviders } from '../test-utils/rtl-utils';
-const createSnackBarMock = vi.fn();
-vi.mock('../dynamicFlow/useCreateSnackBar', async () => {
-    return {
-        useCreateSnackBar: () => createSnackBarMock,
-    };
-});
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-describe('onNotification', () => {
-    beforeEach(() => {
-        createSnackBarMock.mockClear();
-    });
-    describe('Download Behavior notifications', () => {
-        const customFetch = async (input) => {
-            switch (input) {
-                case '/fake-download-url':
-                    return new Response(new Blob(['file contents'], { type: 'text/plain' }), {
-                        headers: { 'Content-Disposition': 'attachment; filename="test.txt"' },
-                    });
-                default:
-                    return new Response('Not Found', { status: 404 });
-            }
-        };
-        const initialStep = {
-            id: 'regular-step',
-            title: 'Download Test',
-            layout: [
-                {
-                    type: 'button',
-                    title: 'Download (correct)',
-                    behavior: {
-                        type: 'download',
-                        request: {
-                            url: '/fake-download-url',
-                            method: 'GET',
-                        },
-                    },
-                },
-                {
-                    type: 'button',
-                    title: 'Download (incorrect)',
-                    behavior: {
-                        type: 'download',
-                        request: {
-                            url: '/non-existent-url',
-                            method: 'GET',
-                        },
-                    },
-                },
-            ],
-            schemas: [],
-        };
-        const getProps = () => ({
-            flowId: 'test-flow',
-            customFetch,
-            initialStep,
-            onCompletion: () => { },
-            onError: () => { },
-            onEvent: vi.fn(),
-            onAnalytics: vi.fn(),
-        });
-        it('displays a snackbar with the specified localised text (success)', async () => {
-            const props = getProps();
-            renderWithProviders(_jsx(DynamicFlow, Object.assign({}, props)));
-            await waitFor(() => {
-                expect(screen.getByText('Download Test')).toBeInTheDocument();
-            });
-            await user.click(screen.getByText('Download (correct)'));
-            await waitFor(() => {
-                expect(createSnackBarMock).toHaveBeenCalledWith({ text: 'Downloading...' });
-            });
-            await waitFor(() => {
-                expect(createSnackBarMock).toHaveBeenCalledWith({ text: 'Download successful' });
-            });
-        });
-        it('displays a snackbar with the specified localised text (failure)', async () => {
-            const props = getProps();
-            renderWithProviders(_jsx(DynamicFlow, Object.assign({}, props)));
-            await waitFor(() => {
-                expect(screen.getByText('Download Test')).toBeInTheDocument();
-            });
-            await user.click(screen.getByText('Download (incorrect)'));
-            await waitFor(() => {
-                expect(createSnackBarMock).toHaveBeenCalledWith({ text: 'Downloading...' });
-            });
-            await waitFor(() => {
-                expect(createSnackBarMock).toHaveBeenCalledWith({ text: 'Download failed' });
-            });
-        });
-    });
-});

package/build/tests/renderers/ControlAndTags.test.js

@@ -1,225 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen } from '@testing-library/react';
-import { vi } from 'vitest';
-import { DynamicFlow } from '../../dynamicFlow/DynamicFlow';
-import { renderWithProviders } from '../../test-utils/rtl-utils';
-const defaultProps = {
-    flowId: 'control-and-tags-flow',
-    onCompletion: vi.fn(),
-    onError: vi.fn(),
-    customFetch: vi.fn(),
-};
-const renderStep = (step) => renderWithProviders(_jsx(DynamicFlow, Object.assign({}, defaultProps, { initialStep: step })));
-describe('control and tags classes', () => {
-    it('applies classes for FieldInput-backed controls', () => {
-        const step = {
-            id: 'text-input-step',
-            title: 'Text input step',
-            schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['amount'],
-                    properties: {
-                        amount: {
-                            type: 'string',
-                            title: 'Amount',
-                            control: 'numeric',
-                            tags: ['primary', 'desktop'],
-                        },
-                    },
-                },
-            ],
-            layout: [{ type: 'form', schemaId: '#schema' }],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByLabelText('Amount')).toBeInTheDocument();
-        expect(container.querySelector('.df-control-numeric.df-tag-primary.df-tag-desktop')).not.toBeNull();
-    });
-    it('applies classes for radio-item select controls', () => {
-        const step = {
-            id: 'radio-item-step',
-            title: 'Radio item step',
-            schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['plan'],
-                    properties: {
-                        plan: {
-                            title: 'Choose a plan',
-                            control: 'radio-item',
-                            tags: ['plan-tag'],
-                            oneOf: [
-                                { const: 'STANDARD', title: 'Standard' },
-                                { const: 'PREMIUM', title: 'Premium' },
-                            ],
-                        },
-                    },
-                },
-            ],
-            layout: [{ type: 'form', schemaId: '#schema' }],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('Standard')).toBeInTheDocument();
-        expect(container.querySelector('.df-control-radio-item.df-tag-plan-tag')).not.toBeNull();
-    });
-    it.each(['checkbox-item', 'switch-item'])('applies classes for %s boolean controls', (control) => {
-        const step = {
-            id: `${control}-step`,
-            title: `${control} step`,
-            schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['marketing'],
-                    properties: {
-                        marketing: {
-                            type: 'boolean',
-                            title: 'Marketing emails',
-                            description: 'Receive product updates.',
-                            control,
-                            tags: ['policy'],
-                        },
-                    },
-                },
-            ],
-            layout: [{ type: 'form', schemaId: '#schema' }],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('Marketing emails')).toBeInTheDocument();
-        expect(container.querySelector(`.df-control-${control}.df-tag-policy`)).not.toBeNull();
-    });
-    it('applies classes for repeatable controls', () => {
-        const step = {
-            id: 'repeatable-step',
-            title: 'Repeatable step',
-            schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['emails'],
-                    properties: {
-                        emails: {
-                            type: 'array',
-                            title: 'Emails',
-                            addItemTitle: 'Add email',
-                            editItemTitle: 'Edit email',
-                            control: 'repeatable',
-                            tags: ['repeatable-tag'],
-                            items: {
-                                type: 'string',
-                                title: 'Email',
-                                summary: {
-                                    providesTitle: true,
-                                    providesIcon: true,
-                                },
-                                icon: {
-                                    name: 'email',
-                                },
-                            },
-                        },
-                    },
-                },
-            ],
-            layout: [{ type: 'form', schemaId: '#schema' }],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('Add email')).toBeInTheDocument();
-        expect(container.querySelector('.df-control-repeatable.df-tag-repeatable-tag')).not.toBeNull();
-    });
-    it('applies classes for file uploads rendered from a persist-async blob schema', () => {
-        const step = {
-            id: 'upload-step',
-            title: 'Upload step',
-            schemas: [
-                {
-                    $id: '#schema',
-                    type: 'object',
-                    displayOrder: ['fileToken'],
-                    properties: {
-                        fileToken: {
-                            type: 'string',
-                            persistAsync: {
-                                method: 'POST',
-                                url: '/upload',
-                                param: 'bodyAttribute',
-                                idProperty: 'token',
-                                schema: {
-                                    type: 'blob',
-                                    title: 'Invoice',
-                                    description: 'PNG, JPG, or PDF, less than 5mb',
-                                    accepts: ['image/png', 'image/jpg', 'application/pdf'],
-                                    source: 'file',
-                                    control: 'upload',
-                                    tags: ['upload-tag'],
-                                },
-                            },
-                        },
-                    },
-                },
-            ],
-            layout: [{ type: 'form', schemaId: '#schema' }],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('Invoice')).toBeInTheDocument();
-        expect(container.querySelector('.df-control-upload.df-tag-upload-tag')).not.toBeNull();
-    });
-    it('applies classes for splash step renderers', () => {
-        const step = {
-            id: 'splash-step',
-            title: 'Welcome',
-            control: 'splash',
-            tags: ['hero'],
-            schemas: [],
-            layout: [
-                {
-                    type: 'button',
-                    title: 'Continue',
-                    action: { id: 'continue-action', url: '/continue' },
-                },
-            ],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('Continue')).toBeInTheDocument();
-        expect(container.querySelector('.splash-screen.df-control-splash.df-tag-hero')).not.toBeNull();
-    });
-    it('applies classes for button renderers', () => {
-        const step = {
-            id: 'button-step',
-            title: 'Button step',
-            schemas: [],
-            layout: [
-                {
-                    type: 'button',
-                    title: 'Submit',
-                    control: 'small',
-                    tags: ['button-tag'],
-                    action: { id: 'submit-action', url: '/submit' },
-                },
-            ],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByRole('button', { name: 'Submit' })).toBeInTheDocument();
-        expect(container.querySelector('.df-button.df-control-small.df-tag-button-tag')).not.toBeNull();
-    });
-    it('applies classes for list renderers', () => {
-        const step = {
-            id: 'list-step',
-            title: 'List step',
-            schemas: [],
-            layout: [
-                {
-                    type: 'list',
-                    title: 'Review items',
-                    control: 'spotlight',
-                    tags: ['list-tag'],
-                    items: [{ title: 'First item' }],
-                },
-            ],
-        };
-        const { container } = renderStep(step);
-        expect(screen.getByText('First item')).toBeInTheDocument();
-        expect(container.querySelector('.df-control-spotlight.df-tag-list-tag')).not.toBeNull();
-    });
-});

package/build/tests/renderers/ImageRenderer.test.js

@@ -1,129 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen, waitFor } from '@testing-library/react';
-import ImageRenderer from '@wise/dynamic-flow-renderers/src/ImageRenderer';
-import { vi } from 'vitest';
-import { renderWithProviders } from '../../test-utils/rtl-utils';
-const ImageRendererFunction = ImageRenderer.render;
-class MockFileReaderLoadend {
-    constructor() {
-        this.result = 'data:image/jpeg';
-        this.addEventListener = vi.fn((event, callback) => {
-            if (event === 'loadend') {
-                callback();
-            }
-        });
-        this.readAsDataURL = vi.fn();
-    }
-}
-class MockFileReaderError {
-    constructor() {
-        this.result = 'some-error-message';
-        this.addEventListener = vi.fn((event, callback) => {
-            if (event === 'error') {
-                callback();
-            }
-        });
-        this.readAsDataURL = vi.fn();
-    }
-}
-describe('ImageRenderer', () => {
-    const getProps = (uri) => ({
-        type: 'image',
-        uid: 'uid',
-        uri,
-        align: 'center',
-        accessibilityDescription: 'An image',
-        size: 'lg',
-        margin: 'md',
-        render: () => null,
-        stepLoadingState: 'idle',
-        features: {},
-        trackEvent: vi.fn(),
-        httpClient: vi.fn(),
-    });
-    describe('image.uri (with absolute url in a different domain)', () => {
-        it('renders an "img" tag with the appropriate "src" attribute', async () => {
-            const props = getProps('https://example.com/image.jpg');
-            renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-            await waitFor(() => {
-                const img = screen.getByRole('img');
-                expect(img).toHaveAttribute('src', 'https://example.com/image.jpg');
-            });
-        });
-    });
-    describe('using httpClient and FileReader', () => {
-        beforeEach(() => {
-            vi.stubGlobal('FileReader', MockFileReaderLoadend);
-        });
-        afterEach(() => {
-            vi.restoreAllMocks();
-            vi.unstubAllGlobals();
-        });
-        describe('image.uri (with relative url that succeeds)', () => {
-            it('renders an "img" tag, but fetches the image using httpClient', async () => {
-                const props = getProps('/image.jpg');
-                vi.mocked(props.httpClient).mockResolvedValueOnce(new Response(new Blob()));
-                renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-                await waitFor(() => {
-                    expect(props.httpClient).toHaveBeenCalledWith('/image.jpg', expect.anything());
-                });
-                await waitFor(() => {
-                    const img = screen.getByRole('img');
-                    expect(img).toHaveAttribute('src', 'data:image/jpeg');
-                });
-            });
-        });
-        describe('image.uri (with relative url that fails to fetch)', () => {
-            it('renders an "img" tag, fetches the image using httpClient, but falls back to setting "src"', async () => {
-                const props = getProps('/image.jpg');
-                renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-                await waitFor(() => {
-                    expect(props.httpClient).toHaveBeenCalledWith('/image.jpg', expect.anything());
-                });
-                // because the image fetching fails (it's an empty mock), the image source will be the uri
-                expect(screen.getByRole('img')).toHaveAttribute('src', '/image.jpg');
-            });
-        });
-        describe('image.uri (with relative url that fails to decode)', () => {
-            beforeEach(() => {
-                vi.stubGlobal('FileReader', MockFileReaderError);
-            });
-            afterEach(() => {
-                vi.unstubAllGlobals();
-            });
-            it('renders an "img" tag, fetches the image using httpClient, but falls back to setting "src"', async () => {
-                const props = getProps('/image.jpg');
-                renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-                await waitFor(() => {
-                    expect(props.httpClient).toHaveBeenCalledWith('/image.jpg', expect.anything());
-                });
-                // because the image fetching fails (it's an empty mock), the image source will be the uri
-                expect(screen.getByRole('img')).toHaveAttribute('src', '/image.jpg');
-            });
-        });
-        describe('image.uri (with absolute url in the same domain)', () => {
-            it('renders an "img" tag, but fetches the image using httpClient', async () => {
-                const props = getProps('http://localhost:3000/image.jpg');
-                vi.mocked(props.httpClient).mockResolvedValueOnce(new Response(new Blob()));
-                renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-                await waitFor(() => {
-                    expect(props.httpClient).toHaveBeenCalledWith('http://localhost:3000/image.jpg', expect.anything());
-                });
-                await waitFor(() => {
-                    const img = screen.getByRole('img');
-                    expect(img).toHaveAttribute('src', 'data:image/jpeg');
-                });
-            });
-        });
-    });
-    describe('image.uri (with urn illustration)', () => {
-        it('renders an illustration component which renders an "img" with a specific "src"', async () => {
-            const props = getProps('urn:wise:illustrations:confetti');
-            renderWithProviders(_jsx(ImageRendererFunction, Object.assign({}, props)));
-            await waitFor(() => {
-                const img = screen.getByRole('img');
-                expect(img).toHaveAttribute('src', expect.stringMatching(/^https:\/\/wise\.com.*illustrations\/confetti/));
-            });
-        });
-    });
-});

package/build/tests/renderers/RadioInputRendererComponent.test.js

@@ -1,89 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { screen } from '@testing-library/react';
-import { RadioInputRendererComponent } from '@wise/dynamic-flow-renderers/src/SelectInputRenderer/RadioInputRendererComponent';
-import { vi } from 'vitest';
-import { renderWithProviders } from '../../test-utils/rtl-utils';
-describe('RadioInputRendererComponent', () => {
-    const getProps = () => ({
-        type: 'input-select',
-        uid: 'uid',
-        id: 'id',
-        children: null,
-        childrenProps: null,
-        description: 'description',
-        autoComplete: 'off',
-        required: false,
-        disabled: false,
-        validationState: { status: 'invalid', message: 'error' },
-        fieldLoadingState: 'idle',
-        help: 'help',
-        options: [
-            {
-                title: 'Option A',
-                disabled: false,
-                keywords: [],
-                children: null,
-                childrenProps: null,
-            },
-            {
-                title: 'Option B',
-                disabled: false,
-                keywords: [],
-                children: null,
-                childrenProps: null,
-            },
-        ],
-        title: 'label',
-        selectedIndex: null,
-        render: () => null,
-        features: {},
-        trackEvent: vi.fn(),
-        stepLoadingState: 'idle',
-        httpClient: vi.fn(),
-        onSelect: vi.fn(),
-        onFocus: vi.fn(),
-        onBlur: vi.fn(),
-    });
-    describe('When the value is updated from outside the UI component', () => {
-        it('should update the selected value', () => {
-            const props = getProps();
-            const { rerender } = renderWithProviders(_jsx(RadioInputRendererComponent, Object.assign({}, props)));
-            expect(screen.getByLabelText('Option A')).not.toBeChecked();
-            expect(screen.getByLabelText('Option B')).not.toBeChecked();
-            rerender(_jsx(RadioInputRendererComponent, Object.assign({}, props, { selectedIndex: 1 })));
-            expect(screen.getByLabelText('Option B')).toBeChecked();
-        });
-    });
-    describe('When the options are updated (e.g. refresh-on-change)', () => {
-        it('should update the options', () => {
-            const props = Object.assign(Object.assign({}, getProps()), { selectedIndex: 1 });
-            const { rerender } = renderWithProviders(_jsx(RadioInputRendererComponent, Object.assign({}, props)));
-            expect(screen.getByLabelText('Option B')).toBeChecked();
-            const updatedProps = Object.assign(Object.assign({}, props), { options: [
-                    {
-                        title: 'Option A',
-                        disabled: false,
-                        keywords: [],
-                        children: null,
-                        childrenProps: null,
-                    },
-                    {
-                        title: 'Option NEW',
-                        disabled: false,
-                        keywords: [],
-                        children: null,
-                        childrenProps: null,
-                    },
-                    {
-                        title: 'Option B',
-                        disabled: false,
-                        keywords: [],
-                        children: null,
-                        childrenProps: null,
-                    },
-                ] });
-            rerender(_jsx(RadioInputRendererComponent, Object.assign({}, updatedProps)));
-            expect(screen.getByLabelText('Option NEW')).toBeChecked();
-        });
-    });
-});