fidel-react-native 1.6.3 → 2.0.0

package/android/src/test/java/com/fidelreactlibrary/FidelModuleTests.java

@@ -2,13 +2,17 @@ package com.fidelreactlibrary;
 
 import android.content.Context;
 
+import com.facebook.react.bridge.ReadableMap;
+import com.fidelapi.Fidel;
+import com.fidelapi.entities.abstraction.OnCardVerificationChoiceSelectedObserver;
+import com.fidelapi.entities.abstraction.OnCardVerificationStartedObserver;
+import com.fidelapi.entities.abstraction.OnResultObserver;
 import com.fidelreactlibrary.adapters.abstraction.ConstantsProvider;
-import com.fidelreactlibrary.fakes.CallbackInputSpy;
-import com.fidelreactlibrary.fakes.CallbackSpy;
 import com.fidelreactlibrary.fakes.ConstantsProviderStub;
 import com.fidelreactlibrary.fakes.DataProcessorSpy;
 import com.fidelreactlibrary.fakes.ReactContextMock;
 import com.fidelreactlibrary.fakes.ReadableMapStub;
+import com.fidelreactlibrary.fakes.VerificationConfigurationAdapterStub;
 
 import org.junit.After;
 import org.junit.Before;
@@ -26,47 +30,44 @@ import static org.junit.Assert.*;
 
 @RunWith(AndroidJUnit4.class)
 public class FidelModuleTests {
-    
+
     private FidelModule sut;
-    private DataProcessorSpy optionsAdapterSpy;
-    private DataProcessorSpy setupAdapterSpy;
-    private List<ConstantsProvider> constantsProviderListStub;
-    private CallbackInputSpy callbackInputSpy;
-    
+    private DataProcessorSpy<ReadableMap> setupAdapterSpy = new DataProcessorSpy<>();;
+    private List<ConstantsProvider> constantsProviderListStub = new ArrayList<>();
+    private final OnResultObserver testOnResultObserver = fidelResult -> {};
+    private final OnCardVerificationStartedObserver testOnCardVerificationStartedObserver = consentDetails -> {};
+
+    private final OnCardVerificationChoiceSelectedObserver testOnCardVerificationChoiceSelectedObserver = cardVerificationChoice -> {};
+
     @Before
     public final void setUp() {
         Context context = ApplicationProvider.getApplicationContext();
         ReactContextMock reactContext = new ReactContextMock(context);
-        optionsAdapterSpy = new DataProcessorSpy();
-        setupAdapterSpy = new DataProcessorSpy();
-        constantsProviderListStub = new ArrayList<>();
-        ConstantsProvider constantsProvider = new ConstantsProviderStub("testModuleConstantKey", 345);
-        constantsProviderListStub.add(constantsProvider);
-        callbackInputSpy = new CallbackInputSpy();
         sut = new FidelModule(reactContext,
                 setupAdapterSpy,
-                optionsAdapterSpy,
+                testOnResultObserver,
+                testOnCardVerificationStartedObserver,
+                testOnCardVerificationChoiceSelectedObserver,
                 constantsProviderListStub,
-                callbackInputSpy);
+                new VerificationConfigurationAdapterStub()
+        );
     }
-    
+
     @After
     public final void tearDown() {
         sut = null;
-        optionsAdapterSpy = null;
+        setupAdapterSpy = null;
         constantsProviderListStub = null;
     }
 
     @Test
-    public void test_WhenSettingOptions_ForwardThemToOptionsAdapter() {
-        ReadableMapStub fakeMap = new ReadableMapStub();
-        sut.setOptions(fakeMap);
-        assertEquals(optionsAdapterSpy.dataToProcess, fakeMap);
-    }
-
-    @Test
-    public void test_WhenGettingConstants_ReturnConstantsFromFirstConstantsProvider() {
-        assertMapContainsMap(sut.getConstants(), constantsProviderListStub.get(0).getConstants());
+    public void test_WhenGettingConstants_ReturnConstantsFromAllConstantsProvider() {
+        ConstantsProvider constantsProvider1 = new ConstantsProviderStub("testModuleConstantKey", 345);
+        ConstantsProvider constantsProvider2 = new ConstantsProviderStub("testModuleConstantKey2", 348);
+        constantsProviderListStub.add(constantsProvider1);
+        constantsProviderListStub.add(constantsProvider2);
+        assertMapContainsMap(sut.getConstants(), constantsProvider1.getConstants());
+        assertMapContainsMap(sut.getConstants(), constantsProvider2.getConstants());
     }
 
     @Test
@@ -77,9 +78,27 @@ public class FidelModuleTests {
     }
 
     @Test
-    public void test_WhenAskedToOpenForm_SendCallbackToInput() {
-        CallbackSpy callback = new CallbackSpy();
-        sut.openForm(callback);
-        assertEquals(callbackInputSpy.receivedCallback, callback);
+    public void test_WhenAResultAvailableListenerHasBeenAdded_AddTheOnResultObserverToFidel() {
+        sut.addListener("ResultAvailable");
+        assertEquals(testOnResultObserver, Fidel.onResult);
+    }
+
+    @Test
+    public void test_WhenACardVerificationStartedListenerHasBeenAdded_AddTheObserverToFidel() {
+        sut.addListener("CardVerificationStarted");
+        assertEquals(testOnCardVerificationStartedObserver, Fidel.onCardVerificationStarted);
+    }
+
+    @Test
+    public void test_WhenACardVerificationChoiceSelectedListenerHasBeenAdded_AddTheObserverToFidel() {
+        sut.addListener("CardVerificationChoiceSelected");
+        assertEquals(testOnCardVerificationChoiceSelectedObserver, Fidel.onCardVerificationChoiceSelected);
+    }
+
+    @Test
+    public void test_WhenListenersHaveBeenRemoved_AddTheOnResultObserverToFidel() {
+        Fidel.onResult = testOnResultObserver;
+        sut.removeListeners(0);
+        assertNull(Fidel.onResult);
     }
 }

package/android/src/test/java/com/fidelreactlibrary/FidelPackageTests.java

@@ -3,7 +3,6 @@ package com.fidelreactlibrary;
 import android.content.Context;
 
 import com.facebook.react.bridge.NativeModule;
-import com.fidel.sdk.Fidel;
 import com.fidelreactlibrary.fakes.ReactContextMock;
 
 import org.junit.Test;

package/android/src/test/java/com/fidelreactlibrary/{FidelCardSchemesAdapterTests.java → adapters/FidelCardSchemesAdapterTests.java}

@@ -1,9 +1,8 @@
-package com.fidelreactlibrary;
+package com.fidelreactlibrary.adapters;
 
 import com.facebook.react.bridge.JavaOnlyArray;
 import com.facebook.react.bridge.ReadableArray;
-import com.fidel.sdk.Fidel;
-import com.fidelreactlibrary.adapters.FidelCardSchemesAdapter;
+import com.fidelapi.entities.CardScheme;
 
 import org.junit.Test;
 
@@ -13,12 +12,11 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
-import javax.annotation.Nonnull;
-
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.IsCollectionContaining.hasItem;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.junit.Assert.*;
+
+import androidx.annotation.NonNull;
 
 public final class FidelCardSchemesAdapterTests {
     private static final String CARD_SCHEMES_KEY = "CardScheme";
@@ -50,105 +48,111 @@ public final class FidelCardSchemesAdapterTests {
         assertThat(getConstantKeyValues().keySet(), hasItem(MASTERCARD_SCHEME_KEY));
     }
 
+    @Test
+    public void test_ToAdaptVisaCardSchemeWithCorrectJSValue() {
+        assertEquals("visa", sut.jsValue(CardScheme.VISA));
+    }
+
+    @Test
+    public void test_ToAdaptMastercardCardSchemeWithCorrectJSValue() {
+        assertEquals("mastercard", sut.jsValue(CardScheme.MASTERCARD));
+    }
+
+    @Test
+    public void test_ToAdaptAmexCardSchemeWithCorrectJSValue() {
+        assertEquals("americanExpress", sut.jsValue(CardScheme.AMERICAN_EXPRESS));
+    }
+
     //Test to expose correct card scheme values
     @Test
     public void test_ToExposeCorrectVisaValue() {
-        int cardSchemesValue = getConstantKeyValues().get(VISA_CARD_SCHEME_KEY);
-        assertEquals(Fidel.CardScheme.VISA.ordinal(), cardSchemesValue);
+        String cardSchemesValue = getConstantKeyValues().get(VISA_CARD_SCHEME_KEY);
+        assertEquals("visa", cardSchemesValue);
     }
 
     @Test
     public void test_ToExposeCorrectMastercardValue() {
-        int cardSchemesValue = getConstantKeyValues().get(MASTERCARD_SCHEME_KEY);
-        assertEquals(Fidel.CardScheme.MASTERCARD.ordinal(), cardSchemesValue);
+        String cardSchemesValue = getConstantKeyValues().get(MASTERCARD_SCHEME_KEY);
+        assertEquals("mastercard", cardSchemesValue);
     }
 
     @Test
     public void test_ToExposeCorrectAmericanExpressValue() {
-        int cardSchemesValue = getConstantKeyValues().get(AMEX_SCHEME_KEY);
-        assertEquals(Fidel.CardScheme.AMERICAN_EXPRESS.ordinal(), cardSchemesValue);
+        String cardSchemesValue = getConstantKeyValues().get(AMEX_SCHEME_KEY);
+        assertEquals("americanExpress", cardSchemesValue);
     }
 
     //Adaptation tests
     @Test
     public void test_WhenAdaptingArrayWithVisa_ReturnSetWithVisaCardScheme() {
-        assertCorrectConversionWithSchemes(Fidel.CardScheme.VISA);
+        assertCorrectConversionWithSchemes(CardScheme.VISA);
     }
 
     @Test
     public void test_WhenAdaptingArrayWithMastercard_ReturnSetWithMastercardCardScheme() {
-        assertCorrectConversionWithSchemes(Fidel.CardScheme.MASTERCARD);
+        assertCorrectConversionWithSchemes(CardScheme.MASTERCARD);
     }
 
     @Test
     public void test_WhenAdaptingArrayWithAmericanExpress_ReturnSetWithAmericanExpressCardScheme() {
-        assertCorrectConversionWithSchemes(Fidel.CardScheme.AMERICAN_EXPRESS);
+        assertCorrectConversionWithSchemes(CardScheme.AMERICAN_EXPRESS);
     }
 
     @Test
     public void test_WhenAdaptingArrayWith2Schemes_ReturnSetWith2Schemes() {
-        Fidel.CardScheme[] expectedSchemes = {
-                Fidel.CardScheme.VISA,
-                Fidel.CardScheme.AMERICAN_EXPRESS
+        CardScheme[] expectedSchemes = {
+                CardScheme.VISA,
+                CardScheme.AMERICAN_EXPRESS
         };
         assertCorrectConversionWithSchemes(expectedSchemes);
     }
 
     @Test
     public void test_WhenAdaptingArrayWith3Schemes_ReturnSetWith2Schemes() {
-        Fidel.CardScheme[] expectedSchemes = {
-                Fidel.CardScheme.VISA,
-                Fidel.CardScheme.MASTERCARD,
-                Fidel.CardScheme.AMERICAN_EXPRESS
+        CardScheme[] expectedSchemes = {
+                CardScheme.VISA,
+                CardScheme.MASTERCARD,
+                CardScheme.AMERICAN_EXPRESS
         };
         assertCorrectConversionWithSchemes(expectedSchemes);
     }
 
     @Test
     public void test_WhenAdapting0Schemes_ReturnEmptySet() {
-        Set<Fidel.CardScheme> result = sut.cardSchemesWithReadableArray(new JavaOnlyArray());
+        Set<CardScheme> result = sut.cardSchemesWithReadableArray(new JavaOnlyArray());
         assertEquals(0, result.size());
     }
 
     @Test
-    public void test_WhenAdaptingNullSchemes_ReturnNullSet() {
-        assertNull(sut.cardSchemesWithReadableArray(null));
+    public void test_WhenAdaptingNullSchemes_ReturnEmptySet() {
+        assertTrue(sut.cardSchemesWithReadableArray(null).isEmpty());
     }
 
     @Test
     public void test_WhenAdaptingSchemeListWithInvalidValues_IgnoreTheInvalidValues() {
-        float invalidValue = (float) Fidel.CardScheme.values().length + 10;
-        ReadableArray invalidDoubleValues = JavaOnlyArray.of(invalidValue, Fidel.CardScheme.VISA.ordinal());
-        Set<Fidel.CardScheme> result = sut.cardSchemesWithReadableArray(invalidDoubleValues);
-        assertEquals(EnumSet.of(Fidel.CardScheme.VISA), result);
-    }
-
-    @Test
-    public void test_WhenAdaptingSchemeListWithValidFloatValue_AdaptValidFloatValue() {
-        double validDoubleValue = (double) Fidel.CardScheme.MASTERCARD.ordinal();
-        ReadableArray invalidDoubleValues = JavaOnlyArray.of(validDoubleValue, Fidel.CardScheme.VISA.ordinal());
-        Set<Fidel.CardScheme> result = sut.cardSchemesWithReadableArray(invalidDoubleValues);
-        assertEquals(EnumSet.of(Fidel.CardScheme.VISA, Fidel.CardScheme.MASTERCARD), result);
+        float invalidValue = (float) CardScheme.values().length + 10;
+        ReadableArray invalidDoubleValues = JavaOnlyArray.of(invalidValue, sut.jsValue(CardScheme.VISA));
+        Set<CardScheme> result = sut.cardSchemesWithReadableArray(invalidDoubleValues);
+        assertEquals(EnumSet.of(CardScheme.VISA), result);
     }
 
     //Helpers
-    private @Nonnull Map<String, Integer> getConstantKeyValues() {
+    private @NonNull Map<String, String> getConstantKeyValues() {
         Map<String, Object> exposedConstants = sut.getConstants();
-        Map<String, Integer> constantKeyValues = (Map<String, Integer>)exposedConstants.get(CARD_SCHEMES_KEY);
+        Map<String, String> constantKeyValues = (Map<String, String>)exposedConstants.get(CARD_SCHEMES_KEY);
         if (constantKeyValues == null) return new HashMap<>();
         return constantKeyValues;
     }
 
-    private void assertCorrectConversionWithSchemes(Fidel.CardScheme... schemes) {
-        Integer[] schemeOrdinals = new Integer[schemes.length];
+    private void assertCorrectConversionWithSchemes(CardScheme... schemes) {
+        String[] schemeJsNames = new String[schemes.length];
         int schemeNumber = 0;
-        for (Fidel.CardScheme scheme :
-                schemes) {
-            schemeOrdinals[schemeNumber] = scheme.ordinal();
+        for (CardScheme scheme : schemes) {
+            schemeJsNames[schemeNumber] = sut.jsValue(scheme);
             schemeNumber++;
         }
-        ReadableArray arrayStub = JavaOnlyArray.of((Object[]) schemeOrdinals);
-        Set<Fidel.CardScheme> result = sut.cardSchemesWithReadableArray(arrayStub);
+        ReadableArray arrayStub = JavaOnlyArray.of((Object[]) schemeJsNames);
+        Set<CardScheme> result = sut.cardSchemesWithReadableArray(arrayStub);
         assertEquals(EnumSet.copyOf(Arrays.asList(schemes)), result);
     }
 }

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

@@ -0,0 +1,70 @@
+package com.fidelreactlibrary.adapters;
+
+import static com.fidelreactlibrary.adapters.FidelCardVerificationChoiceAdapter.CARD_VERIFICATION_CHOICE;
+import static com.fidelreactlibrary.adapters.FidelCardVerificationChoiceAdapter.CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY;
+import static com.fidelreactlibrary.adapters.FidelCardVerificationChoiceAdapter.CARD_VERIFICATION_ON_THE_SPOT;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.fidelapi.entities.CardVerificationChoice;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FidelCardVerificationChoiceAdapterTest {
+
+    @Test
+    public void test_ShouldExposeConstantsWithCorrectKey() {
+        FidelCardVerificationChoiceAdapter sut = new FidelCardVerificationChoiceAdapter(null);
+
+        Map<String, Object> constants = sut.getConstants();
+
+        assertTrue(constants.containsKey(CARD_VERIFICATION_CHOICE));
+    }
+
+    @Test
+    public void test_ShouldExposeConstantsThatContainDelegatedToThirdParty() {
+        FidelCardVerificationChoiceAdapter sut = new FidelCardVerificationChoiceAdapter(null);
+
+        Map<String, Object> constants = sut.getConstants();
+
+        Map<String, String> verificationChoicesMap = (HashMap) constants.get(CARD_VERIFICATION_CHOICE);
+        assertEquals(CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY, verificationChoicesMap.get(CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY));
+    }
+
+    @Test
+    public void test_ShouldExposeConstantsThatContainOnTheSpot() {
+        FidelCardVerificationChoiceAdapter sut = new FidelCardVerificationChoiceAdapter(null);
+
+        Map<String, Object> constants = sut.getConstants();
+
+        Map<String, String> verificationChoicesMap = (HashMap) constants.get(CARD_VERIFICATION_CHOICE);
+        assertEquals(CARD_VERIFICATION_ON_THE_SPOT, verificationChoicesMap.get(CARD_VERIFICATION_ON_THE_SPOT));
+    }
+
+    @Test
+    public void test_ShouldAdaptOnTheSpotVerificationChoiceCorrectly() {
+        FidelCardVerificationChoiceAdapter sut = new FidelCardVerificationChoiceAdapter(JavaOnlyMap::new);
+
+        ReadableMap map = sut.adapt(CardVerificationChoice.ON_THE_SPOT);
+
+        assertEquals(CARD_VERIFICATION_ON_THE_SPOT, map.getString(CARD_VERIFICATION_CHOICE));
+    }
+
+    @Test
+    public void test_ShouldAdaptDelegatedToThirdPartyCorrectly() {
+        FidelCardVerificationChoiceAdapter sut = new FidelCardVerificationChoiceAdapter(JavaOnlyMap::new);
+
+        ReadableMap map = sut.adapt(CardVerificationChoice.DELEGATED_TO_THIRD_PARTY);
+
+        assertEquals(CARD_VERIFICATION_DELEGATED_TO_THIRD_PARTY, map.getString(CARD_VERIFICATION_CHOICE));
+    }
+
+
+}

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

@@ -0,0 +1,157 @@
+package com.fidelreactlibrary.adapters;
+
+import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.ReadableArray;
+import com.fidelapi.entities.Country;
+import com.fidelreactlibrary.adapters.FidelCountryAdapter;
+import com.fidelreactlibrary.fakes.ReadableArrayStub;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.Assert.*;
+
+public class FidelCountryAdapterTests {
+
+    private static final String COUNTRIES_KEY = "Country";
+    
+    private FidelCountryAdapter sut;
+    
+    @Before
+    public final void setUp() {
+        sut = new FidelCountryAdapter();
+    }
+    
+    @After
+    public final void tearDown() {
+        sut = null;
+    }
+
+    @Test
+    public void test_ToExposeCountryConstants() {
+        Map<String, Object> exposedConstants = sut.getConstants();
+        assertTrue(exposedConstants.containsKey(COUNTRIES_KEY));
+        Map<String, String> countriesMap = (Map<String, String>)exposedConstants.get(COUNTRIES_KEY);
+        assertNotNull(countriesMap);
+        for (Country country : Country.values()) {
+            String countryKey = sut.jsCountryValue(country);
+            assertCorrectCountryValueFor(countryKey, country, countriesMap);
+        }
+    }
+
+    @Test
+    public void test_WhenAskedForAnyCountryJSValue_ItProvidesIt() {
+        for (Country country : Country.values()) {
+            assertNotNull(sut.jsCountryValue(country));
+        }
+    }
+
+    @Test
+    public void test_WhenAskedForCanadaCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("canada", sut.jsCountryValue(Country.CANADA));
+    }
+
+    @Test
+    public void test_WhenAskedForIrelandCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("ireland", sut.jsCountryValue(Country.IRELAND));
+    }
+
+    @Test
+    public void test_WhenAskedForJapanCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("japan", sut.jsCountryValue(Country.JAPAN));
+    }
+
+    @Test
+    public void test_WhenAskedForSwedenCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("sweden", sut.jsCountryValue(Country.SWEDEN));
+    }
+
+    @Test
+    public void test_WhenAskedForNorwayCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("norway", sut.jsCountryValue(Country.NORWAY));
+    }
+
+    @Test
+    public void test_WhenAskedForUnitedArabEmiratesCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("unitedArabEmirates", sut.jsCountryValue(Country.UNITED_ARAB_EMIRATES));
+    }
+
+    @Test
+    public void test_WhenAskedForUnitedKingdomCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("unitedKingdom", sut.jsCountryValue(Country.UNITED_KINGDOM));
+    }
+
+    @Test
+    public void test_WhenAskedForUnitedStatesCountryValue_ItProvidesTheCorrectOne() {
+        assertEquals("unitedStates", sut.jsCountryValue(Country.UNITED_STATES));
+    }
+
+    @Test
+    public void test_WhenCountryOrdinalNumberIsTooHigh_ReturnEmptyCountriesSet() {
+        String[] countriesArrayValues = new String[]{"something unrecognizable"};
+        ReadableArrayStub countriesArrayStub = new ReadableArrayStub(1, countriesArrayValues);
+        assertTrue(sut.parseAllowedCountries(countriesArrayStub).isEmpty());
+    }
+
+    @Test
+    public void test_WhenParsingNullReadableArray_ReturnEmptyCountriesSet() {
+        assertTrue(sut.parseAllowedCountries(null).isEmpty());
+    }
+
+    @Test
+    public void test_WhenParsingEmptyReadableArray_ReturnEmptyCountriesSet() {
+        assertTrue(sut.parseAllowedCountries(new ReadableArrayStub(0, new String[]{})).isEmpty());
+    }
+
+    @Test
+    public void test_WhenCountryJSValuesAreValid_ReturnCorrectCountriesSet() {
+        ReadableArray countriesArrayValues = JavaOnlyArray.of(
+                sut.jsCountryValue(Country.CANADA),
+                sut.jsCountryValue(Country.UNITED_ARAB_EMIRATES),
+                sut.jsCountryValue(Country.UNITED_KINGDOM),
+                sut.jsCountryValue(Country.SWEDEN),
+                sut.jsCountryValue(Country.UNITED_STATES),
+                sut.jsCountryValue(Country.IRELAND),
+                sut.jsCountryValue(Country.JAPAN),
+                sut.jsCountryValue(Country.NORWAY)
+        );
+
+        Set<Country> expectedCountries = EnumSet.of(Country.CANADA, Country.UNITED_ARAB_EMIRATES, Country.UNITED_KINGDOM,
+                Country.SWEDEN, Country.UNITED_STATES, Country.IRELAND, Country.JAPAN, Country.NORWAY);
+        Set<Country> adaptedCountries = sut.parseAllowedCountries(countriesArrayValues);
+
+        assertEquals(countriesArrayValues.size(), adaptedCountries.size());
+        assertEquals(adaptedCountries, expectedCountries);
+    }
+
+    @Test
+    public void test_WhenSomeCountryJSValuesAreInvalid_TheyShouldBeIgnored() {
+        ReadableArray countriesWithSomeInvalidValues = JavaOnlyArray.of(
+                sut.jsCountryValue(Country.CANADA),
+                "something unrecognizable",
+                sut.jsCountryValue(Country.UNITED_KINGDOM),
+                -1,
+                sut.jsCountryValue(Country.UNITED_STATES),
+                sut.jsCountryValue(Country.IRELAND),
+                sut.jsCountryValue(Country.JAPAN));
+
+        Set<Country> expectedCountries = EnumSet.of(Country.CANADA, Country.UNITED_KINGDOM,
+                Country.UNITED_STATES, Country.IRELAND, Country.JAPAN);
+        Set<Country> adaptedCountries = sut.parseAllowedCountries(countriesWithSomeInvalidValues);
+
+        assertEquals(adaptedCountries, expectedCountries);
+    }
+
+    private void assertCorrectCountryValueFor(String key,
+                                              Country countryValue,
+                                              Map<String, String> map) {
+        assertNotEquals(key, "notFound");
+        assertTrue(map.containsKey(key));
+        assertEquals(map.get(key), sut.jsCountryValue(countryValue));
+    }
+}

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

@@ -0,0 +1,54 @@
+package com.fidelreactlibrary.adapters;
+
+import static org.junit.Assert.*;
+
+import com.fidelapi.entities.ProgramType;
+import com.fidelreactlibrary.adapters.FidelProgramTypeAdapter;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class FidelProgramTypeAdapterTests {
+    private final FidelProgramTypeAdapter sut = new FidelProgramTypeAdapter();
+
+    @Test
+    public void test_ToExposeProgramTypeConstants() {
+        Map<String, Object> exposedConstants = sut.getConstants();
+        String expectedProgramTypesConstantsKey = "ProgramType";
+        assertTrue(exposedConstants.containsKey(expectedProgramTypesConstantsKey));
+
+        Map<String, String> programTypesMap = (HashMap<String, String>)exposedConstants.get(expectedProgramTypesConstantsKey);
+        assertNotNull(programTypesMap);
+
+        for (ProgramType programType : ProgramType.values()) {
+            String programTypeKey = sut.keyFor(programType);
+            assertNotEquals(programTypeKey, "notFound");
+            assertTrue(programTypesMap.containsKey(programTypeKey));
+            String programTypeValue = programTypesMap.get(programTypeKey);
+            assertNotNull(programTypeValue);
+            assertEquals(programTypeValue, programType.name());
+        }
+    }
+
+    @Test
+    public void test_WhenReceivingToParseProgramTypeWithNullValue_ShouldReturnTransactionSelectProgramType() {
+        assertEquals(ProgramType.TRANSACTION_SELECT, sut.parseProgramType(null));
+    }
+
+    @Test
+    public void test_WhenReceivingToParseProgramTypeWithUnknownValue_ShouldReturnTransactionSelectProgramType() {
+        assertEquals(ProgramType.TRANSACTION_SELECT, sut.parseProgramType("unknown program type value"));
+    }
+
+    @Test
+    public void test_WhenReceivingToParseProgramTypeWithTransactionSelectValue_ShouldReturnTransactionSelectProgramType() {
+        assertEquals(ProgramType.TRANSACTION_SELECT, sut.parseProgramType(ProgramType.TRANSACTION_SELECT.name()));
+    }
+
+    @Test
+    public void test_WhenReceivingToParseProgramTypeWithTransactionStreamValue_ShouldReturnTransactionStreamProgramType() {
+        assertEquals(ProgramType.TRANSACTION_STREAM, sut.parseProgramType(ProgramType.TRANSACTION_STREAM.name()));
+    }
+}