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

package/src/__tests__/integration/webview-communication.test.tsx

@@ -1,35 +1,35 @@
 /**
  * INTEGRATION TEST: WebView Communication
- * 
+ *
  * CRITICAL: Tests the core WebView message passing bridge between
  * the embedded widget and React Native.
- * 
+ *
  * Coverage Target: handleWebViewMessage, handleWebViewLoad, handleClose
  * Previous Coverage: 0% (CRITICAL GAP)
- * 
+ *
  * Strategy: Minimal mocking - use real WidgetEventService and components
  */
 
-import React from 'react';
-import { render, waitFor, fireEvent } from '@testing-library/react-native';
-import { SoluCXWidget } from '../../SoluCXWidget';
-import type { WidgetCallbacks } from '../../interfaces';
+import React from "react";
+import { render, waitFor, fireEvent } from "@testing-library/react-native";
+import { SoluCXWidgetView as SoluCXWidget } from "../../SoluCXWidgetView";
+import type { WidgetCallbacks } from "../../domain";
 
 // Mock only external dependencies we can't control
-jest.mock('react-native-webview', () => {
-    const React = require('react');
-    const { View } = require('react-native');
+jest.mock("react-native-webview", () => {
+    const React = require("react");
+    const { View } = require("react-native");
     return {
         __esModule: true,
         WebView: React.forwardRef((props: any, ref: any) => {
             // Store ref methods for testing
             React.useImperativeHandle(ref, () => ({
-                injectJavaScript: jest.fn((script) => {
+                injectJavaScript: jest.fn(script => {
                     // Simulate successful injection
                     if (props.onLoadEnd) props.onLoadEnd();
                 }),
             }));
-            
+
             return (
                 <View testID="webview" {...props}>
                     {/* Expose onMessage handler for testing */}
@@ -40,19 +40,21 @@ jest.mock('react-native-webview', () => {
     };
 });
 
-jest.mock('../../services/widgetBootstrapService', () => ({
-    requestWidgetUrl: jest.fn().mockResolvedValue('https://mock.widget.url/form123'),
+jest.mock("../../services/WidgetBootstrapService", () => ({
+    requestWidgetUrl: jest.fn().mockResolvedValue({ available: true, url: "https://mock.widget.url/form123" }),
 }));
 
-jest.mock('../../services/widgetValidationService', () => ({
+jest.mock("../../services/WidgetValidationService", () => ({
     WidgetValidationService: jest.fn().mockImplementation(() => ({
+        shouldDisplayForTransaction: jest.fn().mockResolvedValue({ canDisplay: true }),
+        shouldDisplayForTransactionAlreadyAnswered: jest.fn().mockResolvedValue({ canDisplay: true }),
         shouldDisplayWidget: jest.fn().mockResolvedValue({ canDisplay: true }),
     })),
 }));
 
 // Mock storage but keep it functional
 const mockStorage: Record<string, string> = {};
-jest.mock('@react-native-async-storage/async-storage', () => ({
+jest.mock("@react-native-async-storage/async-storage", () => ({
     __esModule: true,
     default: {
         getItem: jest.fn((key: string) => Promise.resolve(mockStorage[key] || null)),
@@ -67,13 +69,13 @@ jest.mock('@react-native-async-storage/async-storage', () => ({
     },
 }));
 
-describe('Integration: WebView Communication', () => {
+describe("Integration: WebView Communication", () => {
     const baseProps = {
-        soluCXKey: 'test-key-123',
-        type: 'modal' as const,
-        data: { 
-            customer_id: 'user-456',
-            form_id: 'form-789', // Required for form mode
+        soluCXKey: "test-key-123",
+        type: "modal" as const,
+        data: {
+            customer_id: "user-456",
+            form_id: "form-789", // Required for form mode
         },
         options: {
             height: 400,
@@ -85,27 +87,25 @@ describe('Integration: WebView Communication', () => {
         Object.keys(mockStorage).forEach(key => delete mockStorage[key]);
     });
 
-    describe('Message Handling - Form Events', () => {
-        it('should handle FORM_CLOSE message and call onClosed callback', async () => {
+    describe("Message Handling - Form Events", () => {
+        it("should handle FORM_CLOSE message and call onClosed callback", async () => {
             const mockOnClosed = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onClosed: mockOnClosed,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             // Wait for widget to be ready
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
-            const webview = getByTestId('webview');
+            const webview = getByTestId("webview");
 
             // Simulate WebView sending FORM_CLOSE message
-            fireEvent(webview, 'message', {
-                nativeEvent: { data: 'FORM_CLOSE' },
+            fireEvent(webview, "message", {
+                nativeEvent: { data: "FORM_CLOSE" },
             });
 
             // Verify callback was called
@@ -114,71 +114,84 @@ describe('Integration: WebView Communication', () => {
             });
         }, 15000); // 15 second timeout for slower CI environments
 
-        it('should handle FORM_ERROR message with error text', async () => {
+        it("should handle FORM_ERROR message with error text", async () => {
             const mockOnError = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onError: mockOnError,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Simulate error message with details
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'FORM_ERROR-Network timeout occurred' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "FORM_ERROR-Network timeout occurred" },
+            });
+
+            await waitFor(() => {
+                expect(mockOnError).toHaveBeenCalledWith("Network timeout occurred");
+            });
+        });
+
+        it("should preserve FORM_ERROR payloads containing additional hyphens", async () => {
+            const mockOnError = jest.fn();
+            const callbacks: WidgetCallbacks = {
+                onError: mockOnError,
+            };
+
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
+
+            await waitFor(() => {
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
+            fireEvent(getByTestId("webview"), "message", { nativeEvent: { data: "FORM_ERROR-timeout-api-gateway" } });
+
             await waitFor(() => {
-                expect(mockOnError).toHaveBeenCalledWith('Network timeout occurred');
+                expect(mockOnError).toHaveBeenCalledWith("timeout-api-gateway");
             });
         });
 
-        it('should handle FORM_RESIZE message and update height', async () => {
+        it("should handle FORM_RESIZE message and update height", async () => {
             const mockOnResize = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onResize: mockOnResize,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Simulate resize message
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'FORM_RESIZE-650' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "FORM_RESIZE-650" },
             });
 
             await waitFor(() => {
-                expect(mockOnResize).toHaveBeenCalledWith('650');
+                expect(mockOnResize).toHaveBeenCalledWith("650");
             });
         });
 
-        it('should handle FORM_COMPLETED message with userId', async () => {
+        it("should handle FORM_COMPLETED message with userId", async () => {
             const mockOnCompleted = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onCompleted: mockOnCompleted,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Simulate form completion
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'FORM_COMPLETED' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "FORM_COMPLETED" },
             });
 
             await waitFor(() => {
@@ -186,47 +199,43 @@ describe('Integration: WebView Communication', () => {
             });
         });
 
-        it('should handle FORM_PAGECHANGED message', async () => {
+        it("should handle FORM_PAGECHANGED message", async () => {
             const mockOnPageChanged = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onPageChanged: mockOnPageChanged,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Simulate page change
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'FORM_PAGECHANGED-2' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "FORM_PAGECHANGED-2" },
             });
 
             await waitFor(() => {
-                expect(mockOnPageChanged).toHaveBeenCalledWith('2');
+                expect(mockOnPageChanged).toHaveBeenCalledWith("2");
             });
         });
 
-        it('should handle QUESTION_ANSWERED message', async () => {
+        it("should handle QUESTION_ANSWERED message", async () => {
             const mockOnQuestionAnswered = jest.fn();
             const callbacks: WidgetCallbacks = {
                 onQuestionAnswered: mockOnQuestionAnswered,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Simulate question answered
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'QUESTION_ANSWERED' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "QUESTION_ANSWERED" },
             });
 
             await waitFor(() => {
@@ -235,29 +244,27 @@ describe('Integration: WebView Communication', () => {
         });
     });
 
-    describe('Message Handling - Survey Events', () => {
+    describe("Message Handling - Survey Events", () => {
         const surveyProps = {
             ...baseProps,
             data: {
-                customer_id: 'user-456',
+                customer_id: "user-456",
                 // No form_id = survey mode
             },
         };
 
-        it('should handle closeSoluCXWidget survey event', async () => {
+        it("should handle closeSoluCXWidget survey event", async () => {
             const mockOnClosed = jest.fn();
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...surveyProps} callbacks={{ onClosed: mockOnClosed }} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...surveyProps} callbacks={{ onClosed: mockOnClosed }} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
             // Survey uses different event names
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'closeSoluCXWidget' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "closeSoluCXWidget" },
             });
 
             await waitFor(() => {
@@ -265,39 +272,35 @@ describe('Integration: WebView Communication', () => {
             });
         });
 
-        it('should handle resizeSoluCXWidget survey event', async () => {
+        it("should handle resizeSoluCXWidget survey event", async () => {
             const mockOnResize = jest.fn();
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...surveyProps} callbacks={{ onResize: mockOnResize }} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...surveyProps} callbacks={{ onResize: mockOnResize }} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'resizeSoluCXWidget-800' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "resizeSoluCXWidget-800" },
             });
 
             await waitFor(() => {
-                expect(mockOnResize).toHaveBeenCalledWith('800');
+                expect(mockOnResize).toHaveBeenCalledWith("800");
             });
         });
 
-        it('should handle completeSoluCXWidget survey event', async () => {
+        it("should handle completeSoluCXWidget survey event", async () => {
             const mockOnCompleted = jest.fn();
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...surveyProps} callbacks={{ onCompleted: mockOnCompleted }} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...surveyProps} callbacks={{ onCompleted: mockOnCompleted }} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
-            fireEvent(getByTestId('webview'), 'message', {
-                nativeEvent: { data: 'completeSoluCXWidget' },
+            fireEvent(getByTestId("webview"), "message", {
+                nativeEvent: { data: "completeSoluCXWidget" },
             });
 
             await waitFor(() => {
@@ -306,23 +309,21 @@ describe('Integration: WebView Communication', () => {
         });
     });
 
-    describe('Edge Cases - Message Handling', () => {
-        it('should handle rapid successive messages', async () => {
+    describe("Edge Cases - Message Handling", () => {
+        it("should handle rapid successive messages", async () => {
             const mockOnResize = jest.fn();
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={{ onResize: mockOnResize }} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={{ onResize: mockOnResize }} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
-            const webview = getByTestId('webview');
+            const webview = getByTestId("webview");
 
             // Send 10 resize messages rapidly
             for (let i = 0; i < 10; i++) {
-                fireEvent(webview, 'message', {
+                fireEvent(webview, "message", {
                     nativeEvent: { data: `FORM_RESIZE-${300 + i * 10}` },
                 });
             }
@@ -333,25 +334,23 @@ describe('Integration: WebView Communication', () => {
             });
 
             // Verify last call had correct value
-            expect(mockOnResize).toHaveBeenLastCalledWith('390');
+            expect(mockOnResize).toHaveBeenLastCalledWith("390");
         });
     });
 
-    describe('Close Button Integration', () => {
-        it('should render close button in modal', async () => {
-            const { getByText, getByTestId } = render(
-                <SoluCXWidget {...baseProps} type="modal" />
-            );
+    describe("Close Button Integration", () => {
+        it("should render close button in modal", async () => {
+            const { getByText, getByTestId } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
-                expect(getByText('✕')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
+                expect(getByText("✕")).toBeTruthy();
             });
         });
     });
 
-    describe('Multiple Callbacks in Single Flow', () => {
-        it('should call multiple callbacks during form interaction flow', async () => {
+    describe("Multiple Callbacks in Single Flow", () => {
+        it("should call multiple callbacks during form interaction flow", async () => {
             const mockOnPageChanged = jest.fn();
             const mockOnQuestionAnswered = jest.fn();
             const mockOnResize = jest.fn();
@@ -366,34 +365,32 @@ describe('Integration: WebView Communication', () => {
                 onClosed: mockOnClosed,
             };
 
-            const { getByTestId } = render(
-                <SoluCXWidget {...baseProps} callbacks={callbacks} />
-            );
+            const { getByTestId } = render(<SoluCXWidget {...baseProps} callbacks={callbacks} />);
 
             await waitFor(() => {
-                expect(getByTestId('webview')).toBeTruthy();
+                expect(getByTestId("webview")).toBeTruthy();
             });
 
-            const webview = getByTestId('webview');
+            const webview = getByTestId("webview");
 
             // Simulate complete user flow
             // 1. Form resizes
-            fireEvent(webview, 'message', { nativeEvent: { data: 'FORM_RESIZE-400' } });
-            
+            fireEvent(webview, "message", { nativeEvent: { data: "FORM_RESIZE-400" } });
+
             // 2. User goes to page 2
-            fireEvent(webview, 'message', { nativeEvent: { data: 'FORM_PAGECHANGED-2' } });
-            
+            fireEvent(webview, "message", { nativeEvent: { data: "FORM_PAGECHANGED-2" } });
+
             // 3. User answers a question
-            fireEvent(webview, 'message', { nativeEvent: { data: 'QUESTION_ANSWERED' } });
-            
+            fireEvent(webview, "message", { nativeEvent: { data: "QUESTION_ANSWERED" } });
+
             // 4. Form resizes again
-            fireEvent(webview, 'message', { nativeEvent: { data: 'FORM_RESIZE-500' } });
-            
+            fireEvent(webview, "message", { nativeEvent: { data: "FORM_RESIZE-500" } });
+
             // 5. User completes form
-            fireEvent(webview, 'message', { nativeEvent: { data: 'FORM_COMPLETED' } });
-            
+            fireEvent(webview, "message", { nativeEvent: { data: "FORM_COMPLETED" } });
+
             // 6. User closes
-            fireEvent(webview, 'message', { nativeEvent: { data: 'FORM_CLOSE' } });
+            fireEvent(webview, "message", { nativeEvent: { data: "FORM_CLOSE" } });
 
             // Verify all callbacks were called in order
             await waitFor(() => {
@@ -405,9 +402,9 @@ describe('Integration: WebView Communication', () => {
             });
 
             // Verify correct arguments
-            expect(mockOnResize).toHaveBeenNthCalledWith(1, '400');
-            expect(mockOnResize).toHaveBeenNthCalledWith(2, '500');
-            expect(mockOnPageChanged).toHaveBeenCalledWith('2');
+            expect(mockOnResize).toHaveBeenNthCalledWith(1, "400");
+            expect(mockOnResize).toHaveBeenNthCalledWith(2, "500");
+            expect(mockOnPageChanged).toHaveBeenCalledWith("2");
         });
     });
 });

package/src/__tests__/normalizeWidgetOptions.test.ts

@@ -0,0 +1,80 @@
+import { normalizeWidgetOptions } from '../domain/WidgetOptions';
+import type { WidgetOptions } from '../domain/WidgetOptions';
+
+describe('normalizeWidgetOptions', () => {
+    it('returns options unchanged when no legacy fields are present', () => {
+        const options: WidgetOptions = {
+            maxAttemptsAfterDismiss: 5,
+            waitDaysAfterWidgetDismiss: 2,
+            waitDaysAfterWidgetSubmit: 30,
+            waitDaysAfterWidgetPartialSubmit: 60,
+        };
+        expect(normalizeWidgetOptions(options)).toEqual(options);
+    });
+
+    it('maps retry.attempts to maxAttemptsAfterDismiss', () => {
+        const result = normalizeWidgetOptions({ retry: { attempts: 3 } });
+        expect(result.maxAttemptsAfterDismiss).toBe(3);
+    });
+
+    it('maps retry.interval to waitDaysAfterWidgetDismiss', () => {
+        const result = normalizeWidgetOptions({ retry: { interval: 1 } });
+        expect(result.waitDaysAfterWidgetDismiss).toBe(1);
+    });
+
+    it('maps waitDelayAfterRating to waitDaysAfterWidgetSubmit and waitDaysAfterWidgetPartialSubmit', () => {
+        const result = normalizeWidgetOptions({ waitDelayAfterRating: 30 });
+        expect(result.waitDaysAfterWidgetSubmit).toBe(30);
+        expect(result.waitDaysAfterWidgetPartialSubmit).toBe(30);
+    });
+
+    it('canonical fields take precedence over legacy retry fields', () => {
+        const result = normalizeWidgetOptions({
+            maxAttemptsAfterDismiss: 10,
+            waitDaysAfterWidgetDismiss: 7,
+            retry: { attempts: 3, interval: 1 },
+        });
+        expect(result.maxAttemptsAfterDismiss).toBe(10);
+        expect(result.waitDaysAfterWidgetDismiss).toBe(7);
+    });
+
+    it('canonical fields take precedence over legacy waitDelayAfterRating', () => {
+        const result = normalizeWidgetOptions({
+            waitDaysAfterWidgetSubmit: 90,
+            waitDaysAfterWidgetPartialSubmit: 45,
+            waitDelayAfterRating: 30,
+        });
+        expect(result.waitDaysAfterWidgetSubmit).toBe(90);
+        expect(result.waitDaysAfterWidgetPartialSubmit).toBe(45);
+    });
+
+    it('should handle backward-compatible format when legacy fields are provided', (): void => {
+        const result = normalizeWidgetOptions({
+            retry: { attempts: 3, interval: 1 },
+            waitDelayAfterRating: 30,
+        });
+        expect(result.maxAttemptsAfterDismiss).toBe(3);
+        expect(result.waitDaysAfterWidgetDismiss).toBe(1);
+        expect(result.waitDaysAfterWidgetSubmit).toBe(30);
+        expect(result.waitDaysAfterWidgetPartialSubmit).toBe(30);
+    });
+
+    it('should preserve other options when normalizing legacy fields', (): void => {
+        const result = normalizeWidgetOptions({
+            enabled: true,
+            samplingPercentage: 50,
+            height: 400,
+            retry: { attempts: 3, interval: 1 },
+            waitDelayAfterRating: 30,
+        });
+        expect(result.enabled).toBe(true);
+        expect(result.samplingPercentage).toBe(50);
+        expect(result.height).toBe(400);
+    });
+
+    it('should leave fields undefined when retry object is empty', (): void => {
+        const result = normalizeWidgetOptions({ retry: {} });
+        expect(result.maxAttemptsAfterDismiss).toBeUndefined();
+        expect(result.waitDaysAfterWidgetDismiss).toBeUndefined();
+    });
+});