Integration test for app launch

Author: aleksandr-gringauz

instrumented/integration/src/androidTest/kotlin/com/datadog/android/sdk/integration/rum/AppLaunchTest.kt

@@ -0,0 +1,78 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sdk.integration.rum
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import com.datadog.android.sdk.integration.RuntimeConfig
+import com.datadog.android.sdk.rules.AppLaunchActivityTestRule
+import com.datadog.tools.unit.ConditionWatcher
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+internal class AppLaunchTest : RumTest<AppLaunchPlaygroundActivity, AppLaunchActivityTestRule>() {
+
+    @get:Rule
+    val mockServerRule = AppLaunchActivityTestRule()
+
+    override fun runInstrumentationScenario(
+        mockServerRule: AppLaunchActivityTestRule
+    ): MutableList<ExpectedEvent> {
+        val expectedEvents = mutableListOf<ExpectedEvent>()
+        val instrumentation = InstrumentationRegistry.getInstrumentation()
+
+        instrumentation.waitForIdleSync()
+        waitForPendingRUMEvents()
+
+        expectedEvents.add(
+            ExpectedApplicationLaunchViewEvent(
+                docVersion = 2
+            )
+        )
+
+        /**
+         * We aren't checking the startup type (cold or warm) here
+         * because the tests are run within the same OS process and we don't
+         * know which startup type it will be. If this test is executed the first,
+         * it will be cold, otherwise warm.
+         */
+        expectedEvents.add(
+            ExpectedVitalAppLaunchEvent(
+                appLaunchMetric = AppLaunchMetric.TTID
+            )
+        )
+
+        expectedEvents.add(
+            ExpectedVitalAppLaunchEvent(
+                appLaunchMetric = AppLaunchMetric.TTFD
+            )
+        )
+
+        instrumentation.waitForIdleSync()
+
+        return expectedEvents
+    }
+
+    @Test
+    fun verifyRumEvents() {
+        val expectedEvents = runInstrumentationScenario(mockServerRule)
+
+        InstrumentationRegistry.getInstrumentation().waitForIdleSync()
+
+        ConditionWatcher {
+            verifyExpectedEvents(
+                mockServerRule.getRequests(RuntimeConfig.rumEndpointUrl),
+                expectedEvents
+            )
+            true
+        }.doWait(timeoutMs = FINAL_WAIT_MS)
+    }
+}

instrumented/integration/src/androidTest/kotlin/com/datadog/android/sdk/integration/rum/ExpectedEvents.kt

@@ -59,6 +59,11 @@ internal data class ExpectedErrorEvent(
     override val rumContext: ExpectedRumContext = resolvedRumContext()
 ) : ExpectedEvent
 
+internal data class ExpectedVitalAppLaunchEvent(
+    val appLaunchMetric: AppLaunchMetric,
+    override val rumContext: ExpectedRumContext = resolvedRumContext()
+) : ExpectedEvent
+
 internal interface ExpectedEvent {
     val rumContext: ExpectedRumContext
 }
@@ -72,6 +77,11 @@ internal enum class ErrorSource(val sourceName: String) {
     NETWORK("network")
 }
 
+internal enum class AppLaunchMetric(val metric: String) {
+    TTID("ttid"),
+    TTFD("ttfd")
+}
+
 private val registryField = Datadog::class.java.getDeclaredField("registry").apply {
     isAccessible = true
 }

instrumented/integration/src/androidTest/kotlin/com/datadog/android/sdk/integration/rum/RumTest.kt

@@ -33,6 +33,7 @@ internal abstract class RumTest<R : Activity, T : MockServerActivityTestRule<R>>
         val sentActionEvents = LinkedList<JsonObject>()
         val sentResourceEvents = LinkedList<JsonObject>()
         val sentLaunchEvents = LinkedList<JsonObject>()
+        val sentVitalAppLaunchEvents = LinkedList<JsonObject>()
         handledRequests
             .filter { it.url?.isRumUrl() ?: false }
             .forEach { request ->
@@ -53,6 +54,8 @@ internal abstract class RumTest<R : Activity, T : MockServerActivityTestRule<R>>
                                 sentActionEvents += it
                             } else if (it.isResourceEvent) {
                                 sentResourceEvents += it
+                            } else if (it.isVitalAppLaunchEvent) {
+                                sentVitalAppLaunchEvents += it
                             }
                         }
                 }
@@ -64,6 +67,7 @@ internal abstract class RumTest<R : Activity, T : MockServerActivityTestRule<R>>
         val expectedViewEvents = expectedEvents.filterIsInstance<ExpectedViewEvent>()
         val expectedActionEvents = expectedEvents.filterIsInstance<ExpectedGestureEvent>()
         val expectedResourceEvents = expectedEvents.filterIsInstance<ExpectedResourceEvent>()
+        val expectedVitalAppLaunchEvents = expectedEvents.filterIsInstance<ExpectedVitalAppLaunchEvent>()
         if (expectedLaunchEvents.isNotEmpty()) {
             sentLaunchEvents
                 .reduceViewEvents()
@@ -80,6 +84,9 @@ internal abstract class RumTest<R : Activity, T : MockServerActivityTestRule<R>>
         if (expectedResourceEvents.isNotEmpty()) {
             sentResourceEvents.verifyEventMatches(expectedResourceEvents)
         }
+        if (expectedVitalAppLaunchEvents.isNotEmpty()) {
+            sentVitalAppLaunchEvents.verifyEventMatches(expectedVitalAppLaunchEvents)
+        }
     }
 
     protected fun verifyNoRumPayloadSent(
@@ -114,6 +121,10 @@ internal abstract class RumTest<R : Activity, T : MockServerActivityTestRule<R>>
     private val JsonObject.isTelemetryEvent
         get() = get("type")?.asString == "telemetry"
 
+    private val JsonObject.isVitalAppLaunchEvent
+        get() = (get("type")?.asString == "vital") &&
+            (get("vital")?.asJsonObject?.get("type")?.asString == "app_launch")
+
     // two methods below are expected to be called only on view events
     private val JsonObject.viewId
         get() = get("view").asJsonObject.get("id").asString

instrumented/integration/src/androidTest/kotlin/com/datadog/android/sdk/integration/rum/RumTestUtils.kt

@@ -42,6 +42,7 @@ internal fun List<JsonObject>.verifyEventMatches(
             is ExpectedGestureEvent -> event.verifyEventMatches(expectedEvent)
             is ExpectedResourceEvent -> event.verifyEventMatches(expectedEvent)
             is ExpectedErrorEvent -> event.verifyEventMatches(expectedEvent)
+            is ExpectedVitalAppLaunchEvent -> event.verifyEventMatches(expectedEvent)
             else -> {
                 // Do nothing
             }
@@ -192,6 +193,15 @@ private fun JsonObject.verifyEventMatches(event: ExpectedErrorEvent) {
     }
 }
 
+private fun JsonObject.verifyEventMatches(event: ExpectedVitalAppLaunchEvent) {
+    verifyRootMatches(event)
+
+    assertThat(this)
+        .hasField("vital") {
+            hasField("app_launch_metric", event.appLaunchMetric.metric)
+        }
+}
+
 private fun JsonObject.verifyRootMatches(event: ExpectedEvent) {
     val applicationId = getAsJsonObject("application")
         .getAsJsonPrimitive("id").asString

instrumented/integration/src/androidTest/kotlin/com/datadog/android/sdk/rules/AppLaunchActivityTestRule.kt

@@ -0,0 +1,44 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sdk.rules
+
+import android.app.ActivityManager
+import androidx.test.platform.app.InstrumentationRegistry
+import com.datadog.android.Datadog
+import com.datadog.android.privacy.TrackingConsent
+import com.datadog.android.rum.DdRumContentProvider
+import com.datadog.android.rum.Rum
+import com.datadog.android.rum.tracking.ActivityViewTrackingStrategy
+import com.datadog.android.sdk.integration.RuntimeConfig
+import com.datadog.android.sdk.integration.rum.AppLaunchPlaygroundActivity
+
+internal class AppLaunchActivityTestRule : RumMockServerActivityTestRule<AppLaunchPlaygroundActivity>(
+    activityClass = AppLaunchPlaygroundActivity::class.java,
+    keepRequests = true,
+    trackingConsent = TrackingConsent.GRANTED
+) {
+    override fun beforeActivityLaunched() {
+        super.beforeActivityLaunched()
+        val config = RuntimeConfig.configBuilder()
+            .build()
+
+        val sdkCore = Datadog.initialize(
+            InstrumentationRegistry.getInstrumentation().targetContext.applicationContext,
+            config,
+            trackingConsent
+        )
+        checkNotNull(sdkCore)
+
+        val rumConfig = RuntimeConfig.rumConfigBuilder()
+            .trackUserInteractions()
+            .trackLongTasks(RuntimeConfig.LONG_TASK_LARGE_THRESHOLD)
+            .useViewTrackingStrategy(ActivityViewTrackingStrategy(false))
+            .build()
+        Rum.enable(rumConfig, sdkCore)
+        DdRumContentProvider.processImportance = ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+    }
+}

instrumented/integration/src/main/AndroidManifest.xml

@@ -84,6 +84,9 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
         </activity>
+        <activity android:name=".rum.AppLaunchPlaygroundActivity"
+            android:label="@string/activity_app_launch"
+            android:windowSoftInputMode="adjustResize"/>
     </application>
 
 </manifest>

instrumented/integration/src/main/kotlin/com/datadog/android/sdk/integration/rum/AppLaunchPlaygroundActivity.kt

@@ -0,0 +1,31 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2016-Present Datadog, Inc.
+ */
+
+package com.datadog.android.sdk.integration.rum
+
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import com.datadog.android.rum.ExperimentalRumApi
+import com.datadog.android.rum.GlobalRumMonitor
+import com.datadog.android.sdk.integration.R
+
+@OptIn(ExperimentalRumApi::class)
+internal class AppLaunchPlaygroundActivity : AppCompatActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.main_activity_layout)
+    }
+
+    override fun onResume() {
+        super.onResume()
+
+        @Suppress("MagicNumber")
+        window.decorView.postDelayed(
+            { GlobalRumMonitor.get().reportAppFullyDisplayed() },
+            3000
+        )
+    }
+}

instrumented/integration/src/main/res/values/strings.xml

@@ -10,6 +10,7 @@
 
     <string name="activity_logs_end_to_end">Logs (End to End)</string>
     <string name="activity_traces_end_to_end">Traces (End to End)</string>
+    <string name="activity_app_launch">App Launch (End to End)</string>
     <string name="activity_logs_profiling">Logs (Profiling)</string>
     <string name="button1">Button1</string>
     <string name="rum_gestures_tracking_end_to_end">Rum Gestures (End to End)</string>