fidel-react-native 1.6.3 → 2.0.0

package/android/src/test/java/com/fidelreactlibrary/adapters/FidelVerificationConfigurationAdapterTest.java

@@ -0,0 +1,51 @@
+package com.fidelreactlibrary.adapters;
+
+import com.fidelreactlibrary.fakes.ReadableMapStub;
+import com.fidelapi.entities.CardVerificationConfiguration;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+public class FidelVerificationConfigurationAdapterTest {
+
+    private FidelVerificationConfigurationAdapter sut = new FidelVerificationConfigurationAdapter();
+
+    @Test
+    public void test_ShouldMapEmptyMapCorrectly() {
+        CardVerificationConfiguration expectedConfig = new CardVerificationConfiguration("", "", null);
+
+        CardVerificationConfiguration cardVerificationConfig = sut.adapt(ReadableMapStub.mapWithNoKey());
+
+        assertEquals(expectedConfig, cardVerificationConfig);
+    }
+
+    @Test
+    public void test_ShouldMapNonEmptyValidMapCorrectly() {
+        CardVerificationConfiguration expectedConfig = new CardVerificationConfiguration("123", "456", "4567");
+
+        CardVerificationConfiguration cardVerificationConfig = sut.adapt(ReadableMapStub.cardConfigWithAllValidConfigKeys());
+
+        assertEquals(expectedConfig, cardVerificationConfig);
+    }
+
+    @Test
+    public void test_ShouldMapNullIdCorrectly() {
+        CardVerificationConfiguration cardVerificationConfig = sut.adapt(ReadableMapStub.cardConfigWithAllInValidConfigKeys());
+
+        assertEquals("", cardVerificationConfig.id);
+    }
+
+    @Test
+    public void test_ShouldMapNullConsentIdCorrectly() {
+        CardVerificationConfiguration cardVerificationConfig = sut.adapt(ReadableMapStub.cardConfigWithAllInValidConfigKeys());
+
+        assertEquals("", cardVerificationConfig.consentId);
+    }
+
+    @Test
+    public void test_ShouldMapNullLast4DigitsCorrectly() {
+        CardVerificationConfiguration cardVerificationConfig = sut.adapt(ReadableMapStub.cardConfigWithAllInValidConfigKeys());
+
+        assertNull(cardVerificationConfig.last4Digits);
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/adapters/ResultsAdapterTests.java

@@ -0,0 +1,74 @@
+package com.fidelreactlibrary.adapters;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.fidelapi.entities.FidelError;
+import com.fidelapi.entities.FidelErrorType;
+import com.fidelreactlibrary.adapters.ResultsAdapter;
+import com.fidelreactlibrary.fakes.CardSchemeAdapterStub;
+import com.fidelreactlibrary.fakes.CountryAdapterStub;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+import static org.junit.Assert.*;
+
+import java.util.Map;
+
+//Custom test runner is necessary for being able to use JSONObject
+@RunWith(RobolectricTestRunner.class)
+public class ResultsAdapterTests {
+
+    private final CountryAdapterStub countryAdapterStub = new CountryAdapterStub();
+    private final CardSchemeAdapterStub cardSchemeAdapterStub = new CardSchemeAdapterStub();
+    private ResultsAdapter sut;
+
+    @Before
+    public final void setUp() {
+        sut = new ResultsAdapter(JavaOnlyMap::new, countryAdapterStub, cardSchemeAdapterStub);
+    }
+
+    @After
+    public final void tearDown() {
+        sut = null;
+    }
+
+    @Test
+    public void test_WhenAskedToConvertNullObject_ReturnNull() {
+        assertNull(sut.getAdaptedObjectFor(null));
+    }
+
+    @Test
+    public void test_WhenAskedToConvertDeviceNotSecureObject_ShouldReturnCorrectErrorTypeForJS() {
+        FidelError fidelError = new FidelError(FidelErrorType.DeviceNotSecure.INSTANCE, "some message", 123);
+        assertEquals("deviceNotSecure", sut.getAdaptedObjectFor(fidelError).getString("type"));
+    }
+
+    @Test
+    public void test_WhenAskedToConvertDeviceNotSecureObject_ShouldReturnCorrectErrorMessageForJS() {
+        String testMessage = "some message";
+        FidelError fidelError = new FidelError(FidelErrorType.DeviceNotSecure.INSTANCE, testMessage, 123);
+        assertEquals(testMessage, sut.getAdaptedObjectFor(fidelError).getString("message"));
+    }
+
+    @Test
+    public void test_WhenAskedToConvertDeviceNotSecureObject_ShouldReturnCorrectDateForJS() {
+        long testDate = 123;
+        FidelError fidelError = new FidelError(FidelErrorType.DeviceNotSecure.INSTANCE, "some message", testDate);
+        assertEquals(testDate, sut.getAdaptedObjectFor(fidelError).getDouble("date"), 0.0001);
+    }
+
+    @Test
+    public void test_WhenAskedToGetAllConstantsToExport_ShouldIncludeDeviceNotSecureError() {
+        Map<String, Object> constants = sut.getConstants();
+        Object errorTypeConstants = constants.get("ErrorType");
+        if (!(errorTypeConstants instanceof Map)) {
+            fail("You should get a map of error types here");
+            return;
+        }
+        Map<String, String> errorTypeConstantsMap = (Map<String, String>)errorTypeConstants;
+        assertEquals("deviceNotSecure", errorTypeConstantsMap.get("deviceNotSecure"));
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/{ErrorEventEmitterTests.java → events/BridgeLibraryEventEmitterTests.java}

@@ -1,11 +1,10 @@
-package com.fidelreactlibrary;
+package com.fidelreactlibrary.events;
 
 import android.content.Context;
 
 import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.fidelreactlibrary.events.ErrorEventEmitter;
 import com.fidelreactlibrary.fakes.ReactContextMock;
 
 import org.junit.After;
@@ -19,16 +18,15 @@ import androidx.test.core.app.ApplicationProvider;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(RobolectricTestRunner.class)
-public class ErrorEventEmitterTests {
+public class BridgeLibraryEventEmitterTests {
 
-    private ErrorEventEmitter sut;
+    private BridgeLibraryEventEmitter sut;
     private ReactContextMock reactContext;
 
     @Before
     public final void setUp() {
         Context context = ApplicationProvider.getApplicationContext();
         reactContext = new ReactContextMock(context);
-        sut = new ErrorEventEmitter(reactContext);
     }
 
     @After
@@ -38,6 +36,7 @@ public class ErrorEventEmitterTests {
 
     @Test
     public void test_WhenReceivingWritableData_AskForJSModule() {
+        sut = new BridgeLibraryEventEmitter(reactContext, BridgeLibraryEvent.RESULT_AVAILABLE);
         WritableMap map = new JavaOnlyMap();
         map.putString("testKey", "testValue");
         sut.process(map);
@@ -45,11 +44,23 @@ public class ErrorEventEmitterTests {
     }
 
     @Test
-    public void test_WhenReceivingWritableData_SendEventUsingTheObtainedJSModule() {
+    public void test_WhenReceivingWritableData_SendCorrectResultAvailableEventUsingTheObtainedJSModule() {
+        sut = new BridgeLibraryEventEmitter(reactContext, BridgeLibraryEvent.RESULT_AVAILABLE);
         WritableMap map = new JavaOnlyMap();
         map.putString("testKey", "testValue");
         sut.process(map);
-        assertEquals(reactContext.receivedErrorName, "CardLinkFailed");
+        assertEquals(reactContext.receivedErrorName, BridgeLibraryEvent.RESULT_AVAILABLE.getEventName());
+        assertEquals(reactContext.receivedErrorData, map);
+        assertEquals(reactContext.eventEmitterInvokedMethodName, "emit");
+    }
+
+    @Test
+    public void test_WhenReceivingWritableData_SendCorrectCardVerificationStartedEventUsingTheObtainedJSModule() {
+        sut = new BridgeLibraryEventEmitter(reactContext, BridgeLibraryEvent.CARD_VERIFICATION_STARTED);
+        WritableMap map = new JavaOnlyMap();
+        map.putString("testKey", "testValue");
+        sut.process(map);
+        assertEquals(reactContext.receivedErrorName, BridgeLibraryEvent.CARD_VERIFICATION_STARTED.getEventName());
         assertEquals(reactContext.receivedErrorData, map);
         assertEquals(reactContext.eventEmitterInvokedMethodName, "emit");
     }

package/android/src/test/java/com/fidelreactlibrary/events/BridgeLibraryEventTests.java

@@ -0,0 +1,17 @@
+package com.fidelreactlibrary.events;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BridgeLibraryEventTests {
+    @Test
+    public void test_ResultAvailableEventType_ShouldHaveCorrectEventName() {
+        assertEquals("ResultAvailable", BridgeLibraryEvent.RESULT_AVAILABLE.getEventName());
+    }
+
+    @Test
+    public void test_CardVerificationStartedEventType_ShouldHaveCorrectEventName() {
+        assertEquals("CardVerificationStarted", BridgeLibraryEvent.CARD_VERIFICATION_STARTED.getEventName());
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/events/CardVerificationStartedObserverTests.java

@@ -0,0 +1,49 @@
+package com.fidelreactlibrary.events;
+
+import static org.junit.Assert.assertEquals;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.fidelapi.entities.ConsentDetails;
+import com.fidelreactlibrary.fakes.DataProcessorSpy;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class CardVerificationStartedObserverTests {
+    private DataProcessorSpy<ReadableMap> adaptedConsentDetailsProcessorSpy;
+    private CardVerificationStartedObserver observer;
+
+    @Before
+    public void setup() {
+        adaptedConsentDetailsProcessorSpy = new DataProcessorSpy<>();
+        observer = new CardVerificationStartedObserver(
+                adaptedConsentDetailsProcessorSpy,
+                JavaOnlyMap::new
+        );
+    }
+
+    @Test
+    public void test_WhenCardVerificationStarted_ShouldForwardMapWithCorrectCardID() {
+        String testCardId = "some card ID";
+        ConsentDetails consentDetailsStub = new ConsentDetails(testCardId, "", "");
+        observer.onCardVerificationStarted(consentDetailsStub);
+        assertEquals(testCardId, adaptedConsentDetailsProcessorSpy.dataToProcess.getString("cardId"));
+    }
+
+    @Test
+    public void test_WhenCardVerificationStarted_ShouldForwardMapWithCorrectConsentID() {
+        String testConsentId = "some consent ID";
+        ConsentDetails consentDetailsStub = new ConsentDetails("", testConsentId, "");
+        observer.onCardVerificationStarted(consentDetailsStub);
+        assertEquals(testConsentId, adaptedConsentDetailsProcessorSpy.dataToProcess.getString("consentId"));
+    }
+
+    @Test
+    public void test_WhenCardVerificationStarted_ShouldForwardMapWithCorrectProgramID() {
+        String testProgramId = "some program ID";
+        ConsentDetails consentDetailsStub = new ConsentDetails("", "", testProgramId);
+        observer.onCardVerificationStarted(consentDetailsStub);
+        assertEquals(testProgramId, adaptedConsentDetailsProcessorSpy.dataToProcess.getString("programId"));
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/events/ResultsObserverTests.java

@@ -0,0 +1,38 @@
+package com.fidelreactlibrary.events;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.fidelapi.entities.CardScheme;
+import com.fidelapi.entities.Country;
+import com.fidelapi.entities.EnrollmentResult;
+import com.fidelreactlibrary.events.ResultsObserver;
+import com.fidelreactlibrary.fakes.DataAdapterStub;
+import com.fidelreactlibrary.fakes.DataProcessorSpy;
+
+import org.junit.After;
+import org.junit.Before;
+
+public class ResultsObserverTests {
+
+    private DataAdapterStub<Object, WritableMap> resultAdapterStub = new DataAdapterStub<>();
+    private DataProcessorSpy<ReadableMap> resultHandlerSpy = new DataProcessorSpy<>();
+    private ResultsObserver sut = new ResultsObserver(resultAdapterStub, resultHandlerSpy, JavaOnlyMap::new);
+
+    private static final EnrollmentResult testLinkResult = new EnrollmentResult(
+            "TEST CARD ID", "", "", -1, CardScheme.MASTERCARD,
+            false, 2021,12, Country.CANADA, "444400", "4001", null
+    );
+
+    @Before
+    public final void setUp() {
+        resultAdapterStub.convertedDataToReturn = new JavaOnlyMap();
+    }
+
+    @After
+    public final void tearDown() {
+        sut = null;
+        resultAdapterStub = null;
+        resultHandlerSpy = null;
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/fakes/CardSchemeAdapterStub.java

@@ -1,28 +1,39 @@
 package com.fidelreactlibrary.fakes;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
+import com.fidelapi.entities.CardScheme;
 import com.fidelreactlibrary.adapters.abstraction.CardSchemesAdapter;
 
 import java.util.Map;
 import java.util.Set;
 
-import javax.annotation.Nonnull;
-
 public final class CardSchemeAdapterStub implements CardSchemesAdapter {
 
     public ReadableArray cardSchemesReceived;
-    public Set<Fidel.CardScheme> fakeAdaptedCardSchemesToReturn;
+    public Set<CardScheme> fakeAdaptedCardSchemesToReturn;
+    public boolean askedToAdaptCardSchemes = false;
+    public String jsValueToReturn;
 
+    @NonNull
     @Override
-    public Set<Fidel.CardScheme> cardSchemesWithReadableArray(ReadableArray cardSchemes) {
+    public Set<CardScheme> cardSchemesWithReadableArray(@Nullable ReadableArray cardSchemes) {
+        askedToAdaptCardSchemes = true;
         cardSchemesReceived = cardSchemes;
         return fakeAdaptedCardSchemesToReturn;
     }
 
-    @Nonnull
+    @NonNull
     @Override
     public Map<String, Object> getConstants() {
         return new ConstantsProviderStub("testKeyCardSchemeAdapter", 234).getConstants();
     }
+
+    @NonNull
+    @Override
+    public String jsValue(@NonNull CardScheme cardScheme) {
+        return jsValueToReturn;
+    }
 }

package/android/src/test/java/com/fidelreactlibrary/fakes/ConstantsProviderStub.java

@@ -9,8 +9,8 @@ import javax.annotation.Nonnull;
 
 public final class ConstantsProviderStub implements ConstantsProvider {
 
-    private String key;
-    private Integer value;
+    private final String key;
+    private final Integer value;
 
     public ConstantsProviderStub(String key, Integer value) {
         this.key = key;

package/android/src/test/java/com/fidelreactlibrary/fakes/CountryAdapterStub.java

@@ -1,32 +1,47 @@
 package com.fidelreactlibrary.fakes;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
-import com.fidel.sdk.Fidel.Country;
+import com.fidelapi.entities.Country;
 import com.fidelreactlibrary.adapters.abstraction.CountryAdapter;
 
 import java.util.Map;
-
-import javax.annotation.Nonnull;
+import java.util.Set;
 
 public final class CountryAdapterStub implements CountryAdapter {
 
-    public Country[] countriesToReturn;
+    public Set<Country> countriesToReturn;
+    public boolean askedToParseAllowedCountries = false;
+    public String jsValueToReturn;
+    public Country countryForJSValueToReturn;
+    public String countryJSValueReceived;
 
-    @Nonnull
+    @NonNull
     @Override
     public Map<String, Object> getConstants() {
         ConstantsProviderStub constantsProviderStub = new ConstantsProviderStub("testKey", 2);
         return constantsProviderStub.getConstants();
     }
 
+    @Nullable
+    @Override
+    public Country countryWithJSValue(String jsValue) {
+        countryJSValueReceived = jsValue;
+        return countryForJSValueToReturn;
+    }
+
+    @NonNull
     @Override
-    public Country countryWithInteger(int integer) {
-        return null;
+    public Set<Country> parseAllowedCountries(ReadableArray inputArray) {
+        askedToParseAllowedCountries = true;
+        return countriesToReturn;
     }
 
+    @NonNull
     @Override
-    public Country[] parseAllowedCountries(ReadableArray inputArray) {
-        return new Fidel.Country[]{Fidel.Country.UNITED_KINGDOM, Fidel.Country.JAPAN, Fidel.Country.CANADA};
+    public String jsCountryValue(@NonNull Country country) {
+        return jsValueToReturn;
     }
 }

package/android/src/test/java/com/fidelreactlibrary/fakes/{DataConverterStub.java → DataAdapterStub.java}

@@ -1,14 +1,14 @@
 package com.fidelreactlibrary.fakes;
 
-import com.fidelreactlibrary.adapters.abstraction.DataConverter;
+import com.fidelreactlibrary.adapters.abstraction.DataAdapter;
 
-public final class DataConverterStub<D, C> implements DataConverter<D, C> {
+public final class DataAdapterStub<D, C> implements DataAdapter<D, C> {
 
     public D dataReceived;
     public C convertedDataToReturn;
 
     @Override
-    public C getConvertedDataFor(D data) {
+    public C getAdaptedObjectFor(D data) {
         dataReceived = data;
         return convertedDataToReturn;
     }

package/android/src/test/java/com/fidelreactlibrary/fakes/ProgramTypeAdapterStub.java

@@ -0,0 +1,31 @@
+package com.fidelreactlibrary.fakes;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.fidelapi.entities.ProgramType;
+import com.fidelreactlibrary.adapters.abstraction.ProgramTypeAdapter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ProgramTypeAdapterStub implements ProgramTypeAdapter {
+
+    public ProgramType programTypeToReturn;
+    public String receivedProgramTypeString;
+
+    @NonNull
+    @Override
+    public ProgramType parseProgramType(@Nullable String programType) {
+        receivedProgramTypeString = programType;
+        return programTypeToReturn;
+    }
+
+    @NonNull
+    @Override
+    public Map<String, Object> getConstants() {
+        HashMap<String, Object> hashmapToReturn = new HashMap<>();
+        hashmapToReturn.put("some key", "some value");
+        return hashmapToReturn;
+    }
+}

package/android/src/test/java/com/fidelreactlibrary/fakes/ReactContextMock.java

@@ -37,7 +37,7 @@ public final class ReactContextMock extends ReactApplicationContext {
     private class JSModuleSpyInvocationHandler implements InvocationHandler {
 
         @Override
-        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
+        public Object invoke(Object o, Method method, Object[] objects) {
             receivedErrorName = (String) objects[0];
             receivedErrorData = (WritableMap) objects[1];
             eventEmitterInvokedMethodName = method.getName();

package/android/src/test/java/com/fidelreactlibrary/fakes/ReadableArrayStub.java

@@ -0,0 +1,82 @@
+package com.fidelreactlibrary.fakes;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Dynamic;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+
+import java.util.ArrayList;
+
+public class ReadableArrayStub implements ReadableArray {
+
+    private final int size;
+    private final String[] values;
+
+    public ReadableArrayStub(int size, String[] values) {
+        this.size = size;
+        this.values = values;
+    }
+
+    @Override
+    public int size() {
+        return this.size;
+    }
+
+    @Override
+    public boolean isNull(int index) {
+        return false;
+    }
+
+    @Override
+    public boolean getBoolean(int index) {
+        return false;
+    }
+
+    @Override
+    public double getDouble(int index) {
+        return 0;
+    }
+
+    @Override
+    public int getInt(int index) {
+        return -1;
+    }
+
+    @NonNull
+    @Override
+    public String getString(int index) {
+        return values[index];
+    }
+
+    @NonNull
+    @Override
+    public ReadableArray getArray(int index) {
+        return null;
+    }
+
+    @NonNull
+    @Override
+    public ReadableMap getMap(int index) {
+        return null;
+    }
+
+    @NonNull
+    @Override
+    public Dynamic getDynamic(int index) {
+        return null;
+    }
+
+    @NonNull
+    @Override
+    public ReadableType getType(int index) {
+        return null;
+    }
+
+    @NonNull
+    @Override
+    public ArrayList<Object> toArrayList() {
+        return null;
+    }
+}