@blueconic/blueconic-react-native 3.2.3 → 4.0.0

package/android/src/main/java/com/blueconic/reactnative/BlueConicClientPackage.java

@@ -10,6 +10,7 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.bridge.JavaScriptModule;
+
 public class BlueConicClientPackage implements ReactPackage {
 
     @Override

package/android/src/main/java/com/blueconic/reactnative/BlueConicInteraction.java

@@ -5,8 +5,8 @@ import java.util.HashMap;
 import java.util.Map;
 
 import com.blueconic.BlueConicClient;
-import com.blueconic.BlueConicClient.InteractionContext;
-import com.blueconic.BlueConicClient.Plugin;
+import com.blueconic.InteractionContext;
+import com.blueconic.Plugin;
 
 /**
  * The BlueConicInteraction class is a custom BlueConic plugin that receives parameters from the BlueConic backend
@@ -21,7 +21,8 @@ public class BlueConicInteraction implements Plugin {
     /**
      * Called by the BlueConic SDK for Android when a dialogue of this type is configured to be present on the current
      * screen.
-     * @param client the BlueConicClient
+     *
+     * @param client  the BlueConicClient
      * @param context the InteractionContext of the interaction plugin
      */
     @Override
@@ -51,7 +52,7 @@ public class BlueConicInteraction implements Plugin {
 
         this.properties = properties;
 
-        if (this.properties != null && interactionId != null) {
+        if (interactionId != null) {
             BlueConicClientModule.publishDialogueEvent(this.properties, "onBlueConicPluginLoad");
         }
     }

package/android/src/test/java/com/blueconic/reactnative/BlueConicTests.kt

@@ -0,0 +1,649 @@
+package com.blueconic.reactnative
+
+import android.app.Activity
+import android.os.Handler
+import android.os.Looper
+import android.os.SystemClock
+import com.blueconic.BlueConicClient
+import com.blueconic.Segment
+import com.blueconic.impl.BlueConicClientImpl
+import com.blueconic.reactnative.utils.MockCallback
+import com.blueconic.reactnative.utils.MockPromise
+import com.blueconic.reactnative.utils.MockWritableArray
+import com.blueconic.reactnative.utils.MockWritableMap
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import io.mockk.MockKAnnotations
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.verify
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import java.util.Date
+
+
+class BlueConicClientModuleTests {
+    @MockK
+    lateinit var reactContext: ReactApplicationContext
+    @MockK
+    lateinit var blueConicClient: BlueConicClientImpl
+
+    private lateinit var module: BlueConicClientModule
+
+    @Before
+    fun setUp() {
+        MockKAnnotations.init(this, relaxed = true)
+
+        mockkStatic(Looper::class)
+        val mockLooper = mockk<Looper>(relaxed = true)
+        every { Looper.getMainLooper() } returns mockLooper
+
+        val mockHandler = mockk<Handler>(relaxed = true)
+
+        mockkStatic(SystemClock::class)
+        every { SystemClock.uptimeMillis() } returns 123456L
+
+        module = object : BlueConicClientModule(reactContext) {
+            override fun getBlueConicClientInstance(): BlueConicClient {
+                return blueConicClient
+            }
+            override fun getHandler(): Handler {
+                return mockHandler
+            }
+            override fun getWritableArray(): WritableArray {
+                return MockWritableArray()
+            }
+            override fun getWritableMap(): WritableMap {
+                return MockWritableMap()
+            }
+        }
+    }
+
+    @Test
+    fun `getProfileId should resolve with profile ID`() {
+        // Given
+        val promise = mockk<Promise>(relaxed = true)
+        val expectedProfileId = "testProfileId"
+
+        every { blueConicClient.profileId } returns expectedProfileId
+
+        // When
+        module.getProfileIdAsync(promise)
+
+        // Then
+        verify { promise.resolve(expectedProfileId) }
+    }
+
+    @Test
+    fun `getProfileIdWithCallback should invoke callback with profile ID`() {
+        // Given
+        val callback = mockk<Callback>(relaxed = true)
+        val expectedProfileId = "testProfileId"
+        every { blueConicClient.profileId } returns expectedProfileId
+
+        // When
+        module.getProfileIdWithCallback(callback)
+
+        // Then
+        verify { callback.invoke(expectedProfileId) }
+    }
+
+    @Test
+    fun `getProfileValue should resolve promise with value`() {
+        // Given
+        val property = "testProperty"
+        val value = "testValue"
+        every { blueConicClient.getProfileValues(property) } returns listOf(value)
+        val expectedValue = MockWritableArray().apply { pushString(value) }
+        // When
+        module.getProfileValuesAsync(property, object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getProfileValue should invoke callback with value`() {
+        // Given
+        val property = "testProperty"
+        val value = "testValue"
+        every { blueConicClient.getProfileValue(property) } returns value
+        val expectedValue = MockWritableArray().apply { pushString(value) }
+        // When
+        module.getProfileValueWithCallback(property, object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                val result = args[0] as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+
+    @Test
+    fun `getProfileValues should resolve promise with value`() {
+        // Given
+        val property = "testProperty"
+        val value = listOf("testValue1", "testValue2")
+        every { blueConicClient.getProfileValues(property) } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getProfileValuesAsync(property, object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+                assertEquals(result.toArrayList()[1], expectedValue.toArrayList()[1])
+            }
+        })
+    }
+
+    @Test
+    fun `getProfileValues should invoke callback with value`() {
+        // Given
+        val property = "testProperty"
+        val value = listOf("testValue1", "testValue2")
+        every { blueConicClient.getProfileValues(property) } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getProfileValuesWithCallback(property, object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                val result = args[0] as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+                assertEquals(result.toArrayList()[1], expectedValue.toArrayList()[1])
+            }
+        })
+    }
+
+    @Test
+    fun `getAllProfilePropertiesAsync should resolve promise with values`() {
+        // Given
+        val propertyNames = listOf("testProperty1", "testProperty2")
+        val propertyValue = listOf("testValue1", "testValue2")
+        every { blueConicClient.profilePropertyNames } returns propertyNames
+        every { blueConicClient.getProfileValues(propertyNames[0]) } returns listOf(propertyValue[0])
+        every { blueConicClient.getProfileValues(propertyNames[1]) } returns listOf(propertyValue[1])
+        val expectedValue = MockWritableArray()
+        for (name in propertyNames) {
+            val valuesMap = MockWritableMap().apply {
+                putString("id", name)
+                putString("value", propertyValue[propertyNames.indexOf(name)])
+            }
+            expectedValue.pushMap(valuesMap)
+        }
+        // When
+        module.getAllProfilePropertiesAsync(object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                val test1 = result.toArrayList()[0] as MockWritableMap
+                val test2 = result.toArrayList()[1] as MockWritableMap
+                assertEquals(test1.getString("id"), propertyNames[0])
+                assertEquals(test1.getString("value"), propertyValue[0])
+                assertEquals(test2.getString("id"), propertyNames[1])
+                assertEquals(test2.getString("value"), propertyValue[1])
+            }
+        })
+    }
+
+    @Test
+    fun `getPrivacyLegislation should resolve promise with value`() {
+        // Given
+        val value = "GDPR"
+        every { blueConicClient.privacyLegislation } returns value
+        val expectedValue = MockWritableArray().apply { pushString(value) }
+        // When
+        module.getPrivacyLegislationAsync(object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getPrivacyLegislation should invoke callback with value`() {
+        // Given
+        val value = "GDPR"
+        every { blueConicClient.privacyLegislation } returns value
+        val expectedValue = MockWritableArray().apply { pushString(value) }
+        // When
+        module.getPrivacyLegislationWithCallback(object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                val result = args[0] as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getConsentedObjectives should resolve promise with value`() {
+        // Given
+        val value = listOf("tracking")
+        every { blueConicClient.consentedObjectives } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getConsentedObjectivesAsync(object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getConsentedObjectives should invoke callback with value`() {
+        // Given
+        val value = listOf("tracking")
+        every { blueConicClient.consentedObjectives } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getConsentedObjectivesWithCallback(object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                val result = args[0] as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getRefusedObjectives should resolve promise with value`() {
+        // Given
+        val value = listOf("analytics")
+        every { blueConicClient.refusedObjectives } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getRefusedObjectivesAsync(object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `getRefusedObjectives should invoke callback with value`() {
+        // Given
+        val value = listOf("analytics")
+        every { blueConicClient.refusedObjectives } returns value
+        val expectedValue = MockWritableArray().apply { pushArray(module.fromList(value)) }
+        // When
+        module.getRefusedObjectivesWithCallback(object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                val result = args[0] as MockWritableArray
+                assertEquals(result.toArrayList()[0], expectedValue.toArrayList()[0])
+            }
+        })
+    }
+
+    @Test
+    fun `setLocale should set locale`() {
+        // Given
+        val locale = "en_US"
+        // When
+        module.setLocale(locale)
+        // Then
+        verify { blueConicClient.setLocale(locale) }
+    }
+
+    @Test
+    fun `getSegments should resolve promise with values`() {
+        // Given
+        val segments = mutableListOf<Segment>(object : Segment {
+            override val id: String = "segment1"
+            override val name: String = "NL"
+        })
+        every { blueConicClient.segments } returns segments
+        val expectedValue = MockWritableArray()
+        for (segment in segments) {
+            val valuesMap = MockWritableMap().apply {
+                putString("id", segment.id)
+                putString("name", segment.name)
+            }
+            expectedValue.pushMap(valuesMap)
+        }
+        // When
+        module.getSegments(object : MockPromise() {
+            override fun resolve(values: Any?) {
+                //Then
+                val result = values as MockWritableArray
+                val test1 = result.toArrayList()[0] as MockWritableMap
+                assertEquals(test1.getString("id"), segments[0].id)
+                assertEquals(test1.getString("name"), segments[0].name)
+            }
+        })
+    }
+
+    @Test
+    fun `getSegments should invoke callback with values`() {
+        // Given
+        val segments = mutableListOf<Segment>(object : Segment {
+            override val id: String
+                get() = "segment1"
+            override val name: String
+                get() = "NL"
+        })
+        every { blueConicClient.segments } returns segments
+        val expectedValue = MockWritableArray()
+        for (segment in segments) {
+            val valuesMap = MockWritableMap().apply {
+                putString("id", segment.id)
+                putString("name", segment.name)
+            }
+            expectedValue.pushMap(valuesMap)
+        }
+        // When
+        module.getSegmentsWithCallback(object : MockCallback() {
+            override fun invoke(vararg args: Any?) {
+                //Then
+                val result = args[0] as MockWritableArray
+                val test1 = result.toArrayList()[0] as MockWritableMap
+                assertEquals(test1.getString("id"), segments[0].id)
+                assertEquals(test1.getString("name"), segments[0].name)
+            }
+        })
+    }
+
+    @Test
+    fun `addProfileValue should add value to profile`() {
+        // Given
+        val property = "testProperty"
+        val value = "testValue"
+        // When
+        module.addProfileValue(property, value)
+        // Then
+        verify { blueConicClient.addProfileValue(property, value) }
+    }
+
+    @Test
+    fun `addProfileValues should add values to profile`() {
+        // Given
+        val property = "testProperty"
+        val value = MockWritableArray().apply { pushString("testValue") }
+        // When
+        module.addProfileValues(property, value)
+        // Then
+        verify { blueConicClient.addProfileValues(property, any()) }
+    }
+
+    @Test
+    fun `setProfileValue should add value to profile`() {
+        // Given
+        val property = "testProperty"
+        val value = "testValue"
+        // When
+        module.setProfileValue(property, value)
+        // Then
+        verify { blueConicClient.setProfileValue(property, value) }
+    }
+
+    @Test
+    fun `setProfileValues should set values to profile`() {
+        // Given
+        val property = "testProperty"
+        val value = MockWritableArray().apply { pushString("testValue") }
+        // When
+        module.setProfileValues(property, value)
+        // Then
+        verify { blueConicClient.setProfileValues(property, any()) }
+    }
+
+    @Test
+    fun `incrementProfileValue should increment value to profile`() {
+        // Given
+        val property = "testProperty"
+        val value = "testValue"
+        // When
+        module.incrementProfileValue(property, value)
+        // Then
+        verify { blueConicClient.incrementProfileValue(property, value) }
+    }
+
+    @Test
+    fun `createEvent should send an event to platform`() {
+        // Given
+        val event = "testEvent"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        // When
+        module.createEvent(event, properties)
+        // Then
+        verify { blueConicClient.createEvent(event, any(), any(), any()) }
+    }
+
+    @Test
+    fun `createEventAsync should send an event to platform and resolve promise`() {
+        // Given
+        val event = "testEvent"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        // When
+        module.createEventAsync(event, properties, MockPromise())
+        // Then
+        verify { blueConicClient.createEvent(event, any(), any(), any()) }
+    }
+
+    @Test
+    fun `createEventWithCallback should send an event to platform and invoke callback`() {
+        // Given
+        val event = "testEvent"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        // When
+        module.createEventWithCallback(event, properties, MockCallback())
+        // Then
+        verify { blueConicClient.createEvent(event, any(), any(), any()) }
+    }
+
+    @Test
+    fun `updateProfile should call profile update`() {
+        // When
+        module.updateProfile()
+        // Then
+        verify { blueConicClient.updateProfile() }
+    }
+
+    @Test
+    fun `updateProfileAsync should call profile update and resolve promise`() {
+        // When
+        module.updateProfileAsync(MockPromise())
+        // Then
+        verify { blueConicClient.updateProfile(any()) }
+    }
+
+    @Test
+    fun `updateProfileWithCallback should call profile update and invoke callback`() {
+        // When
+        module.updateProfileWithCallback(MockCallback())
+        // Then
+        verify { blueConicClient.updateProfile(any()) }
+    }
+
+    @Test
+    fun `createPageViewEvent should send a PAGEVIEW event to platform`() {
+        // Given
+        val screen = "screenName"
+        // When
+        module.createPageViewEvent(screen, MockWritableMap())
+        // Then
+        verify { blueConicClient.createPageViewEvent(screen, any<Activity>(), any<HashMap<String, String>>(), any()) }
+    }
+
+    @Test
+    fun `createPageViewEventAsync should send a PAGEVIEW event to platform and resolve promise`() {
+        // Given
+        val screen = "screenName"
+        // When
+        module.createPageViewEventAsync(screen, MockWritableMap(), MockPromise())
+        // Then
+        verify { blueConicClient.createPageViewEvent(screen, any<Activity>(), any<HashMap<String, String>>(), any()) }
+    }
+
+    @Test
+    fun `createPageViewEventWithCallback should send a PAGEVIEW event to platform and invoke callback`() {
+        // Given
+        val screen = "screenName"
+        // When
+        module.createPageViewEventWithCallback(screen, MockWritableMap(), MockCallback())
+        // Then
+        verify { blueConicClient.createPageViewEvent(screen, any<Activity>(), any<HashMap<String, String>>(), any()) }
+    }
+
+    @Test
+    fun `createTimelineEvent should send a timeline event to platform`() {
+        // Given
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEvent(timelineEventType, dateTime.toDouble(), properties)
+        // Then
+        verify { blueConicClient.createTimelineEvent(timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), null) }
+    }
+
+    @Test
+    fun `createTimelineEventAsync should send a timeline event to platform and resolve promise`() {
+        // Given
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEventAsync(timelineEventType, dateTime.toDouble(), properties, MockPromise())
+        // Then
+        verify { blueConicClient.createTimelineEvent(timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), any()) }
+    }
+
+    @Test
+    fun `createTimelineEventWithCallback should send a timeline event to platform and invoke callback`() {
+        // Given
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEventWithCallback(timelineEventType, dateTime.toDouble(), properties, MockCallback())
+        // Then
+        verify { blueConicClient.createTimelineEvent(timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), any()) }
+    }
+
+    @Test
+    fun `createTimelineEventById should send a timeline event to platform`() {
+        // Given
+        val timelineId = "id"
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEventById(timelineId, timelineEventType, dateTime.toDouble(), properties)
+        // Then
+        verify { blueConicClient.createTimelineEventById(timelineId, timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), null) }
+    }
+
+    @Test
+    fun `createTimelineEventByIdAsync should send a timeline event to platform and resolve promise`() {
+        // Given
+        val timelineId = "id"
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEventByIdAsync(timelineId, timelineEventType, dateTime.toDouble(), properties, MockPromise())
+        // Then
+        verify { blueConicClient.createTimelineEventById(timelineId, timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), any()) }
+    }
+
+    @Test
+    fun `createTimelineEventByIdWithCallback should send a timeline event to platform and invoke callback`() {
+        // Given
+        val timelineId = "id"
+        val timelineEventType = "event"
+        val properties = MockWritableMap().apply { putString("testProperty", "testValue") }
+        val dateTime = Date().time
+        // When
+        module.createTimelineEventByIdWithCallback(timelineId, timelineEventType, dateTime.toDouble(), properties, MockCallback())
+        // Then
+        verify { blueConicClient.createTimelineEventById(timelineId, timelineEventType, Date(dateTime),  any<HashMap<String, Any>>(), any()) }
+    }
+
+    @Test
+    fun `publishClickEvent should send a click event to platform`() {
+        // Given
+        val selector = "selector"
+        // When
+        module.publishClickEvent(selector, null)
+        // Then
+        verify { blueConicClient.eventManager.publishClickEvent(any()) }
+    }
+
+    @Test
+    fun `publishClickEventWithContext should send a click event to platform`() {
+        // Given
+        val selector = "selector"
+        val context = MockWritableArray().apply { pushString("context") }
+        // When
+        module.publishClickEvent(selector, context)
+        // Then
+        verify { blueConicClient.eventManager.publishClickEvent(any(), any()) }
+    }
+
+    @Test
+    fun `publishFormSubmitEvent should send a form submit event to platform`() {
+        // Given
+        val selector = "selector"
+        // When
+        module.publishFormSubmitEvent(selector, null)
+        // Then
+        verify { blueConicClient.eventManager.publishFormSubmitEvent(any()) }
+    }
+
+    @Test
+    fun `publishFormSubmitEventWithContext should send a click event to platform`() {
+        // Given
+        val selector = "selector"
+        val context = MockWritableArray().apply { pushString("context") }
+        // When
+        module.publishFormSubmitEvent(selector, context)
+        // Then
+        verify { blueConicClient.eventManager.publishFormSubmitEvent(any(), any()) }
+    }
+
+    @Test
+    fun `publishUpdateContentEvent should send a update content event to platform`() {
+        // Given
+        val selector = "selector"
+        val value = "value"
+        // When
+        module.publishUpdateContentEvent(selector, value)
+        // Then
+        verify { blueConicClient.eventManager.publishUpdateContentEvent(any(), any()) }
+    }
+
+    @Test
+    fun `publishUpdateValuesEvent should send a update values event to platform`() {
+        // Given
+        val selector = "selector"
+        val value = "value"
+        // When
+        module.publishUpdateContentEvent(selector, value)
+        // Then
+        verify { blueConicClient.eventManager.publishUpdateContentEvent(any(), any()) }
+    }
+
+    @Test
+    fun `publishAdvancedEvent should send a advanced event to platform`() {
+        // Given
+        val selector = "selector"
+        val context = MockWritableArray().apply { pushString("context") }
+        // When
+        module.publishAdvancedEvent(selector, context)
+        // Then
+        verify { blueConicClient.eventManager.publishAdvancedEvent(any(), any()) }
+    }
+}

package/android/src/test/java/com/blueconic/reactnative/utils/MockCallback.kt

@@ -0,0 +1,8 @@
+package com.blueconic.reactnative.utils
+
+import com.facebook.react.bridge.Callback
+
+open class MockCallback : Callback {
+    override fun invoke(vararg args: Any?) {
+    }
+}