@wise/dynamic-flow-client 5.25.1 → 5.25.2

package/build/tests/ValidationAsync.test.js

@@ -0,0 +1,295 @@
+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

@@ -0,0 +1,348 @@
+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());
+        });
+    });
+});