RUM-10363: Fix appUptimeNs and RumResourceInputStreamTest.kt tests

Author: kikoveiga

dd-sdk-android-core/src/test/kotlin/com/datadog/android/core/internal/time/DefaultAppStartTimeProviderTest.kt

@@ -21,6 +21,7 @@ import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.api.extension.Extensions
 import org.mockito.Mock
 import org.mockito.junit.jupiter.MockitoExtension
+import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.whenever
 import java.util.concurrent.TimeUnit
 
@@ -42,8 +43,8 @@ class DefaultAppStartTimeProviderTest {
         @LongForgery(min = 0L) fakeCurrentTimeNs: Long
     ) {
         // Given
-        whenever(mockBuildSdkVersionProvider.version).thenReturn(apiVersion)
-        whenever(mockTimeProvider.getDeviceElapsedTimeNs()).thenReturn(fakeCurrentTimeNs)
+        whenever(mockBuildSdkVersionProvider.version) doReturn apiVersion
+        whenever(mockTimeProvider.getDeviceElapsedTimeNs()) doReturn fakeCurrentTimeNs
         val diffMs = SystemClock.elapsedRealtime() - Process.getStartElapsedRealtime()
         val expectedStartTimeNs = fakeCurrentTimeNs - TimeUnit.MILLISECONDS.toNanos(diffMs)
 
@@ -63,7 +64,7 @@ class DefaultAppStartTimeProviderTest {
         @IntForgery(min = Build.VERSION_CODES.M, max = Build.VERSION_CODES.N) apiVersion: Int
     ) {
         // Given
-        whenever(mockBuildSdkVersionProvider.version).thenReturn(apiVersion)
+        whenever(mockBuildSdkVersionProvider.version) doReturn apiVersion
         val startTimeNs = DdRumContentProvider.createTimeNs
 
         // When
@@ -80,25 +81,27 @@ class DefaultAppStartTimeProviderTest {
     @Test
     fun `M return app uptime W appUptimeNs`(
         @IntForgery(min = Build.VERSION_CODES.N) apiVersion: Int,
-        @LongForgery(min = 1000000L) fakeCurrentTimeNs: Long,
-        @LongForgery(min = 100L, max = 999999L) fakeUptimeNs: Long
+        @LongForgery(min = 1000000L) fakeStartTimeNs: Long,
+        @LongForgery(min = 1000L, max = 100000L) fakeUptimeNs: Long
     ) {
         // Given
-        whenever(mockBuildSdkVersionProvider.version).thenReturn(apiVersion)
+        whenever(mockBuildSdkVersionProvider.version) doReturn apiVersion
+
         val diffMs = SystemClock.elapsedRealtime() - Process.getStartElapsedRealtime()
-        val fakeStartTimeNs = fakeCurrentTimeNs - TimeUnit.MILLISECONDS.toNanos(diffMs)
+        val fakeCurrentTimeNs = fakeStartTimeNs + TimeUnit.MILLISECONDS.toNanos(diffMs)
+
         whenever(mockTimeProvider.getDeviceElapsedTimeNs())
-            .thenReturn(fakeCurrentTimeNs)
-            .thenReturn(fakeStartTimeNs + fakeUptimeNs)
+            .doReturn(fakeCurrentTimeNs)
+            .doReturn(fakeStartTimeNs + fakeUptimeNs)
 
-        // When
-        val testedAppStartTimeProvider = DefaultAppStartTimeProvider(
+        val testedProvider = DefaultAppStartTimeProvider(
             mockTimeProvider,
             mockBuildSdkVersionProvider
         )
-        // First call initializes appStartTimeNs
-        testedAppStartTimeProvider.appStartTimeNs
-        val uptime = testedAppStartTimeProvider.appUptimeNs
+
+        // When
+        testedProvider.appStartTimeNs
+        val uptime = testedProvider.appUptimeNs
 
         // Then
         assertThat(uptime).isEqualTo(fakeUptimeNs)
@@ -107,26 +110,27 @@ class DefaultAppStartTimeProviderTest {
     @Test
     fun `M return increasing uptime W appUptimeNs called multiple times`(
         @IntForgery(min = Build.VERSION_CODES.N) apiVersion: Int,
-        @LongForgery(min = 1000000L) fakeCurrentTimeNs: Long
+        @LongForgery(min = 1000000L) fakeStartTimeNs: Long
     ) {
         // Given
-        whenever(mockBuildSdkVersionProvider.version).thenReturn(apiVersion)
+        whenever(mockBuildSdkVersionProvider.version) doReturn apiVersion
         val diffMs = SystemClock.elapsedRealtime() - Process.getStartElapsedRealtime()
-        val fakeStartTimeNs = fakeCurrentTimeNs - TimeUnit.MILLISECONDS.toNanos(diffMs)
+        val fakeCurrentTimeNs = fakeStartTimeNs + TimeUnit.MILLISECONDS.toNanos(diffMs)
+
         whenever(mockTimeProvider.getDeviceElapsedTimeNs())
-            .thenReturn(fakeCurrentTimeNs)
-            .thenReturn(fakeStartTimeNs + 100L)
-            .thenReturn(fakeStartTimeNs + 200L)
+            .doReturn(fakeCurrentTimeNs)
+            .doReturn(fakeStartTimeNs + 100L)
+            .doReturn(fakeStartTimeNs + 200L)
 
-        // When
-        val testedAppStartTimeProvider = DefaultAppStartTimeProvider(
+        val testedProvider = DefaultAppStartTimeProvider(
             mockTimeProvider,
             mockBuildSdkVersionProvider
         )
-        // First call initializes appStartTimeNs
-        testedAppStartTimeProvider.appStartTimeNs
-        val uptime1 = testedAppStartTimeProvider.appUptimeNs
-        val uptime2 = testedAppStartTimeProvider.appUptimeNs
+
+        // When
+        testedProvider.appStartTimeNs
+        val uptime1 = testedProvider.appUptimeNs
+        val uptime2 = testedProvider.appUptimeNs
 
         // Then
         assertThat(uptime2).isGreaterThan(uptime1)

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/resource/ContextExtTest.kt

@@ -9,7 +9,7 @@ package com.datadog.android.rum.resource
 import android.content.Context
 import android.content.res.AssetManager
 import android.content.res.Resources
-import com.datadog.android.api.SdkCore
+import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.android.internal.utils.toHexString
 import com.datadog.tools.unit.forge.BaseConfigurator
 import fr.xgouchet.elmyr.annotation.IntForgery
@@ -45,7 +45,7 @@ class ContextExtTest {
     lateinit var mockContext: Context
 
     @Mock
-    lateinit var mockSdkCore: SdkCore
+    lateinit var mockSdkCore: FeatureSdkCore
 
     @Mock
     lateinit var mockAssetManager: AssetManager
@@ -57,6 +57,8 @@ class ContextExtTest {
     fun `set up`() {
         whenever(mockContext.assets) doReturn mockAssetManager
         whenever(mockContext.resources) doReturn mockResources
+
+        whenever(mockSdkCore.timeProvider) doReturn mock()
     }
 
     @Test

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/resource/InputStreamExtTest.kt

@@ -6,7 +6,7 @@
 
 package com.datadog.android.rum.resource
 
-import com.datadog.android.api.SdkCore
+import com.datadog.android.api.feature.FeatureSdkCore
 import com.datadog.tools.unit.forge.BaseConfigurator
 import fr.xgouchet.elmyr.annotation.StringForgery
 import fr.xgouchet.elmyr.junit5.ForgeConfiguration
@@ -17,7 +17,9 @@ import org.junit.jupiter.api.extension.ExtendWith
 import org.junit.jupiter.api.extension.Extensions
 import org.mockito.junit.jupiter.MockitoExtension
 import org.mockito.junit.jupiter.MockitoSettings
+import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
 import org.mockito.quality.Strictness
 import java.io.InputStream
 
@@ -37,7 +39,8 @@ class InputStreamExtTest {
     ) {
         // Given
         val mockIS: InputStream = mock()
-        val mockSdkCore: SdkCore = mock()
+        val mockSdkCore: FeatureSdkCore = mock()
+        whenever(mockSdkCore.timeProvider) doReturn mock()
 
         // When
         val result = mockIS.asRumResource(url, mockSdkCore)

features/dd-sdk-android-rum/src/test/kotlin/com/datadog/android/rum/resource/RumResourceInputStreamTest.kt

@@ -6,6 +6,8 @@
 
 package com.datadog.android.rum.resource
 
+import com.datadog.android.api.feature.FeatureSdkCore
+import com.datadog.android.internal.time.TimeProvider
 import com.datadog.android.rum.RumErrorSource
 import com.datadog.android.rum.RumResourceKind
 import com.datadog.android.rum.internal.domain.event.ResourceTiming
@@ -45,10 +47,7 @@ import org.mockito.quality.Strictness
 import java.io.BufferedReader
 import java.io.IOException
 import java.io.InputStream
-import java.lang.RuntimeException
-import java.util.concurrent.TimeUnit
 import kotlin.math.min
-import kotlin.system.measureNanoTime
 
 @Extensions(
     ExtendWith(MockitoExtension::class),
@@ -64,6 +63,9 @@ internal class RumResourceInputStreamTest {
     @Mock
     lateinit var mockInputStream: InputStream
 
+    @Mock
+    lateinit var mockTimeProvider: TimeProvider
+
     @StringForgery
     lateinit var fakeUrl: String
 
@@ -72,6 +74,7 @@ internal class RumResourceInputStreamTest {
 
     @BeforeEach
     fun `set up`() {
+        whenever((rumMonitor.mockSdkCore as FeatureSdkCore).timeProvider) doReturn mockTimeProvider
         testedInputStream = RumResourceInputStream(mockInputStream, fakeUrl, rumMonitor.mockSdkCore)
 
         // M start resource W init
@@ -658,24 +661,26 @@ internal class RumResourceInputStreamTest {
 
     @Test
     fun `M register resource with timing W read() + close() {bufferedReader}`(
-        @StringForgery content: String
+        @StringForgery content: String,
+        @LongForgery(min = 0L) fakeCallStartNs: Long,
+        @LongForgery(min = 0L) fakeDownloadStartNs: Long,
+        @LongForgery(min = 0L) fakeDownloadDurationNs: Long
     ) {
         // Given
         val contentBytes = content.toByteArray()
         val inputStream = contentBytes.inputStream()
+        val fakeFirstByteNs = fakeCallStartNs + fakeDownloadStartNs
+        val fakeLastByteNs = fakeFirstByteNs + fakeDownloadDurationNs
+
+        whenever(mockTimeProvider.getDeviceElapsedTimeNs())
+            .thenReturn(fakeCallStartNs)
+            .thenReturn(fakeFirstByteNs)
+            .thenReturn(fakeLastByteNs)
+
         testedInputStream = RumResourceInputStream(inputStream, fakeUrl, rumMonitor.mockSdkCore)
-        Thread.sleep(500)
-        var download: Long
 
         // When
-        val result = testedInputStream.bufferedReader().use {
-            var text: String
-            download = measureNanoTime {
-                text = it.readText()
-            }
-            Thread.sleep(500)
-            text
-        }
+        val result = testedInputStream.bufferedReader().use { it.readText() }
 
         // Then
         assertThat(result).isEqualTo(content)
@@ -697,10 +702,8 @@ internal class RumResourceInputStreamTest {
                 assertThat(firstValue.dnsDuration).isEqualTo(0L)
                 assertThat(firstValue.sslDuration).isEqualTo(0L)
                 assertThat(firstValue.firstByteDuration).isEqualTo(0L)
-                assertThat(firstValue.downloadStart).isGreaterThan(
-                    TimeUnit.MILLISECONDS.toNanos(500)
-                )
-                assertThat(firstValue.downloadDuration).isLessThanOrEqualTo(download)
+                assertThat(firstValue.downloadStart).isEqualTo(fakeDownloadStartNs)
+                assertThat(firstValue.downloadDuration).isEqualTo(fakeDownloadDurationNs)
             }
             verify(rumMonitor.mockInstance).stopResource(
                 testedInputStream.key,