@solucx/react-native-solucx-widget 0.2.0 → 0.2.2

package/src/__tests__/e2e/widget-lifecycle.test.tsx

@@ -82,7 +82,7 @@ describe('E2E: Widget Lifecycle', () => {
             const callbacks: WidgetCallbacks = {
                 onOpened: (userId) => analytics.track('widget_shown', { userId }),
                 onQuestionAnswered: () => analytics.track('question_answered'),
-                onPartialCompleted: (userId) => {
+                onCompleted: (userId) => {
                     analytics.track('survey_completed', { userId });
                 },
                 onClosed: () => analytics.track('widget_closed'),
@@ -117,10 +117,6 @@ describe('E2E: Widget Lifecycle', () => {
                 nativeEvent: { data: 'FORM_RESIZE-400' },
             });
 
-            await waitFor(() => {
-                expect(analytics.track).toHaveBeenCalledWith('question_answered', undefined);
-            }, { timeout: 100 }).catch(() => {}); // May not be called yet
-
             // 4. Customer answers first question
             fireEvent(webview, 'message', {
                 nativeEvent: { data: 'QUESTION_ANSWERED' },
@@ -130,6 +126,9 @@ describe('E2E: Widget Lifecycle', () => {
                 expect(analytics.track).toHaveBeenCalledWith('question_answered');
             });
 
+            // Reset counter after first question to track only upcoming interactions
+            analytics.track.mockClear();
+
             // 5. Customer goes to next page
             fireEvent(webview, 'message', {
                 nativeEvent: { data: 'FORM_PAGECHANGED-2' },
@@ -142,7 +141,7 @@ describe('E2E: Widget Lifecycle', () => {
 
             await waitFor(() => {
                 expect(analytics.track).toHaveBeenCalledWith('question_answered');
-                expect(analytics.track).toHaveBeenCalledTimes(2); // Called twice
+                expect(analytics.track).toHaveBeenCalledTimes(1); // Called once after reset
             });
 
             // 7. Customer submits survey
@@ -165,8 +164,8 @@ describe('E2E: Widget Lifecycle', () => {
                 expect(analytics.track).toHaveBeenCalledWith('widget_closed');
             });
 
-            // Verify complete tracking flow
-            expect(analytics.track).toHaveBeenCalledTimes(4);
+            // Verify complete tracking flow after reset (question_answered + survey_completed + widget_closed)
+            expect(analytics.track).toHaveBeenCalledTimes(3);
         });
     });
 
@@ -177,7 +176,7 @@ describe('E2E: Widget Lifecycle', () => {
 
             const callbacks: WidgetCallbacks = {
                 onError: errorHandler,
-                onPartialCompleted: completionHandler,
+                onCompleted: completionHandler,
             };
 
             const { getByTestId } = render(
@@ -298,7 +297,7 @@ describe('E2E: Widget Lifecycle', () => {
                     callbacks={{
                         onPageChanged: pageChangeHandler,
                         onQuestionAnswered: questionHandler,
-                        onPartialCompleted: completionHandler,
+                        onCompleted: completionHandler,
                     }}
                 />
             );

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

@@ -167,9 +167,9 @@ describe('Integration: WebView Communication', () => {
         });
 
         it('should handle FORM_COMPLETED message with userId', async () => {
-            const mockOnPartialCompleted = jest.fn();
+            const mockOnCompleted = jest.fn();
             const callbacks: WidgetCallbacks = {
-                onPartialCompleted: mockOnPartialCompleted,
+                onCompleted: mockOnCompleted,
             };
 
             const { getByTestId } = render(
@@ -186,7 +186,7 @@ describe('Integration: WebView Communication', () => {
             });
 
             await waitFor(() => {
-                expect(mockOnPartialCompleted).toHaveBeenCalledWith(expect.any(String));
+                expect(mockOnCompleted).toHaveBeenCalledWith(expect.any(String));
             });
         });
 
@@ -290,10 +290,10 @@ describe('Integration: WebView Communication', () => {
         });
 
         it('should handle completeSoluCXWidget survey event', async () => {
-            const mockOnPartialCompleted = jest.fn();
+            const mockOnCompleted = jest.fn();
 
             const { getByTestId } = render(
-                <SoluCXWidget {...surveyProps} callbacks={{ onPartialCompleted: mockOnPartialCompleted }} />
+                <SoluCXWidget {...surveyProps} callbacks={{ onCompleted: mockOnCompleted }} />
             );
 
             await waitFor(() => {
@@ -305,7 +305,7 @@ describe('Integration: WebView Communication', () => {
             });
 
             await waitFor(() => {
-                expect(mockOnPartialCompleted).toHaveBeenCalled();
+                expect(mockOnCompleted).toHaveBeenCalled();
             });
         });
     });
@@ -359,14 +359,14 @@ describe('Integration: WebView Communication', () => {
             const mockOnPageChanged = jest.fn();
             const mockOnQuestionAnswered = jest.fn();
             const mockOnResize = jest.fn();
-            const mockOnPartialCompleted = jest.fn();
+            const mockOnCompleted = jest.fn();
             const mockOnClosed = jest.fn();
 
             const callbacks: WidgetCallbacks = {
                 onPageChanged: mockOnPageChanged,
                 onQuestionAnswered: mockOnQuestionAnswered,
                 onResize: mockOnResize,
-                onPartialCompleted: mockOnPartialCompleted,
+                onCompleted: mockOnCompleted,
                 onClosed: mockOnClosed,
             };
 
@@ -404,7 +404,7 @@ describe('Integration: WebView Communication', () => {
                 expect(mockOnResize).toHaveBeenCalledTimes(2);
                 expect(mockOnPageChanged).toHaveBeenCalledTimes(1);
                 expect(mockOnQuestionAnswered).toHaveBeenCalledTimes(1);
-                expect(mockOnPartialCompleted).toHaveBeenCalledTimes(1);
+                expect(mockOnCompleted).toHaveBeenCalledTimes(1);
                 expect(mockOnClosed).toHaveBeenCalledTimes(1);
             });
 

package/src/__tests__/useWidgetState.test.ts

@@ -78,7 +78,7 @@ describe('WidgetEventService', () => {
     it('should handle FORM_COMPLETED event correctly', async () => {
         const result = await service.handleMessage('FORM_COMPLETED', true);
 
-        expect(mockCallbacks.onPartialCompleted).toHaveBeenCalledWith('test-user-123');
+        expect(mockCallbacks.onCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 
@@ -112,7 +112,7 @@ describe('WidgetEventService', () => {
     it('should adapt completeSoluCXWidget to FORM_COMPLETED', async () => {
         const result = await service.handleMessage('completeSoluCXWidget', false);
 
-        expect(mockCallbacks.onPartialCompleted).toHaveBeenCalledWith('test-user-123');
+        expect(mockCallbacks.onCompleted).toHaveBeenCalledWith('test-user-123');
         expect(result).toEqual({ status: 'success' });
     });
 

package/src/__tests__/widgetBootstrapService.test.ts

@@ -156,27 +156,62 @@ describe('widgetBootstrapService', () => {
             expect(result).toBe('https://widget.url/test');
         });
 
-        it('should return undefined when response is not ok', async () => {
+        it('should throw error when response is not ok', async () => {
             const mockResponse = {
                 ok: false,
+                status: 404,
+                statusText: 'Not Found',
             };
             (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            const result = await requestWidgetUrl(
-                'api-key',
-                { customer_id: 'cust' },
-                'user-id'
-            );
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Failed to fetch widget URL: 404 Not Found');
+        });
 
-            expect(result).toBeUndefined();
+        it('should throw error with status 500', async () => {
+            const mockResponse = {
+                ok: false,
+                status: 500,
+                statusText: 'Internal Server Error',
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Failed to fetch widget URL: 500 Internal Server Error');
         });
 
-        it('should return undefined when fetch is not available', async () => {
+        it('should throw error when fetch is not available', async () => {
             (global as any).fetch = undefined;
 
-            const result = await requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id');
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Fetch is not available');
+        });
+
+        it('should throw error when response payload does not contain url', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({}),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
+
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Widget URL not found in response');
+        });
+
+        it('should throw error when response payload url is null', async () => {
+            const mockResponse = {
+                ok: true,
+                json: jest.fn().mockResolvedValue({ url: null }),
+            };
+            (global.fetch as jest.Mock).mockResolvedValue(mockResponse);
 
-            expect(result).toBeUndefined();
+            await expect(
+                requestWidgetUrl('api-key', { customer_id: 'cust' }, 'user-id')
+            ).rejects.toThrow('Widget URL not found in response');
         });
     });
 });

package/src/hooks/useWidgetState.ts

@@ -10,9 +10,9 @@ import { StorageService } from '../services/storage';
 
 function getUserId(widgetData: WidgetData): string {
   return (
-    widgetData.customer_id ??
-    widgetData.document ??
-    widgetData.email ??
+    widgetData?.customer_id ??
+    widgetData?.document ??
+    widgetData?.email ??
     'default_user'
   );
 }

package/src/interfaces/WidgetCallbacks.ts

@@ -4,7 +4,6 @@ export interface WidgetCallbacks {
     onPreOpen?: (userId: string) => void;
     onOpened?: (userId: string) => void;
     onBlock?: (blockReason: BlockReason | undefined) => void;
-    onPingError?: (error: unknown) => void;
     onClosed?: () => void;
     onError?: (message: string) => void;
     onPageChanged?: (page: string) => void;

package/src/services/widgetBootstrapService.ts

@@ -50,18 +50,27 @@ export async function requestWidgetUrl(
     instanceKey: SoluCXKey,
     requestParams: WidgetData,
     userId: string,
-): Promise<string | undefined> {
-    if (typeof fetch !== "function") return;
+): Promise<string> {
+    if (typeof fetch !== "function") {
+        throw new Error("Fetch is not available");
+    }
 
     const params = buildRequestParams(requestParams);
     const url = `${RATING_FORM_ENDPOINT}?${params.toString()}`;
     const headers = buildRequestHeaders(instanceKey, userId);
     const response = await fetch(url, { method: "GET", headers });
 
-    if (!response.ok) return;
+    if (!response.ok) {
+        throw new Error(`Failed to fetch widget URL: ${response.status} ${response.statusText}`);
+    }
 
     const payload: Payload = await response.json();
-    return payload?.url;
+    
+    if (!payload?.url) {
+        throw new Error("Widget URL not found in response");
+    }
+    
+    return payload.url;
 }
 
 export { buildRequestParams };

package/src/services/widgetEventService.ts

@@ -79,7 +79,7 @@ export class WidgetEventService {
   }
 
   private handleFormCompleted(): WidgetResponse {
-    this.callbacks?.onPartialCompleted?.(this.userId);
+    this.callbacks?.onCompleted?.(this.userId);
     return { status: "success" };
   }