feat(experimental): Initialize Android SDK from json configuration

CHANGELOG.md

@@ -23,7 +23,9 @@
 - Rename `navigation.processing` span to more expressive `Navigation dispatch to screen A mounted/navigation cancelled` ([#4423](https://github.com/getsentry/sentry-react-native/pull/4423))
 - Add RN SDK package to `sdk.packages` for Cocoa ([#4381](https://github.com/getsentry/sentry-react-native/pull/4381))
 - Add experimental version of `startWithConfigureOptions` for Apple platforms ([#4444](https://github.com/getsentry/sentry-react-native/pull/4444))
+- Add experimental version of `init` with optional `OptionsConfiguration<SentryAndroidOptions>` for Android ([#4451](https://github.com/getsentry/sentry-react-native/pull/4451))
 - Add initialization using `sentry.options.json` for Apple platforms ([#4447](https://github.com/getsentry/sentry-react-native/pull/4447))
+- Add initialization using `sentry.options.json` for Android ([#4451](https://github.com/getsentry/sentry-react-native/pull/4451))
 
 ### Internal
 

packages/core/RNSentryAndroidTester/app/src/androidTest/assets/invalid.options.json

@@ -0,0 +1,3 @@
+{
+  "dsn": "invalid-dsn"
+}

packages/core/RNSentryAndroidTester/app/src/androidTest/assets/invalid.options.txt

@@ -0,0 +1 @@
+invalid-options

packages/core/RNSentryAndroidTester/app/src/androidTest/assets/sentry.options.json

@@ -0,0 +1,5 @@
+{
+  "dsn": "https://[email protected]/123456",
+  "enableTracing": true,
+  "tracesSampleRate": 1.0
+}

packages/core/RNSentryAndroidTester/app/src/androidTest/java/io/sentry/react/RNSentrySDKTest.kt

@@ -0,0 +1,208 @@
+package io.sentry.react
+
+import android.content.Context
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.facebook.react.common.JavascriptException
+import io.sentry.Hint
+import io.sentry.ILogger
+import io.sentry.Sentry
+import io.sentry.Sentry.OptionsConfiguration
+import io.sentry.SentryEvent
+import io.sentry.android.core.AndroidLogger
+import io.sentry.android.core.SentryAndroidOptions
+import io.sentry.protocol.SdkVersion
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class RNSentrySDKTest {
+    private val logger: ILogger = AndroidLogger(RNSentrySDKTest::class.java.simpleName)
+    private lateinit var context: Context
+
+    companion object {
+        private const val INITIALISATION_ERROR = "Failed to initialize Sentry's React Native SDK"
+        private const val VALID_OPTIONS = "sentry.options.json"
+        private const val INVALID_OPTIONS = "invalid.options.json"
+        private const val INVALID_JSON = "invalid.options.txt"
+        private const val MISSING = "non-existing-file"
+
+        private val validConfig =
+            OptionsConfiguration<SentryAndroidOptions> { options ->
+                options.dsn = "https://[email protected]/123456"
+            }
+        private val invalidConfig =
+            OptionsConfiguration<SentryAndroidOptions> { options ->
+                options.dsn = "invalid-dsn"
+            }
+        private val emptyConfig = OptionsConfiguration<SentryAndroidOptions> {}
+    }
+
+    @Before
+    fun setUp() {
+        context = InstrumentationRegistry.getInstrumentation().context
+    }
+
+    @After
+    fun tearDown() {
+        Sentry.close()
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithDefaultValidJsonFile() { // sentry.options.json
+        RNSentrySDK.init(context)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithValidConfigurationAndDefaultValidJsonFile() {
+        RNSentrySDK.init(context, validConfig)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithValidConfigurationAndInvalidJsonFile() {
+        RNSentrySDK.init(context, validConfig, INVALID_OPTIONS, logger, null)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithValidConfigurationAndMissingJsonFile() {
+        RNSentrySDK.init(context, validConfig, MISSING, logger, null)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithValidConfigurationAndErrorInParsingJsonFile() {
+        RNSentrySDK.init(context, validConfig, INVALID_JSON, logger, null)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun initialisesSuccessfullyWithNoConfigurationAndValidJsonFile() {
+        RNSentrySDK.init(context, emptyConfig, VALID_OPTIONS, logger, null)
+        assertTrue(Sentry.isEnabled())
+    }
+
+    @Test
+    fun failsToInitialiseWithNoConfigurationAndInvalidJsonFile() {
+        try {
+            RNSentrySDK.init(context, emptyConfig, INVALID_OPTIONS, logger, null)
+        } catch (e: Exception) {
+            assertEquals(INITIALISATION_ERROR, e.message)
+        }
+        assertFalse(Sentry.isEnabled())
+    }
+
+    @Test
+    fun failsToInitialiseWithInvalidConfigAndInvalidJsonFile() {
+        try {
+            RNSentrySDK.init(context, invalidConfig, INVALID_OPTIONS, logger, null)
+        } catch (e: Exception) {
+            assertEquals(INITIALISATION_ERROR, e.message)
+        }
+        assertFalse(Sentry.isEnabled())
+    }
+
+    @Test
+    fun failsToInitialiseWithInvalidConfigAndValidJsonFile() {
+        try {
+            RNSentrySDK.init(context, invalidConfig, VALID_OPTIONS, logger, null)
+        } catch (e: Exception) {
+            assertEquals(INITIALISATION_ERROR, e.message)
+        }
+        assertFalse(Sentry.isEnabled())
+    }
+
+    @Test
+    fun failsToInitialiseWithInvalidConfigurationAndDefaultValidJsonFile() {
+        try {
+            RNSentrySDK.init(context, invalidConfig)
+        } catch (e: Exception) {
+            assertEquals(INITIALISATION_ERROR, e.message)
+        }
+        assertFalse(Sentry.isEnabled())
+    }
+
+    @Test
+    fun defaultsAndFinalsAreSetWithValidJsonFile() {
+        RNSentrySDK.init(context, emptyConfig, VALID_OPTIONS, logger) { _, config ->
+            val actualOptions = SentryAndroidOptions()
+            config.configure(actualOptions)
+            verifyDefaults(actualOptions)
+            verifyFinals(actualOptions)
+            // options file
+            assert(actualOptions.dsn == "https://[email protected]/123456")
+        }
+    }
+
+    @Test
+    fun defaultsAndFinalsAreSetWithValidConfiguration() {
+        RNSentrySDK.init(context, validConfig, MISSING, logger) { _, config ->
+            val actualOptions = SentryAndroidOptions()
+            config.configure(actualOptions)
+            verifyDefaults(actualOptions)
+            verifyFinals(actualOptions)
+            // configuration
+            assert(actualOptions.dsn == "https://[email protected]/123456")
+        }
+    }
+
+    @Test
+    fun defaultsOverrideOptionsJsonFile() {
+        RNSentrySDK.init(context, emptyConfig, VALID_OPTIONS, logger) { _, config ->
+            val actualOptions = SentryAndroidOptions()
+            config.configure(actualOptions)
+            assertNull(actualOptions.tracesSampleRate)
+            assertEquals(false, actualOptions.enableTracing)
+        }
+    }
+
+    @Test
+    fun configurationOverridesDefaultOptions() {
+        val validConfig =
+            OptionsConfiguration<SentryAndroidOptions> { options ->
+                options.dsn = "https://[email protected]/123456"
+                options.tracesSampleRate = 0.5
+                options.enableTracing = true
+            }
+        RNSentrySDK.init(context, validConfig, MISSING, logger) { _, config ->
+            val actualOptions = SentryAndroidOptions()
+            config.configure(actualOptions)
+            assertEquals(0.5, actualOptions.tracesSampleRate)
+            assertEquals(true, actualOptions.enableTracing)
+            assert(actualOptions.dsn == "https://[email protected]/123456")
+        }
+    }
+
+    private fun verifyDefaults(actualOptions: SentryAndroidOptions) {
+        assertTrue(actualOptions.ignoredExceptionsForType.contains(JavascriptException::class.java))
+        assertEquals(RNSentryVersion.ANDROID_SDK_NAME, actualOptions.sdkVersion?.name)
+        assertEquals(
+            io.sentry.android.core.BuildConfig.VERSION_NAME,
+            actualOptions.sdkVersion?.version,
+        )
+        val pack = actualOptions.sdkVersion?.packages?.first { it.name == RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_NAME }
+        assertNotNull(pack)
+        assertEquals(RNSentryVersion.REACT_NATIVE_SDK_PACKAGE_VERSION, pack?.version)
+        assertNull(actualOptions.tracesSampleRate)
+        assertNull(actualOptions.tracesSampler)
+        assertEquals(false, actualOptions.enableTracing)
+    }
+
+    private fun verifyFinals(actualOptions: SentryAndroidOptions) {
+        val event =
+            SentryEvent().apply { sdk = SdkVersion(RNSentryVersion.ANDROID_SDK_NAME, "1.0") }
+        val result = actualOptions.beforeSend?.execute(event, Hint())
+        assertNotNull(result)
+        assertEquals("android", result?.getTag("event.origin"))
+        assertEquals("java", result?.getTag("event.environment"))
+    }
+}

packages/core/RNSentryAndroidTester/app/src/test/java/io/sentry/react/RNSentryCompositeOptionsConfigurationTest.kt

@@ -0,0 +1,50 @@
+package io.sentry.react
+
+import io.sentry.Sentry.OptionsConfiguration
+import io.sentry.android.core.SentryAndroidOptions
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+
+@RunWith(JUnit4::class)
+class RNSentryCompositeOptionsConfigurationTest {
+    @Test
+    fun `configure should call base and overriding configurations`() {
+        val baseConfig: OptionsConfiguration<SentryAndroidOptions> = mock()
+        val overridingConfig: OptionsConfiguration<SentryAndroidOptions> = mock()
+
+        val compositeConfig = RNSentryCompositeOptionsConfiguration(baseConfig, overridingConfig)
+        val options = SentryAndroidOptions()
+        compositeConfig.configure(options)
+
+        verify(baseConfig).configure(options)
+        verify(overridingConfig).configure(options)
+    }
+
+    @Test
+    fun `configure should apply base configuration and override values`() {
+        val baseConfig =
+            OptionsConfiguration<SentryAndroidOptions> { options ->
+                options.dsn = "https://[email protected]"
+                options.isDebug = false
+                options.release = "some-release"
+            }
+        val overridingConfig =
+            OptionsConfiguration<SentryAndroidOptions> { options ->
+                options.dsn = "https://[email protected]"
+                options.isDebug = true
+                options.environment = "production"
+            }
+
+        val compositeConfig = RNSentryCompositeOptionsConfiguration(baseConfig, overridingConfig)
+        val options = SentryAndroidOptions()
+        compositeConfig.configure(options)
+
+        assert(options.dsn == "https://[email protected]") // overridden value
+        assert(options.isDebug) // overridden value
+        assert(options.release == "some-release") // base value not overridden
+        assert(options.environment == "production") // overridden value not in base
+    }
+}