chore: bump io.mockk:mockk from 1.13.4 to 1.14.6

.github/dependabot.yml

@@ -2,10 +2,18 @@ version: 2
 updates:
 - package-ecosystem: gradle
   directory: "/"
-  target-branch: "development"
   labels: [ "dependabot" ]
   schedule:
     interval: "daily"
   open-pull-requests-limit: 10
   commit-message:
     prefix: "chore"
+- package-ecosystem: github-actions
+  directory: /
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 4
+  labels:
+    - dependabot
+  commit-message:
+    prefix: "chore"

build.gradle

@@ -68,11 +68,11 @@ dependencies {
     implementation 'androidx.annotation:annotation:1.5.0'
     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'
     implementation 'androidx.compose.runtime:runtime'
-    api 'com.rokt:roktsdk:4.11.2'
+    api 'com.rokt:roktsdk:4.12.1'
 
     testImplementation  files('libs/java-json.jar')
     testImplementation 'com.squareup.assertj:assertj-android:1.2.0'
-    testImplementation ("io.mockk:mockk:1.13.4")
+    testImplementation ("io.mockk:mockk:1.14.6")
     testImplementation 'org.jetbrains.kotlinx:kotlinx-coroutines-test:1.6.4'
     compileOnly 'androidx.compose.ui:ui'
     compileOnly 'androidx.compose.material:material'

src/main/kotlin/com/mparticle/kits/RoktConfigExtensions.kt

@@ -0,0 +1,32 @@
+package com.mparticle.kits
+
+import com.mparticle.rokt.RoktConfig
+import com.mparticle.rokt.CacheConfig as MpCacheConfig
+import com.rokt.roktsdk.CacheConfig
+import com.rokt.roktsdk.RoktConfig as RoktSdkConfig
+
+fun MpCacheConfig.toRoktSdkCacheConfig(): CacheConfig = CacheConfig(
+    cacheDurationInSeconds = this.cacheDurationInSeconds,
+    cacheAttributes = this.cacheAttributes,
+)
+
+fun RoktConfig.toRoktSdkConfig(): RoktSdkConfig {
+    val colorMode = when (this.colorMode) {
+        RoktConfig.ColorMode.LIGHT -> RoktSdkConfig.ColorMode.LIGHT
+        RoktConfig.ColorMode.DARK -> RoktSdkConfig.ColorMode.DARK
+        RoktConfig.ColorMode.SYSTEM -> RoktSdkConfig.ColorMode.SYSTEM
+        else -> RoktSdkConfig.ColorMode.SYSTEM
+    }
+
+    val cacheConfig = this.cacheConfig?.toRoktSdkCacheConfig()
+
+    val edgeToEdgeDisplay = this.edgeToEdgeDisplay
+
+    val builder = RoktSdkConfig.Builder()
+        .colorMode(colorMode)
+        .edgeToEdgeDisplay(edgeToEdgeDisplay)
+
+    cacheConfig?.let { builder.cacheConfig(it) }
+
+    return builder.build()
+}

src/main/kotlin/com/mparticle/kits/RoktKit.kt

@@ -21,7 +21,6 @@ import com.mparticle.kits.KitIntegration.IdentityListener
 import com.mparticle.kits.KitIntegration.RoktListener
 import com.mparticle.rokt.RoktConfig
 import com.mparticle.rokt.RoktEmbeddedView
-import com.rokt.roktsdk.CacheConfig
 import com.rokt.roktsdk.Rokt
 import com.rokt.roktsdk.Rokt.RoktCallback
 import com.rokt.roktsdk.Rokt.SdkFrameworkType.Android
@@ -197,7 +196,7 @@ class RoktKit :
 
         this.mpRoktEventCallback = mpRoktEventCallback
         val finalAttributes = prepareFinalAttributes(filterUser, attributes)
-        val roktConfig = mpRoktConfig?.let { mapToRoktConfig(it) }
+        val roktConfig = mpRoktConfig?.toRoktSdkConfig()
         Rokt.execute(
             viewName,
             finalAttributes,
@@ -214,25 +213,48 @@ class RoktKit :
         attributes: Map<String, String>,
     ): Map<String, String> {
         val finalAttributes = mutableMapOf<String, String>()
+
         filterUser?.userAttributes?.let { userAttrs ->
             for ((key, value) in userAttrs) {
-                finalAttributes[key] = value.toString()
+                if (value != null) {
+                    finalAttributes[key] = convertValueToString(value)
+                }
             }
         }
 
+        finalAttributes.putAll(filterAttributes(attributes, configuration))
+
         filterUser?.id?.toString()?.let { mpid ->
             finalAttributes[MPID] = mpid
         } ?: Logger.warning("RoktKit: No user ID available for placement")
 
         addIdentityAttributes(finalAttributes, filterUser)
 
-        attributes[ROKT_ATTRIBUTE_SANDBOX_MODE]?.let { value ->
-            finalAttributes.put(ROKT_ATTRIBUTE_SANDBOX_MODE, value)
-        }
         verifyHashedEmail(finalAttributes)
         return finalAttributes
     }
 
+    private fun convertValueToString(value: Any?): String {
+        return when (value) {
+            is Double -> BigDecimal.valueOf(value).toPlainString()
+            is Long -> BigDecimal.valueOf(value).toPlainString()
+            is Int -> BigDecimal.valueOf(value.toLong()).toPlainString()
+            is Number -> BigDecimal(value.toString()).toPlainString()
+            else -> value.toString()
+        }
+    }
+
+    private fun filterAttributes(attributes: Map<String, String>, kitConfiguration: KitConfiguration): MutableMap<String, String> {
+        val userAttributes = mutableMapOf<String, String>()
+        for ((key, value) in attributes) {
+            val hashKey = KitUtils.hashForFiltering(key)
+            if (!kitConfiguration.mUserAttributeFilters.get(hashKey)) {
+                userAttributes[key] = value
+            }
+        }
+        return userAttributes
+    }
+
     override fun events(identifier: String): Flow<com.mparticle.RoktEvent> = Rokt.events(identifier).map { event ->
         when (event) {
             is RoktEvent.HideLoadingIndicator -> com.mparticle.RoktEvent.HideLoadingIndicator
@@ -312,30 +334,7 @@ class RoktKit :
         }
     }
 
-    private fun mapToRoktConfig(config: RoktConfig): com.rokt.roktsdk.RoktConfig {
-        val colorMode = when (config.colorMode) {
-            RoktConfig.ColorMode.LIGHT -> com.rokt.roktsdk.RoktConfig.ColorMode.LIGHT
-            RoktConfig.ColorMode.DARK -> com.rokt.roktsdk.RoktConfig.ColorMode.DARK
-            RoktConfig.ColorMode.SYSTEM -> com.rokt.roktsdk.RoktConfig.ColorMode.SYSTEM
-            else -> com.rokt.roktsdk.RoktConfig.ColorMode.SYSTEM
-        }
-
-        val cacheConfig = config.cacheConfig?.cacheDurationInSeconds?.let {
-            CacheConfig(
-                cacheDurationInSeconds = it,
-                cacheAttributes = config.cacheConfig?.cacheAttributes,
-            )
-        }
 
-        val edgeToEdgeDisplay = config.edgeToEdgeDisplay
-
-        val builder = com.rokt.roktsdk.RoktConfig.Builder().colorMode(colorMode).edgeToEdgeDisplay(edgeToEdgeDisplay)
-
-        cacheConfig?.let {
-            builder.cacheConfig(it)
-        }
-        return builder.build()
-    }
 
     private fun addIdentityAttributes(
         attributes: MutableMap<String, String>?,

src/main/kotlin/com/mparticle/kits/RoktLayout.kt

@@ -6,6 +6,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import com.mparticle.MpRoktEventCallback
+import com.mparticle.rokt.RoktConfig
 import com.rokt.roktsdk.Rokt
 
 @Composable
@@ -17,6 +18,7 @@ fun RoktLayout(
     location: String,
     modifier: Modifier = Modifier,
     mpRoktEventCallback: MpRoktEventCallback? = null,
+    config: RoktConfig? = null,
 ) {
     val instance = RoktKit.instance
     val resultMapState = remember { mutableStateOf<RoktResult?>(null) }
@@ -38,6 +40,7 @@ fun RoktLayout(
             onShouldShowLoadingIndicator = { resultMap.callback.onShouldShowLoadingIndicator() },
             onShouldHideLoadingIndicator = { resultMap.callback.onShouldHideLoadingIndicator() },
             onUnload = { reason -> resultMap.callback.onUnload(reason) },
+            config = config?.toRoktSdkConfig(),
         )
     }
 }

src/test/kotlin/com/mparticle/kits/RoktConfigExtensionsTest.kt

@@ -0,0 +1,67 @@
+package com.mparticle.kits
+
+import com.mparticle.rokt.CacheConfig
+import com.mparticle.rokt.RoktConfig
+import com.rokt.roktsdk.RoktConfig as SdkRoktConfig
+import io.mockk.every
+import io.mockk.mockk
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.Assert.assertNotNull
+
+class RoktConfigExtensionsTest {
+
+    @Test
+    fun `toRoktSdkConfig maps color mode and edgeToEdge`() {
+        val source = mockk<RoktConfig>()
+        every { source.colorMode } returns RoktConfig.ColorMode.DARK
+        every { source.edgeToEdgeDisplay } returns true
+        every { source.cacheConfig } returns null
+
+        val result: SdkRoktConfig = source.toRoktSdkConfig()
+
+        assertEquals(SdkRoktConfig.ColorMode.DARK, result.colorMode)
+        assertEquals(true, result.edgeToEdgeDisplay)
+    }
+
+    @Test
+    fun `toRoktSdkConfig maps cacheConfig when present`() {
+        val cacheAttributes = mapOf(
+            "key1" to "value1",
+            "key2" to "value2",
+        )
+
+        val cacheConfig = mockk<CacheConfig>()
+        every { cacheConfig.cacheDurationInSeconds } returns 3600
+        every { cacheConfig.cacheAttributes } returns cacheAttributes
+
+        val source = mockk<RoktConfig>()
+        every { source.colorMode } returns RoktConfig.ColorMode.LIGHT
+        every { source.edgeToEdgeDisplay } returns false
+        every { source.cacheConfig } returns cacheConfig
+
+        val result: SdkRoktConfig = source.toRoktSdkConfig()
+
+        assertEquals(SdkRoktConfig.ColorMode.LIGHT, result.colorMode)
+        assertEquals(false, result.edgeToEdgeDisplay)
+        assertNotNull(result.cacheConfig)
+        assertEquals(3600L, result.cacheConfig?.cacheDurationInSeconds)
+        assertEquals(cacheAttributes, result.cacheConfig?.cacheAttributes)
+    }
+
+    @Test
+    fun `toRoktSdkCacheConfig maps fields`() {
+        val cacheAttributes = mapOf(
+            "a" to "1",
+            "b" to "2",
+        )
+        val mpCache = mockk<CacheConfig>()
+        every { mpCache.cacheDurationInSeconds } returns 120
+        every { mpCache.cacheAttributes } returns cacheAttributes
+
+        val sdkCache = mpCache.toRoktSdkCacheConfig()
+
+        assertEquals(120, sdkCache.cacheDurationInSeconds)
+        assertEquals(cacheAttributes, sdkCache.cacheAttributes)
+    }
+}