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

package/src/__tests__/SoluCXWidget.rendering.test.tsx

@@ -1,8 +1,8 @@
 import React from "react";
 import { render, waitFor } from "@testing-library/react-native";
-import { SoluCXWidget } from "../SoluCXWidget";
-import { WidgetData, WidgetOptions } from "../interfaces";
-import { requestWidgetUrl } from "../services/widgetBootstrapService";
+import { SoluCXWidgetView as SoluCXWidget } from "../SoluCXWidgetView";
+import { WidgetData, WidgetOptions } from "../domain";
+import { requestWidgetOptions, requestWidgetUrl } from "../services/WidgetBootstrapService";
 
 jest.mock("react-native-webview", () => {
     const { forwardRef } = require("react");
@@ -13,38 +13,50 @@ jest.mock("react-native-webview", () => {
     };
 });
 
-const mockLoadSavedData = jest.fn();
 const mockClose = jest.fn();
-const mockSetIsWidgetVisible = jest.fn();
+const mockHide = jest.fn();
 const mockOpen = jest.fn();
 const mockShouldDisplayWidget = jest.fn();
+const mockShouldDisplayForTransaction = jest.fn();
+
+const mockStateManager = {
+    getLogs: jest.fn().mockResolvedValue({ lastFirstAccess: 0, lastDisplay: 0 }),
+    updateTimestamp: jest.fn().mockResolvedValue(undefined),
+    incrementAttempt: jest.fn().mockResolvedValue(undefined),
+    hasAnsweredTransaction: jest.fn().mockResolvedValue(false),
+    markTransactionAnswered: jest.fn().mockResolvedValue(undefined),
+    resetAttempts: jest.fn().mockResolvedValue(undefined),
+};
 
-jest.mock("../hooks/useWidgetState", () => ({
-    useWidgetState: () => ({
+jest.mock("../hooks/useWidget", () => ({
+    useWidget: () => ({
         widgetHeight: 400,
         isWidgetVisible: true,
-        setIsWidgetVisible: mockSetIsWidgetVisible,
-        loadSavedData: mockLoadSavedData,
+        hide: mockHide,
         resize: jest.fn(),
         open: mockOpen,
         close: mockClose,
         userId: "test-user-123",
+        stateManager: mockStateManager,
     }),
 }));
 
-jest.mock("../services/widgetEventService", () => ({
+jest.mock("../services/WidgetEventService", () => ({
     WidgetEventService: jest.fn().mockImplementation(() => ({
         handleMessage: jest.fn(),
     })),
 }));
 
-jest.mock("../services/widgetValidationService", () => ({
+jest.mock("../services/WidgetValidationService", () => ({
     WidgetValidationService: jest.fn().mockImplementation(() => ({
+        shouldDisplayForTransaction: mockShouldDisplayForTransaction,
+        shouldDisplayForTransactionAlreadyAnswered: mockShouldDisplayForTransaction,
         shouldDisplayWidget: mockShouldDisplayWidget,
     })),
 }));
 
-jest.mock("../services/widgetBootstrapService", () => ({
+jest.mock("../services/WidgetBootstrapService", () => ({
+    requestWidgetOptions: jest.fn(),
     requestWidgetUrl: jest.fn(),
 }));
 
@@ -53,7 +65,7 @@ jest.mock("../constants/Constants", () => ({
     SDK_VERSION: "0.1.16",
 }));
 
-jest.mock("../services/ClientVersionCollector", () => ({
+jest.mock("../hooks/useClientVersionCollector", () => ({
     getClientVersion: jest.fn(() => "1.0.0"),
 }));
 
@@ -73,6 +85,7 @@ jest.mock("../hooks/useDeviceInfoCollector", () => ({
 }));
 
 const mockRequestWidgetUrl = requestWidgetUrl as jest.MockedFunction<typeof requestWidgetUrl>;
+const mockRequestWidgetOptions = requestWidgetOptions as jest.MockedFunction<typeof requestWidgetOptions>;
 const bootstrappedWidgetUrl = "https://widgets.solucx.com/widget/bootstrap-result";
 
 const baseProps = {
@@ -89,26 +102,30 @@ const baseProps = {
 
 beforeEach(() => {
     jest.clearAllMocks();
+    mockShouldDisplayForTransaction.mockReset();
+    mockShouldDisplayForTransaction.mockResolvedValue({ canDisplay: true });
     mockShouldDisplayWidget.mockReset();
     mockShouldDisplayWidget.mockResolvedValue({ canDisplay: true });
+    mockRequestWidgetOptions.mockReset();
+    mockRequestWidgetOptions.mockResolvedValue({ height: 400 });
     mockRequestWidgetUrl.mockReset();
-    mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+    mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 });
 
 describe("SoluCXWidget type routing", () => {
     it("should render ModalWidget when type is modal", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { UNSAFE_getByType } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
         await waitFor(() => {
             const modal = UNSAFE_getByType(require("react-native").Modal);
             expect(modal).toBeTruthy();
-        });
-    }, 10000);
+        }, { timeout: 10000 });
+    }, 15000);
 
     it("should render close button inside ModalWidget", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByText } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
@@ -118,7 +135,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should render WebView inside ModalWidget with correct source", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByTestId } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
@@ -129,7 +146,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should render InlineWidget when type is inline", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { queryByTestId, getByText } = render(<SoluCXWidget {...baseProps} type="inline" />);
 
@@ -140,7 +157,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should not render Modal when type is inline", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { UNSAFE_queryByType } = render(<SoluCXWidget {...baseProps} type="inline" />);
 
@@ -151,7 +168,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should render OverlayWidget when type is bottom", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { queryByTestId, getByText } = render(<SoluCXWidget {...baseProps} type="bottom" />);
 
@@ -162,7 +179,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should render OverlayWidget when type is top", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { queryByTestId, getByText } = render(<SoluCXWidget {...baseProps} type="top" />);
 
@@ -173,7 +190,7 @@ describe("SoluCXWidget type routing", () => {
     });
 
     it("should not render Modal when type is bottom", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { UNSAFE_queryByType } = render(<SoluCXWidget {...baseProps} type="bottom" />);
 
@@ -182,17 +199,11 @@ describe("SoluCXWidget type routing", () => {
             expect(modal).toBeNull();
         });
     });
-
-    it("should call loadSavedData on mount", () => {
-        render(<SoluCXWidget {...baseProps} type="modal" />);
-
-        expect(mockLoadSavedData).toHaveBeenCalledTimes(1);
-    });
 });
 
 describe("SoluCXWidget WebView configuration", () => {
     it("should set originWhitelist to allow all origins", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByTestId } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
@@ -203,7 +214,7 @@ describe("SoluCXWidget WebView configuration", () => {
     });
 
     it("should set WebView width style to screen width", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByTestId } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
@@ -215,7 +226,7 @@ describe("SoluCXWidget WebView configuration", () => {
     });
 
     it("should set WebView height style to widgetHeight", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByTestId } = render(<SoluCXWidget {...baseProps} type="modal" />);
 
@@ -227,7 +238,7 @@ describe("SoluCXWidget WebView configuration", () => {
     });
 
     it("should use bootstrapped URL for widgets", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const { getByTestId } = render(<SoluCXWidget {...baseProps} type="inline" />);
 
@@ -240,7 +251,7 @@ describe("SoluCXWidget WebView configuration", () => {
 
 describe("SoluCXWidget bootstrap flow", () => {
     it("fetches widget URL for form widgets", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const props = {
             ...baseProps,
@@ -270,7 +281,7 @@ describe("SoluCXWidget bootstrap flow", () => {
     });
 
     it("fetches widget URL before rendering non-form widgets", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
 
         const props = {
             ...baseProps,
@@ -296,7 +307,7 @@ describe("SoluCXWidget bootstrap flow", () => {
         expect(webview.props.source.uri).toBe(bootstrappedWidgetUrl);
     });
 
-    it("keeps widget hidden when identifier fetch fails", async () => {
+    it("keeps widget hidden when preflight fetch fails", async () => {
         mockRequestWidgetUrl.mockRejectedValue(new Error("network"));
 
         const props = {
@@ -313,15 +324,16 @@ describe("SoluCXWidget bootstrap flow", () => {
         expect(queryByTestId("webview")).toBeNull();
 
         await waitFor(() => {
+            // Validation runs BEFORE preflight to reduce API load at scale
+            expect(mockShouldDisplayWidget).toHaveBeenCalledTimes(1);
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
-            expect(mockShouldDisplayWidget).not.toHaveBeenCalled();
             expect(queryByTestId("webview")).toBeNull();
         });
     });
 
-    it("keeps widget hidden when validation fails after bootstrap", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
-        mockShouldDisplayWidget.mockResolvedValue({ canDisplay: false, blockReason: "BLOCKED_BY_MAX_RETRY_ATTEMPTS" });
+    it("keeps widget hidden when validation fails before preflight", async () => {
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
+        mockShouldDisplayWidget.mockResolvedValue({ canDisplay: false, blockReason: "BLOCKED_BY_MAX_ATTEMPTS" });
 
         const props = {
             ...baseProps,
@@ -337,12 +349,38 @@ describe("SoluCXWidget bootstrap flow", () => {
         expect(queryByTestId("webview")).toBeNull();
 
         await waitFor(() => {
-            expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
+            // Validation blocks BEFORE preflight — preflight is never called
             expect(mockShouldDisplayWidget).toHaveBeenCalledTimes(1);
+            expect(mockRequestWidgetUrl).not.toHaveBeenCalled();
             expect(mockOpen).not.toHaveBeenCalled();
             expect(queryByTestId("webview")).toBeNull();
         });
     });
+
+    it("keeps widget hidden and skips all fetches when transaction was already answered", async () => {
+        mockShouldDisplayForTransaction.mockResolvedValue({
+            canDisplay: false,
+            blockReason: "BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED",
+        });
+        const onBlocked = jest.fn();
+
+        const props = {
+            ...baseProps,
+            type: "bottom" as const,
+            callbacks: { onBlocked },
+        };
+
+        const { queryByTestId } = render(<SoluCXWidget {...props} />);
+
+        await waitFor(() => {
+            expect(mockShouldDisplayForTransaction).toHaveBeenCalledWith('txn-999');
+            expect(mockShouldDisplayWidget).not.toHaveBeenCalled();
+            expect(mockRequestWidgetOptions).not.toHaveBeenCalled();
+            expect(mockRequestWidgetUrl).not.toHaveBeenCalled();
+            expect(onBlocked).toHaveBeenCalledWith('BLOCKED_BY_TRANSACTION_ALREADY_ANSWERED');
+            expect(queryByTestId("webview")).toBeNull();
+        });
+    });
 });
 
 describe("SoluCXWidget callbacks", () => {
@@ -356,7 +394,7 @@ describe("SoluCXWidget callbacks", () => {
 
         render(<SoluCXWidget {...props} type="modal" />);
 
-        expect(onError).toHaveBeenCalledTimes(1);
+        expect(onError).toHaveBeenCalled();
         expect(onError).toHaveBeenCalledWith("Widget data is required but was not provided");
     });
 
@@ -379,7 +417,7 @@ describe("SoluCXWidget callbacks", () => {
         await waitFor(() => {
             expect(onError).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledWith("Network timeout");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(mockHide).toHaveBeenCalledTimes(1);
         });
     });
 
@@ -449,13 +487,13 @@ describe("SoluCXWidget callbacks", () => {
         });
     });
 
-    it("calls onBlock when validation fails", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+    it("calls onBlocked when validation fails", async () => {
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
         mockShouldDisplayWidget.mockResolvedValue({
             canDisplay: false,
-            blockReason: "BLOCKED_BY_MAX_RETRY_ATTEMPTS",
+            blockReason: "BLOCKED_BY_MAX_ATTEMPTS",
         });
-        const onBlock = jest.fn();
+        const onBlocked = jest.fn();
 
         const props = {
             ...baseProps,
@@ -464,20 +502,20 @@ describe("SoluCXWidget callbacks", () => {
                 journey: "sac",
             },
             type: "bottom" as const,
-            callbacks: { onBlock },
+            callbacks: { onBlocked },
         };
 
         render(<SoluCXWidget {...props} />);
 
         await waitFor(() => {
-            expect(onBlock).toHaveBeenCalledTimes(1);
-            expect(onBlock).toHaveBeenCalledWith("BLOCKED_BY_MAX_RETRY_ATTEMPTS");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(onBlocked).toHaveBeenCalledTimes(1);
+            expect(onBlocked).toHaveBeenCalledWith("BLOCKED_BY_MAX_ATTEMPTS");
+            expect(mockHide).toHaveBeenCalledTimes(1);
         });
     });
 
     it("calls onPreOpen, onOpened callbacks for successful bootstrap", async () => {
-        mockRequestWidgetUrl.mockResolvedValue(bootstrappedWidgetUrl);
+        mockRequestWidgetUrl.mockResolvedValue({ available: true, url: bootstrappedWidgetUrl });
         mockShouldDisplayWidget.mockResolvedValue({ canDisplay: true });
         const onPreOpen = jest.fn();
         const onOpened = jest.fn();
@@ -520,7 +558,7 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledWith("Failed to get error response: 404 Not Found");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(mockHide).toHaveBeenCalledTimes(1);
             expect(queryByTestId("webview")).toBeNull();
         });
     });
@@ -541,7 +579,7 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledWith("Failed to get error response: 500 Internal Server Error");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(mockHide).toHaveBeenCalledTimes(1);
             expect(queryByTestId("webview")).toBeNull();
         });
     });
@@ -562,7 +600,7 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledWith("Fetch is not available");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(mockHide).toHaveBeenCalledTimes(1);
             expect(queryByTestId("webview")).toBeNull();
         });
     });
@@ -583,12 +621,12 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledTimes(1);
             expect(onError).toHaveBeenCalledWith("Failed to get the widget api response.");
-            expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+            expect(mockHide).toHaveBeenCalledTimes(1);
             expect(queryByTestId("webview")).toBeNull();
         });
     });
 
-    it("does not call shouldDisplayWidget when requestWidgetUrl fails", async () => {
+    it("calls shouldDisplayWidget before requestWidgetUrl and handles preflight failure", async () => {
         mockRequestWidgetUrl.mockRejectedValue(new Error("Failed to fetch widget URL: 403 Forbidden"));
         const onError = jest.fn();
 
@@ -601,8 +639,9 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
         render(<SoluCXWidget {...props} />);
 
         await waitFor(() => {
+            // Validation runs BEFORE preflight to avoid unnecessary API calls
+            expect(mockShouldDisplayWidget).toHaveBeenCalled();
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
-            expect(mockShouldDisplayWidget).not.toHaveBeenCalled();
             expect(mockOpen).not.toHaveBeenCalled();
             expect(onError).toHaveBeenCalledWith("Failed to fetch widget URL: 403 Forbidden");
         });
@@ -623,6 +662,8 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
         render(<SoluCXWidget {...props} />);
 
         await waitFor(() => {
+            // Validation runs first, then preflight fails
+            expect(mockShouldDisplayWidget).toHaveBeenCalled();
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
             expect(onPreOpen).not.toHaveBeenCalled();
             expect(onOpened).not.toHaveBeenCalled();
@@ -644,11 +685,13 @@ describe("SoluCXWidget error handling from requestWidgetUrl", () => {
         expect(queryByTestId("webview")).toBeNull();
 
         await waitFor(() => {
+            // Validation runs first, then preflight fails
+            expect(mockShouldDisplayWidget).toHaveBeenCalled();
             expect(mockRequestWidgetUrl).toHaveBeenCalledTimes(1);
         });
 
         // Should remain null after failure
         expect(queryByTestId("webview")).toBeNull();
-        expect(mockSetIsWidgetVisible).toHaveBeenCalledWith(false);
+        expect(mockHide).toHaveBeenCalledTimes(1);
     });
 });