@solucx/react-native-solucx-widget 0.2.4 → 2.0.7

package/src/__tests__/useWidgetBootstrap.test.ts

@@ -0,0 +1,634 @@
+import { renderHook, waitFor } from '@testing-library/react-native';
+import { useWidgetBootstrap } from '../hooks/useWidgetBootstrap';
+import { requestWidgetUrl, requestWidgetOptions } from '../services/WidgetBootstrapService';
+import type { WidgetStateManager } from '../services/WidgetStateManager';
+import type { WidgetValidationService } from '../services/WidgetValidationService';
+import type { WidgetData, WidgetOptions, WidgetCallbacks } from '../domain';
+
+// Mock dos serviços
+jest.mock('../services/WidgetBootstrapService');
+
+const mockRequestWidgetUrl = requestWidgetUrl as jest.MockedFunction<typeof requestWidgetUrl>;
+const mockRequestWidgetOptions = requestWidgetOptions as jest.MockedFunction<typeof requestWidgetOptions>;
+
+describe('useWidgetBootstrap', () => {
+    let mockOpen: jest.Mock;
+    let mockHide: jest.Mock;
+    let mockOnError: jest.Mock;
+    let mockOnBlocked: jest.Mock;
+    let mockOnPreOpen: jest.Mock;
+    let mockOnOpened: jest.Mock;
+    let mockValidationService: jest.Mocked<WidgetValidationService>;
+    let mockStateManager: jest.Mocked<WidgetStateManager>;
+
+    const defaultParams = {
+        soluCXKey: 'test-key-123',
+        data: {
+            journey: 'test-journey',
+            user_id: 'user123',
+        } as WidgetData,
+        userId: 'user123',
+        options: {
+            maxAttemptsAfterDismiss: 1,
+            height: 400,
+        } as WidgetOptions,
+        callbacks: {} as WidgetCallbacks,
+        open: jest.fn(),
+        hide: jest.fn(),
+        validationService: {} as any,
+        stateManager: {} as any,
+    };
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+
+        // Mocks das funções
+        mockOpen = jest.fn().mockResolvedValue(undefined);
+        mockHide = jest.fn();
+        mockOnError = jest.fn();
+        mockOnBlocked = jest.fn();
+        mockOnPreOpen = jest.fn();
+        mockOnOpened = jest.fn();
+
+        // Mock do ValidationService
+        mockValidationService = {
+            shouldDisplayWidget: jest.fn().mockResolvedValue({
+                canDisplay: true,
+                blockReason: undefined,
+            }),
+            shouldDisplayForTransactionAlreadyAnswered: jest.fn().mockResolvedValue({
+                canDisplay: true,
+                blockReason: undefined,
+            }),
+        } as any;
+
+        // Mock do StateManager
+        mockStateManager = {
+            getLogs: jest.fn().mockResolvedValue({
+                attempts: 0,
+                answeredTransactionIds: [],
+                lastFirstAccess: undefined,
+            }),
+            updateTimestamp: jest.fn().mockResolvedValue(undefined),
+            incrementAttempt: jest.fn().mockResolvedValue(undefined),
+            clearLogs: jest.fn().mockResolvedValue(undefined),
+        } as any;
+
+        // Mock das funções do serviço de bootstrap
+        mockRequestWidgetOptions.mockResolvedValue({
+            maxAttemptsAfterDismiss: 2,
+            height: 400,
+        });
+
+        mockRequestWidgetUrl.mockResolvedValue({
+            available: true,
+            url: 'https://widget.test.com/survey?token=abc123',
+        });
+    });
+
+    describe('bootstrap - Happy Path', () => {
+        it('should complete full bootstrap when all validations pass', async () => {
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    open: mockOpen,
+                    hide: mockHide,
+                    callbacks: {
+                        onPreOpen: mockOnPreOpen,
+                        onOpened: mockOnOpened,
+                    },
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(result.current.widgetUri).toBe('https://widget.test.com/survey?token=abc123');
+            });
+
+            // Verificar ordem das chamadas
+            expect(mockValidationService.shouldDisplayForTransactionAlreadyAnswered).toHaveBeenCalledWith(undefined);
+            expect(mockValidationService.shouldDisplayWidget).toHaveBeenCalled();
+            expect(mockRequestWidgetUrl).toHaveBeenCalledWith('test-key-123', defaultParams.data, 'user123');
+            expect(mockOnPreOpen).toHaveBeenCalledWith('user123');
+            expect(mockOpen).toHaveBeenCalled();
+            expect(mockStateManager.incrementAttempt).toHaveBeenCalled();
+            expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastDisplay');
+            expect(mockOnOpened).toHaveBeenCalledWith('user123');
+        });
+
+        it('should set lastFirstAccess timestamp when widget is displayed for the first time', async () => {
+            mockStateManager.getLogs.mockResolvedValue({
+                attempts: 0,
+                answeredTransactionIds: [],
+                lastFirstAccess: undefined, // Primeira vez
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastFirstAccess');
+            });
+        });
+
+        it('should not update lastFirstAccess when widget is displayed again', async () => {
+            mockStateManager.getLogs.mockResolvedValue({
+                attempts: 2,
+                answeredTransactionIds: [],
+                lastFirstAccess: 1000, // Já tem valor
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockStateManager.updateTimestamp).not.toHaveBeenCalledWith('lastFirstAccess');
+                expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastDisplay');
+            });
+        });
+
+        it('should use provided options when options are passed', async () => {
+            const customOptions: WidgetOptions = {
+                maxAttemptsAfterDismiss: 3,
+                height: 500,
+            };
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    options: customOptions,
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockRequestWidgetOptions).not.toHaveBeenCalled();
+                expect(result.current.widgetOptions).toEqual(customOptions);
+            });
+        });
+
+        it('should request options from API when options are not provided', async () => {
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    options: undefined,
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockRequestWidgetOptions).toHaveBeenCalledWith('test-key-123', 'test-journey');
+                expect(result.current.widgetOptions).toEqual({
+                    maxAttemptsAfterDismiss: 2,
+                    height: 400,
+                });
+            });
+        });
+    });
+
+    describe('bootstrap - Validation Blocking', () => {
+        it('should block widget when transaction has already been answered', async () => {
+            mockValidationService.shouldDisplayForTransactionAlreadyAnswered.mockResolvedValue({
+                canDisplay: false,
+                blockReason: 'BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED',
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    data: {
+                        ...defaultParams.data,
+                        transaction_id: 'tx123',
+                    },
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnBlocked).toHaveBeenCalledWith('BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED');
+                expect(mockHide).toHaveBeenCalled();
+                expect(mockOpen).not.toHaveBeenCalled();
+                expect(mockRequestWidgetUrl).not.toHaveBeenCalled();
+            });
+        });
+
+        it('should block widget when validation rules fail', async () => {
+            mockValidationService.shouldDisplayWidget.mockResolvedValue({
+                canDisplay: false,
+                blockReason: 'BLOCKED_BY_MAX_ATTEMPTS',
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnBlocked).toHaveBeenCalledWith('BLOCKED_BY_MAX_ATTEMPTS');
+                expect(mockHide).toHaveBeenCalled();
+                expect(mockStateManager.updateTimestamp).toHaveBeenCalledWith('lastDisplayAttempt');
+                expect(mockRequestWidgetUrl).not.toHaveBeenCalled();
+            });
+        });
+
+        it('should call onError when saving display attempt timestamp fails', async () => {
+            mockValidationService.shouldDisplayWidget.mockResolvedValue({
+                canDisplay: false,
+                blockReason: 'BLOCKED_BY_DISABLED',
+            });
+
+            mockStateManager.updateTimestamp.mockRejectedValue(new Error('Storage error'));
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Cannot save display attempt timestamp');
+                expect(mockHide).toHaveBeenCalled();
+            });
+        });
+    });
+
+    describe('bootstrap - Preflight Blocking', () => {
+        it('should block widget when preflight indicates unavailability', async () => {
+            mockRequestWidgetUrl.mockResolvedValue({
+                available: false,
+                reason: 'Survey not active',
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnBlocked).toHaveBeenCalledWith('Survey not active');
+                expect(mockHide).toHaveBeenCalled();
+                expect(mockOpen).not.toHaveBeenCalled();
+            });
+        });
+
+        it('should use default block reason when preflight returns no reason', async () => {
+            mockRequestWidgetUrl.mockResolvedValue({
+                available: false,
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnBlocked).toHaveBeenCalledWith('for the given parameters');
+                expect(mockHide).toHaveBeenCalled();
+            });
+        });
+
+        it('should call onError when widget URL is missing in response', async () => {
+            mockRequestWidgetUrl.mockResolvedValue({
+                available: true,
+                url: undefined as any,
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Widget URL is missing in the response');
+                expect(mockOpen).not.toHaveBeenCalled();
+            });
+        });
+    });
+
+    describe('bootstrap - Error Handling', () => {
+        it('should call onError when widget data is missing', async () => {
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    data: undefined as any,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Widget data is required but was not provided');
+                expect(mockOpen).not.toHaveBeenCalled();
+            });
+        });
+
+        it('should call onError when requestWidgetUrl throws error', async () => {
+            mockRequestWidgetUrl.mockRejectedValue(new Error('Network error'));
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Network error');
+                expect(mockHide).toHaveBeenCalled();
+            });
+        });
+
+        it('should call onError when error is a string', async () => {
+            mockRequestWidgetUrl.mockRejectedValue('Connection timeout');
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Connection timeout');
+            });
+        });
+
+        it('should call onError when error is an object', async () => {
+            mockRequestWidgetUrl.mockRejectedValue({ code: 500, message: 'Server error' });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('{"code":500,"message":"Server error"}');
+            });
+        });
+
+        it('should call onError when error type is unknown', async () => {
+            mockRequestWidgetUrl.mockRejectedValue(null);
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Unknown error');
+            });
+        });
+
+        it('should call onError when saving display timestamps fails', async () => {
+            mockStateManager.incrementAttempt.mockRejectedValue(new Error('Storage full'));
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onError: mockOnError,
+                        onOpened: mockOnOpened,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith('Error saving display timestamps');
+                // O widget ainda deve abrir mesmo com erro no timestamp
+                expect(mockOnOpened).toHaveBeenCalled();
+            });
+        });
+    });
+
+    describe('bootstrap - State Management', () => {
+        it('should reset widgetUri to null when bootstrap starts', async () => {
+            const { result, rerender } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            // Primeiro bootstrap
+            await result.current.bootstrap();
+            await waitFor(() => {
+                expect(result.current.widgetUri).toBe('https://widget.test.com/survey?token=abc123');
+            });
+
+            // Segundo bootstrap - deve limpar URI primeiro
+            mockRequestWidgetUrl.mockResolvedValue({
+                available: true,
+                url: 'https://widget.test.com/survey?token=xyz789',
+            });
+
+            await result.current.bootstrap();
+
+            // Verificar que foi resetado e depois atualizado
+            await waitFor(() => {
+                expect(result.current.widgetUri).toBe('https://widget.test.com/survey?token=xyz789');
+            });
+        });
+
+        it('should pass undefined as experienceId when transaction_id is not provided', async () => {
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    data: {
+                        form_id: 'form123',
+                        user_id: 'user123',
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(mockValidationService.shouldDisplayWidget).toHaveBeenCalledWith(
+                    expect.anything(),
+                    undefined
+                );
+            });
+        });
+    });
+
+    describe('bootstrap - Validation Before Preflight', () => {
+        it('should validate before preflight when bootstrap is called', async () => {
+            const callOrder: string[] = [];
+
+            mockValidationService.shouldDisplayWidget.mockImplementation(async () => {
+                callOrder.push('validation');
+                return { canDisplay: false, blockReason: 'BLOCKED_BY_DISABLED' };
+            });
+
+            mockRequestWidgetUrl.mockImplementation(async () => {
+                callOrder.push('preflight');
+                return { available: true, url: 'test' };
+            });
+
+            const { result } = renderHook(() =>
+                useWidgetBootstrap({
+                    ...defaultParams,
+                    callbacks: {
+                        onBlocked: mockOnBlocked,
+                    },
+                    open: mockOpen,
+                    hide: mockHide,
+                    validationService: mockValidationService,
+                    stateManager: mockStateManager,
+                })
+            );
+
+            await result.current.bootstrap();
+
+            await waitFor(() => {
+                expect(callOrder).toEqual(['validation']);
+                expect(mockRequestWidgetUrl).not.toHaveBeenCalled();
+            });
+        });
+    });
+});