@wise/dynamic-flow-client 5.28.0 → 5.29.0-experimental-f7c2300

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/behavior/events.test.js

@@ -1,348 +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, respondWith } from '../../test-utils';
-import { getMockHttpClient } from '../../test-utils/fetch-utils';
-import DynamicFlowWise from '../../test-utils/DynamicFlowWise';
-const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
-describe('Behavior Triggered event', () => {
-    const goodCases = [
-        [
-            'copy behavior',
-            {
-                step: {
-                    id: 'step-id',
-                    title: 'Step',
-                    schemas: [],
-                    layout: [
-                        {
-                            type: 'button',
-                            title: 'Copy',
-                            behavior: {
-                                type: 'copy',
-                                content: 'copied text',
-                                analytics: { source: 'test' },
-                            },
-                        },
-                    ],
-                },
-                buttonLabel: 'Copy',
-                expectedBehaviorType: 'copy',
-            },
-        ],
-        [
-            'link behavior',
-            {
-                step: {
-                    id: 'step-id',
-                    title: 'Step',
-                    schemas: [],
-                    layout: [
-                        {
-                            type: 'button',
-                            title: 'Open Link',
-                            behavior: {
-                                type: 'link',
-                                url: 'https://example.com',
-                                analytics: { source: 'test' },
-                            },
-                        },
-                    ],
-                },
-                buttonLabel: 'Open Link',
-                expectedBehaviorType: 'link',
-            },
-        ],
-        [
-            'refresh behavior',
-            {
-                step: {
-                    id: 'step-id',
-                    title: 'Step',
-                    schemas: [],
-                    layout: [
-                        {
-                            type: 'button',
-                            title: 'Refresh',
-                            behavior: {
-                                type: 'refresh',
-                                analytics: { source: 'test' },
-                            },
-                        },
-                    ],
-                },
-                buttonLabel: 'Refresh',
-                expectedBehaviorType: 'refresh',
-            },
-        ],
-        [
-            'modal behavior',
-            {
-                step: {
-                    id: 'step-id',
-                    title: 'Step',
-                    schemas: [],
-                    layout: [
-                        {
-                            type: 'button',
-                            title: 'Open Modal',
-                            behavior: {
-                                type: 'modal',
-                                title: 'Modal Title',
-                                content: [{ type: 'paragraph', text: 'Modal content' }],
-                                analytics: { source: 'test' },
-                            },
-                        },
-                    ],
-                },
-                buttonLabel: 'Open Modal',
-                expectedBehaviorType: 'modal',
-            },
-        ],
-        [
-            'subflow behavior',
-            {
-                step: {
-                    id: 'step-id',
-                    title: 'Step',
-                    schemas: [],
-                    layout: [
-                        {
-                            type: 'button',
-                            title: 'Start Subflow',
-                            behavior: {
-                                type: 'subflow',
-                                referrerId: 'test-referrer',
-                                launchConfig: {
-                                    type: 'dynamic',
-                                    presentation: { type: 'modal' },
-                                    request: {
-                                        method: 'POST',
-                                        url: '/subflow',
-                                    },
-                                },
-                                analytics: { source: 'test' },
-                            },
-                        },
-                    ],
-                },
-                buttonLabel: 'Start Subflow',
-                expectedBehaviorType: 'subflow',
-            },
-        ],
-    ];
-    describe.each(goodCases)('%s', (_name, { step, buttonLabel, expectedBehaviorType }) => {
-        it('sends the Behavior Triggered event', async () => {
-            const onEvent = vi.fn();
-            const httpClient = vi.fn().mockResolvedValue(respondWith({}));
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            await user.click(screen.getByRole('button', { name: buttonLabel }));
-            await waitFor(() => {
-                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.objectContaining({
-                    behaviorType: expectedBehaviorType,
-                    source: 'test',
-                }));
-            });
-        });
-    });
-    describe('delay behavior', () => {
-        const step = {
-            id: 'step-id',
-            title: 'Step',
-            schemas: [],
-            layout: [
-                {
-                    type: 'button',
-                    title: 'Action with delay',
-                    behavior: {
-                        type: 'delay',
-                        duration: 1,
-                        analytics: { source: 'delay' },
-                        behavior: {
-                            type: 'action',
-                            action: {
-                                url: '/submit',
-                                method: 'POST',
-                            },
-                            analytics: { source: 'action' },
-                        },
-                    },
-                },
-            ],
-        };
-        it('sends the Behavior Triggered event for the Delay and the child behavior', async () => {
-            const onEvent = vi.fn();
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: vi.fn(), onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            await user.click(screen.getByRole('button', { name: 'Action with delay' }));
-            await waitFor(() => {
-                expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.objectContaining({
-                    behaviorType: 'delay',
-                    source: 'delay',
-                }));
-            });
-            await act(() => vi.advanceTimersByTimeAsync(1000));
-            expect(onEvent).toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.objectContaining({
-                behaviorType: 'action',
-                source: 'action',
-            }));
-        });
-    });
-    describe("non-behavior spec features which use behaviors internally don't track", () => {
-        it('back action', async () => {
-            const onEvent = vi.fn();
-            const nextStep = {
-                id: 'next-step',
-                title: 'Next Step',
-                schemas: [],
-                layout: [{ type: 'paragraph', text: 'Next step content' }],
-            };
-            const httpClient = vi.fn().mockResolvedValue(respondWith(nextStep));
-            const step = {
-                id: 'step-id',
-                title: 'Step',
-                schemas: [],
-                layout: [{ type: 'paragraph', text: 'Content' }],
-                navigation: {
-                    back: { title: 'Go Back', action: { method: 'GET', url: '/back' } },
-                },
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            await user.click(screen.getByRole('button', { name: 'Go Back' }));
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/back', expect.anything());
-            });
-            expect(onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.anything());
-        });
-        it('polling action', async () => {
-            const onEvent = vi.fn();
-            const nextStep = {
-                id: 'next-step',
-                title: 'Polled Step',
-                schemas: [],
-                layout: [{ type: 'paragraph', text: 'Polled content' }],
-            };
-            const httpClient = vi.fn(getMockHttpClient({
-                '/polling': async () => respondWith(nextStep),
-            }));
-            const step = {
-                id: 'step-id',
-                title: 'Step',
-                schemas: [],
-                layout: [],
-                polling: {
-                    url: '/polling',
-                    interval: 2,
-                    maxAttempts: 10,
-                    onError: {
-                        action: { url: '/error', method: 'GET' },
-                    },
-                },
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            await act(async () => {
-                vi.advanceTimersByTime(2000);
-            });
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/polling', expect.anything());
-            });
-            expect(onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.anything());
-        });
-        it('search action', async () => {
-            const onEvent = vi.fn();
-            const nextStep = {
-                id: 'next-step',
-                title: 'Next Step',
-                schemas: [],
-                layout: [{ type: 'paragraph', text: 'Next step content' }],
-            };
-            const httpClient = vi.fn(getMockHttpClient({
-                '/search?query=abcd': async () => new Response(JSON.stringify({
-                    type: 'results',
-                    results: [
-                        {
-                            type: 'action',
-                            title: 'Result 1',
-                            description: 'A result',
-                            value: { url: '/next-step', method: 'GET' },
-                        },
-                    ],
-                })),
-                '/next-step': async () => respondWith(nextStep),
-            }));
-            const step = {
-                id: 'step-id',
-                title: 'Step',
-                schemas: [],
-                layout: [
-                    {
-                        type: 'search',
-                        title: 'Search',
-                        url: '/search',
-                        method: 'GET',
-                        param: 'query',
-                        emptyMessage: 'No results',
-                    },
-                ],
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            const input = screen.getByLabelText('Search');
-            await user.type(input, 'abcd');
-            await act(async () => vi.advanceTimersByTimeAsync(500));
-            await waitFor(() => {
-                expect(screen.getByText('Result 1')).toBeInTheDocument();
-            });
-            await user.click(screen.getByText('Result 1'));
-            await waitFor(() => {
-                expect(screen.getByText('Next Step')).toBeInTheDocument();
-            });
-            expect(onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.anything());
-        });
-        it('schema on change', async () => {
-            const onEvent = vi.fn();
-            const httpClient = vi.fn().mockResolvedValue(respondWith({}));
-            const step = {
-                id: 'step-id',
-                title: 'Step',
-                schemas: [
-                    {
-                        $id: '#name',
-                        type: 'string',
-                        title: 'Name',
-                        refreshStepOnChange: true,
-                        refreshUrl: '/refresh',
-                    },
-                ],
-                layout: [{ type: 'form', schemaId: '#name' }],
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            const nameInput = screen.getByLabelText('Name');
-            await user.type(nameInput, 'John');
-            await act(async () => vi.advanceTimersByTimeAsync(1000));
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/refresh', expect.anything());
-            });
-            expect(onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.anything());
-        });
-        it('refresh after', async () => {
-            const onEvent = vi.fn();
-            const httpClient = vi.fn().mockResolvedValue(respondWith({}));
-            const step = {
-                id: 'step-id',
-                title: 'Step',
-                schemas: [],
-                layout: [{ type: 'paragraph', text: 'Waiting for refresh' }],
-                refreshUrl: '/refresh',
-                refreshAfter: new Date(Date.now() + 3000).toISOString(),
-            };
-            renderWithProviders(_jsx(DynamicFlowWise, { flowId: "flow-id", initialStep: step, httpClient: httpClient, onCompletion: vi.fn(), onError: vi.fn(), onEvent: onEvent }));
-            await act(async () => {
-                vi.advanceTimersByTime(3000);
-            });
-            await waitFor(() => {
-                expect(httpClient).toHaveBeenCalledWith('/refresh', expect.anything());
-            });
-            expect(onEvent).not.toHaveBeenCalledWith('Dynamic Flow - Behavior Triggered', expect.anything());
-        });
-    });
-});