react-native-klarna-inapp-sdk 2.4.10 → 2.5.0

package/android/src/test/java/com/klarna/mobile/sdk/reactnative/expresscheckout/KlarnaExpressCheckoutViewManagerTest.java

@@ -0,0 +1,259 @@
+package com.klarna.mobile.sdk.reactnative.expresscheckout;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import android.widget.FrameLayout;
+
+import com.klarna.mobile.sdk.api.KlarnaEnvironment;
+import com.klarna.mobile.sdk.api.KlarnaRegion;
+import com.klarna.mobile.sdk.api.button.KlarnaButtonShape;
+import com.klarna.mobile.sdk.api.button.KlarnaButtonStyle;
+import com.klarna.mobile.sdk.api.button.KlarnaButtonTheme;
+import com.klarna.mobile.sdk.api.expresscheckout.KlarnaExpressCheckoutButton;
+import com.klarna.mobile.sdk.api.expresscheckout.KlarnaExpressCheckoutButtonAuthorizationResponse;
+import com.klarna.mobile.sdk.api.expresscheckout.KlarnaExpressCheckoutError;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mockito;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class KlarnaExpressCheckoutViewManagerTest {
+
+    private KlarnaExpressCheckoutViewManager manager;
+
+    @Before
+    public void setup() {
+        manager = new KlarnaExpressCheckoutViewManager();
+    }
+
+    // region React class name
+
+    @Test
+    public void testReactClassName() {
+        assertEquals("RNKlarnaExpressCheckoutView", manager.getName());
+        assertEquals("RNKlarnaExpressCheckoutView", KlarnaExpressCheckoutViewManager.REACT_CLASS);
+    }
+
+    // endregion
+
+    // region parseTheme
+
+    @Test
+    public void testParseTheme_light() {
+        assertEquals(KlarnaButtonTheme.LIGHT, KlarnaExpressCheckoutViewManager.parseTheme("light"));
+    }
+
+    @Test
+    public void testParseTheme_dark() {
+        assertEquals(KlarnaButtonTheme.DARK, KlarnaExpressCheckoutViewManager.parseTheme("dark"));
+    }
+
+    @Test
+    public void testParseTheme_auto() {
+        assertEquals(KlarnaButtonTheme.AUTO, KlarnaExpressCheckoutViewManager.parseTheme("auto"));
+    }
+
+    @Test
+    public void testParseTheme_null() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseTheme(null));
+    }
+
+    @Test
+    public void testParseTheme_unknown() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseTheme("neon"));
+    }
+
+    // endregion
+
+    // region parseShape
+
+    @Test
+    public void testParseShape_roundedRect() {
+        assertEquals(KlarnaButtonShape.ROUNDED_RECT, KlarnaExpressCheckoutViewManager.parseShape("roundedRect"));
+    }
+
+    @Test
+    public void testParseShape_pill() {
+        assertEquals(KlarnaButtonShape.PILL, KlarnaExpressCheckoutViewManager.parseShape("pill"));
+    }
+
+    @Test
+    public void testParseShape_rectangle() {
+        assertEquals(KlarnaButtonShape.RECTANGLE, KlarnaExpressCheckoutViewManager.parseShape("rectangle"));
+    }
+
+    @Test
+    public void testParseShape_null() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseShape(null));
+    }
+
+    @Test
+    public void testParseShape_unknown() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseShape("circle"));
+    }
+
+    // endregion
+
+    // region parseButtonStyle
+
+    @Test
+    public void testParseButtonStyle_filled() {
+        assertEquals(KlarnaButtonStyle.FILLED, KlarnaExpressCheckoutViewManager.parseButtonStyle("filled"));
+    }
+
+    @Test
+    public void testParseButtonStyle_outlined() {
+        assertEquals(KlarnaButtonStyle.OUTLINED, KlarnaExpressCheckoutViewManager.parseButtonStyle("outlined"));
+    }
+
+    @Test
+    public void testParseButtonStyle_null() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseButtonStyle(null));
+    }
+
+    @Test
+    public void testParseButtonStyle_unknown() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseButtonStyle("gradient"));
+    }
+
+    // endregion
+
+    // region parseEnvironment
+
+    @Test
+    public void testParseEnvironment_playground() {
+        assertEquals(KlarnaEnvironment.PLAYGROUND, KlarnaExpressCheckoutViewManager.parseEnvironment("playground"));
+    }
+
+    @Test
+    public void testParseEnvironment_production() {
+        assertEquals(KlarnaEnvironment.PRODUCTION, KlarnaExpressCheckoutViewManager.parseEnvironment("production"));
+    }
+
+    @Test
+    public void testParseEnvironment_null() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseEnvironment(null));
+    }
+
+    @Test
+    public void testParseEnvironment_unknown() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseEnvironment("staging"));
+    }
+
+    // endregion
+
+    // region parseRegion
+
+    @Test
+    public void testParseRegion_eu() {
+        assertEquals(KlarnaRegion.EU, KlarnaExpressCheckoutViewManager.parseRegion("eu"));
+    }
+
+    @Test
+    public void testParseRegion_na() {
+        assertEquals(KlarnaRegion.NA, KlarnaExpressCheckoutViewManager.parseRegion("na"));
+    }
+
+    @Test
+    public void testParseRegion_oc() {
+        assertEquals(KlarnaRegion.OC, KlarnaExpressCheckoutViewManager.parseRegion("oc"));
+    }
+
+    @Test
+    public void testParseRegion_null() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseRegion(null));
+    }
+
+    @Test
+    public void testParseRegion_unknown() {
+        assertNull(KlarnaExpressCheckoutViewManager.parseRegion("ap"));
+    }
+
+    // endregion
+
+    // region ExpressCheckoutProps defaults
+
+    @Test
+    public void testPropsDefaults() {
+        KlarnaExpressCheckoutViewManager.ExpressCheckoutProps props =
+                new KlarnaExpressCheckoutViewManager.ExpressCheckoutProps();
+
+        assertNull(props.sessionType);
+        assertNull(props.clientId);
+        assertNull(props.clientToken);
+        assertNull(props.locale);
+        assertNull(props.environment);
+        assertNull(props.region);
+        assertNull(props.returnUrl);
+        assertNull(props.theme);
+        assertNull(props.shape);
+        assertNull(props.buttonStyle);
+        assertTrue(props.autoFinalize);
+        assertFalse(props.collectShippingAddress);
+        assertNull(props.sessionData);
+        assertEquals(-1, props.lastSentHeightDp);
+    }
+
+    // endregion
+
+    // region Callback forwarding
+
+    @Test
+    public void testCallbackForwardsOnAuthorized() {
+        FrameLayout container = Mockito.mock(FrameLayout.class);
+        KlarnaExpressCheckoutViewEventSender sender =
+                Mockito.mock(KlarnaExpressCheckoutViewEventSender.class);
+
+        KlarnaExpressCheckoutViewCallback callback =
+                new KlarnaExpressCheckoutViewCallback(container, sender);
+
+        KlarnaExpressCheckoutButton button = Mockito.mock(KlarnaExpressCheckoutButton.class);
+        KlarnaExpressCheckoutButtonAuthorizationResponse response =
+                Mockito.mock(KlarnaExpressCheckoutButtonAuthorizationResponse.class);
+
+        callback.onAuthorized(button, response);
+
+        Mockito.verify(sender, Mockito.times(1))
+                .sendOnAuthorizedEvent(container, response);
+    }
+
+    @Test
+    public void testCallbackForwardsOnError() {
+        FrameLayout container = Mockito.mock(FrameLayout.class);
+        KlarnaExpressCheckoutViewEventSender sender =
+                Mockito.mock(KlarnaExpressCheckoutViewEventSender.class);
+
+        KlarnaExpressCheckoutViewCallback callback =
+                new KlarnaExpressCheckoutViewCallback(container, sender);
+
+        KlarnaExpressCheckoutButton button = Mockito.mock(KlarnaExpressCheckoutButton.class);
+        KlarnaExpressCheckoutError error = Mockito.mock(KlarnaExpressCheckoutError.class);
+
+        callback.onError(button, error);
+
+        Mockito.verify(sender, Mockito.times(1))
+                .sendKlarnaExpressCheckoutError(container, error);
+    }
+
+    // endregion
+
+    // region Event sender configuration
+
+    @Test
+    public void testExportedEventConstants() {
+        assertNotNull(manager.getExportedCustomDirectEventTypeConstants());
+        assertTrue(manager.getExportedCustomDirectEventTypeConstants().containsKey("onAuthorized"));
+        assertTrue(manager.getExportedCustomDirectEventTypeConstants().containsKey("onError"));
+        assertTrue(manager.getExportedCustomDirectEventTypeConstants().containsKey("onResized"));
+    }
+
+    // endregion
+}

package/android/src/test/java/com/klarna/mobile/sdk/reactnative/osm/KlarnaOSMViewEventHandlerTest.java

@@ -0,0 +1,136 @@
+package com.klarna.mobile.sdk.reactnative.osm;
+
+import android.os.SystemClock;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.klarna.mobile.sdk.KlarnaMobileSDKError;
+import com.klarna.mobile.sdk.api.KlarnaProductEvent;
+import com.klarna.mobile.sdk.api.component.KlarnaComponent;
+import com.klarna.mobile.sdk.api.osm.KlarnaOSMView;
+import com.klarna.mobile.sdk.reactnative.common.event.ComponentEvent;
+import com.klarna.mobile.sdk.reactnative.common.ui.WrapperView;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(MockitoJUnitRunner.class)
+public class KlarnaOSMViewEventHandlerTest {
+
+    private MockedStatic<UIManagerHelper> mockedStaticUiManagerHelper;
+    private MockedStatic<SystemClock> mockedStaticSystemClock;
+    private MockedStatic<Arguments> mockedStaticArguments;
+    private KlarnaOSMViewEventSender eventSender;
+    private KlarnaOSMViewEventHandler eventHandler;
+    private WrapperView<KlarnaOSMView> wrapper;
+    private KlarnaOSMView osmView;
+    private EventDispatcher eventDispatcher;
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void setup() {
+        osmView = Mockito.mock(KlarnaOSMView.class);
+        wrapper = Mockito.mock(WrapperView.class);
+        Mockito.when(wrapper.getView()).thenReturn(osmView);
+
+        ReactContext reactContext = Mockito.mock(ReactContext.class);
+        Mockito.when(wrapper.getContext()).thenReturn(reactContext);
+
+        eventDispatcher = Mockito.mock(EventDispatcher.class);
+        Map<WrapperView<KlarnaOSMView>, EventDispatcher> viewToDispatcher = new HashMap<>();
+        viewToDispatcher.put(wrapper, eventDispatcher);
+
+        mockedStaticUiManagerHelper = Mockito.mockStatic(UIManagerHelper.class);
+        Mockito.when(UIManagerHelper.getEventDispatcherForReactTag(Mockito.any(), Mockito.anyInt()))
+                .thenAnswer(invocation -> eventDispatcher);
+        mockedStaticSystemClock = Mockito.mockStatic(SystemClock.class);
+        mockedStaticArguments = Mockito.mockStatic(Arguments.class);
+        Mockito.when(Arguments.createArray())
+                .thenAnswer(invocation -> new JavaOnlyArray());
+        Mockito.when(Arguments.createMap())
+                .thenAnswer(invocation -> new JavaOnlyMap());
+
+        eventSender = new KlarnaOSMViewEventSender(viewToDispatcher);
+        eventHandler = new KlarnaOSMViewEventHandler(eventSender);
+    }
+
+    @After
+    public void teardown() {
+        mockedStaticUiManagerHelper.close();
+        mockedStaticSystemClock.close();
+        mockedStaticArguments.close();
+    }
+
+    // --- onError with KlarnaOSMView ---
+
+    @Test
+    public void testOnErrorWithOSMView() {
+        KlarnaMobileSDKError error = Mockito.mock(KlarnaMobileSDKError.class);
+        Mockito.when(error.getName()).thenReturn("RenderError");
+        Mockito.when(error.getMessage()).thenReturn("Failed to render OSM");
+        Mockito.when(error.isFatal()).thenReturn(false);
+
+        eventHandler.onError(osmView, error);
+
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    @Test
+    public void testOnErrorWithOSMViewFatal() {
+        KlarnaMobileSDKError error = Mockito.mock(KlarnaMobileSDKError.class);
+        Mockito.when(error.getName()).thenReturn("FatalError");
+        Mockito.when(error.getMessage()).thenReturn("Fatal SDK error");
+        Mockito.when(error.isFatal()).thenReturn(true);
+
+        eventHandler.onError(osmView, error);
+
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    // --- onError with non-OSM component ---
+
+    @Test
+    public void testOnErrorWithNonOSMComponent() {
+        KlarnaComponent nonOSMComponent = Mockito.mock(KlarnaComponent.class);
+        KlarnaMobileSDKError error = Mockito.mock(KlarnaMobileSDKError.class);
+
+        eventHandler.onError(nonOSMComponent, error);
+
+        // Should not dispatch any event for non-OSM components
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+
+    // --- onEvent (no-op) ---
+
+    @Test
+    public void testOnEventIsNoOp() {
+        KlarnaProductEvent productEvent = Mockito.mock(KlarnaProductEvent.class);
+
+        eventHandler.onEvent(osmView, productEvent);
+
+        // onEvent should be a no-op for OSM
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+
+    @Test
+    public void testOnEventWithNonOSMComponent() {
+        KlarnaComponent nonOSMComponent = Mockito.mock(KlarnaComponent.class);
+        KlarnaProductEvent productEvent = Mockito.mock(KlarnaProductEvent.class);
+
+        eventHandler.onEvent(nonOSMComponent, productEvent);
+
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+}

package/android/src/test/java/com/klarna/mobile/sdk/reactnative/osm/KlarnaOSMViewEventSenderTest.java

@@ -0,0 +1,184 @@
+package com.klarna.mobile.sdk.reactnative.osm;
+
+import android.os.SystemClock;
+import android.view.View;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIManagerHelper;
+import com.facebook.react.uimanager.events.EventDispatcher;
+import com.klarna.mobile.sdk.KlarnaMobileSDKError;
+import com.klarna.mobile.sdk.api.osm.KlarnaOSMView;
+import com.klarna.mobile.sdk.reactnative.common.event.ComponentEvent;
+import com.klarna.mobile.sdk.reactnative.common.ui.WrapperView;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(MockitoJUnitRunner.class)
+public class KlarnaOSMViewEventSenderTest {
+
+    private MockedStatic<UIManagerHelper> mockedStaticUiManagerHelper;
+    private MockedStatic<SystemClock> mockedStaticSystemClock;
+    private MockedStatic<Arguments> mockedStaticArguments;
+    private KlarnaOSMViewEventSender eventSender;
+    private WrapperView<KlarnaOSMView> wrapper;
+    private KlarnaOSMView osmView;
+    private EventDispatcher eventDispatcher;
+    private Map<WrapperView<KlarnaOSMView>, EventDispatcher> viewToDispatcher;
+
+    @SuppressWarnings("unchecked")
+    @Before
+    public void setup() {
+        osmView = Mockito.mock(KlarnaOSMView.class);
+        wrapper = Mockito.mock(WrapperView.class);
+        Mockito.when(wrapper.getView()).thenReturn(osmView);
+
+        ReactContext reactContext = Mockito.mock(ReactContext.class);
+        Mockito.when(wrapper.getContext()).thenReturn(reactContext);
+
+        eventDispatcher = Mockito.mock(EventDispatcher.class);
+        viewToDispatcher = new HashMap<>();
+        viewToDispatcher.put(wrapper, eventDispatcher);
+
+        eventSender = new KlarnaOSMViewEventSender(viewToDispatcher);
+
+        mockedStaticUiManagerHelper = Mockito.mockStatic(UIManagerHelper.class);
+        Mockito.when(UIManagerHelper.getEventDispatcherForReactTag(Mockito.any(), Mockito.anyInt()))
+                .thenAnswer(invocation -> eventDispatcher);
+        mockedStaticSystemClock = Mockito.mockStatic(SystemClock.class);
+        mockedStaticArguments = Mockito.mockStatic(Arguments.class);
+        Mockito.when(Arguments.createArray())
+                .thenAnswer(invocation -> new JavaOnlyArray());
+        Mockito.when(Arguments.createMap())
+                .thenAnswer(invocation -> new JavaOnlyMap());
+    }
+
+    @After
+    public void teardown() {
+        mockedStaticUiManagerHelper.close();
+        mockedStaticSystemClock.close();
+        mockedStaticArguments.close();
+    }
+
+    // --- getCallbackEventNames ---
+
+    @Test
+    public void testCallbackEventNames() {
+        Collection<String> names = eventSender.getCallbackEventNames();
+        Assert.assertEquals(3, names.size());
+        Assert.assertTrue(names.contains("onError"));
+        Assert.assertTrue(names.contains("onResized"));
+        Assert.assertTrue(names.contains("onOSMViewReady"));
+    }
+
+    // --- getExportedCustomDirectEventTypeConstants ---
+
+    @Test
+    public void testExportedCustomDirectEventTypeConstants() {
+        Map<String, Object> constants = eventSender.getExportedCustomDirectEventTypeConstants();
+        Assert.assertEquals(3, constants.size());
+        Assert.assertTrue(constants.containsKey("onError"));
+        Assert.assertTrue(constants.containsKey("onResized"));
+        Assert.assertTrue(constants.containsKey("onOSMViewReady"));
+
+        for (String key : constants.keySet()) {
+            @SuppressWarnings("unchecked")
+            Map<String, String> value = (Map<String, String>) constants.get(key);
+            Assert.assertNotNull(value);
+            Assert.assertEquals(key, value.get("registrationName"));
+        }
+    }
+
+    // --- sendError ---
+
+    @Test
+    public void testSendError() {
+        eventSender.sendError(osmView, "TestError", "Test message", false);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    @Test
+    public void testSendErrorFatal() {
+        eventSender.sendError(osmView, "FatalError", "Fatal message", true);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    // --- sendKlarnaMobileSDKError ---
+
+    @Test
+    public void testSendKlarnaMobileSDKError() {
+        KlarnaMobileSDKError error = Mockito.mock(KlarnaMobileSDKError.class);
+        Mockito.when(error.getName()).thenReturn("SDKError");
+        Mockito.when(error.getMessage()).thenReturn("SDK error message");
+        Mockito.when(error.isFatal()).thenReturn(true);
+
+        eventSender.sendKlarnaMobileSDKError(osmView, error);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    // --- sendOnResizedEvent ---
+
+    @Test
+    public void testSendOnResizedEvent() {
+        eventSender.sendOnResizedEvent(osmView, 150);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    @Test
+    public void testSendOnResizedEventZeroHeight() {
+        eventSender.sendOnResizedEvent(osmView, 0);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    // --- sendOnOSMViewReadyEvent ---
+
+    @Test
+    public void testSendOnOSMViewReadyEvent() {
+        eventSender.sendOnOSMViewReadyEvent(osmView);
+        Mockito.verify(eventDispatcher).dispatchEvent(Mockito.any(ComponentEvent.class));
+    }
+
+    // --- null view handling ---
+
+    @Test
+    public void testSendErrorNullView() {
+        eventSender.sendError(null, "TestError", "Test message", false);
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+
+    @Test
+    public void testSendOnResizedEventNullView() {
+        eventSender.sendOnResizedEvent(null, 100);
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+
+    @Test
+    public void testSendOnOSMViewReadyEventNullView() {
+        eventSender.sendOnOSMViewReadyEvent(null);
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+
+    // --- view not in dispatcher map ---
+
+    @Test
+    public void testSendErrorUnknownView() {
+        KlarnaOSMView unknownView = Mockito.mock(KlarnaOSMView.class);
+        eventSender.sendError(unknownView, "TestError", "Test message", false);
+        Mockito.verify(eventDispatcher, Mockito.never()).dispatchEvent(Mockito.any());
+    }
+}