Add more tests

Author: markushi

sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt

@@ -47,23 +47,36 @@ internal object ComposeViewHierarchyNode {
         return@lazy null
     }
 
-    private fun LayoutNode.retrieveSemanticsConfiguration(logger: ILogger): SemanticsConfiguration? {
+    private var semanticsRetrievalErrorLogged: Boolean = false
+
+    internal fun retrieveSemanticsConfiguration(node: LayoutNode, logger: ILogger): SemanticsConfiguration? {
         // Jetpack Compose 1.8 or newer provides SemanticsConfiguration via SemanticsInfo
         // See https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/LayoutNode.kt
         // and https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/semantics/SemanticsInfo.kt
         try {
             getSemanticsConfigurationMethod?.let {
-                return it.invoke(this) as SemanticsConfiguration?
+                return it.invoke(node) as SemanticsConfiguration?
             }
-        } catch (_: Throwable) {
-            logger.log(
-                SentryLevel.WARNING,
-                "Failed to invoke LayoutNode.getSemanticsConfiguration"
-            )
-        }
 
-        // for backwards compatibility
-        return collapsedSemantics
+            // for backwards compatibility
+            return node.collapsedSemantics
+        } catch (t: Throwable) {
+            if (!semanticsRetrievalErrorLogged) {
+                semanticsRetrievalErrorLogged = true
+                logger.log(
+                    SentryLevel.ERROR,
+                    t,
+                    """
+                Error retrieving semantics information from Compose tree. Most likely you're using
+                an unsupported version of androidx.compose.ui:ui. The supported
+                version range is 1.5.0 - 1.8.0.
+                If you're using a newer version, please open a github issue with the version
+                you're using, so we can add support for it.
+                    """.trimIndent()
+                )
+            }
+        }
+        return null
     }
 
     /**
@@ -114,23 +127,41 @@ internal object ComposeViewHierarchyNode {
             _rootCoordinates = WeakReference(node.coordinates.findRootCoordinates())
         }
 
-        // TODO: if semantics are null and masking is enabled, we simply should mask the whole node
-        val semantics = node.retrieveSemanticsConfiguration(options.logger)
+        val semantics = retrieveSemanticsConfiguration(node, options.logger)
         val visibleRect = node.coordinates.boundsInWindow(_rootCoordinates?.get())
         val isVisible = !node.outerCoordinator.isTransparent() &&
             (semantics == null || !semantics.contains(SemanticsProperties.InvisibleToUser)) &&
             visibleRect.height() > 0 && visibleRect.width() > 0
         val isEditable = semantics?.contains(SemanticsActions.SetText) == true ||
             semantics?.contains(SemanticsProperties.EditableText) == true
+
+        // If we're unable to retrieve the semantics configuration
+        // we should play safe and mask the whole node.
+        if (semantics == null) {
+            return GenericViewHierarchyNode(
+                x = visibleRect.left.toFloat(),
+                y = visibleRect.top.toFloat(),
+                width = node.width,
+                height = node.height,
+                elevation = (parent?.elevation ?: 0f),
+                distance = distance,
+                parent = parent,
+                shouldMask = true,
+                isImportantForContentCapture = false, /* will be set by children */
+                isVisible = isVisible,
+                visibleRect = visibleRect
+            )
+        }
+
         return when {
-            semantics?.contains(SemanticsProperties.Text) == true || isEditable -> {
+            semantics.contains(SemanticsProperties.Text) || isEditable -> {
                 val shouldMask = isVisible && semantics.shouldMask(isImage = false, options)
 
                 parent?.setImportantForCaptureToAncestors(true)
                 // TODO: if we get reports that it's slow, we can drop this, and just mask
                 // TODO: the whole view instead of per-line
                 val textLayoutResults = mutableListOf<TextLayoutResult>()
-                semantics?.getOrNull(SemanticsActions.GetTextLayoutResult)
+                semantics.getOrNull(SemanticsActions.GetTextLayoutResult)
                     ?.action
                     ?.invoke(textLayoutResults)
 

sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt

@@ -1,9 +1,13 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
 package io.sentry.android.replay.viewhierarchy
 
 import android.app.Activity
 import android.net.Uri
 import android.os.Bundle
 import android.os.Looper
+import android.view.View
+import android.view.ViewGroup
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.compose.foundation.layout.Arrangement
@@ -15,7 +19,9 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TextField
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.node.LayoutNode
 import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.SemanticsConfiguration
 import androidx.compose.ui.semantics.clearAndSetSemantics
 import androidx.compose.ui.semantics.editableText
 import androidx.compose.ui.semantics.invisibleToUser
@@ -27,6 +33,8 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import coil.compose.AsyncImage
+import io.sentry.ILogger
+import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.android.replay.maskAllImages
 import io.sentry.android.replay.maskAllText
@@ -39,15 +47,24 @@ import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarc
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
 import org.junit.Before
 import org.junit.runner.RunWith
+import org.mockito.Mockito
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoMoreInteractions
+import org.mockito.kotlin.whenever
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
 import java.io.File
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
+import kotlin.use
 
 @RunWith(AndroidJUnit4::class)
 @Config(sdk = [30])
@@ -139,6 +156,45 @@ class ComposeMaskingOptionsTest {
         assertTrue(imageNodes.all { it.shouldMask })
     }
 
+    @Test
+    fun `when retrieving the semantics fails, a node should be masked`() {
+        val activity = buildActivity(ComposeMaskingOptionsActivity::class.java).setup()
+        shadowOf(Looper.getMainLooper()).idle()
+        val options = SentryOptions()
+
+        Mockito.mockStatic(ComposeViewHierarchyNode::class.java).use { utils ->
+            utils.`when`<SemanticsConfiguration> { ComposeViewHierarchyNode.retrieveSemanticsConfiguration(any<LayoutNode>(), any()) }.thenReturn(null)
+
+            val root = activity.get().window.decorView
+            val composeView = root.lookupComposeView()
+            assertNotNull(composeView)
+
+            val rootNode = GenericViewHierarchyNode(0f, 0f, 0, 0, 1.0f, -1, shouldMask = true)
+            ComposeViewHierarchyNode.fromView(composeView, rootNode, options)
+
+            assertEquals(1, rootNode.children?.size)
+
+            rootNode.traverse { node ->
+                assertTrue(node.shouldMask)
+                true
+            }
+        }
+    }
+
+    @Test
+    fun `when retrieving the semantics fails, an error is logged once`() {
+        val logger = mock<ILogger>()
+
+        val node = mock<LayoutNode>()
+        whenever(node.collapsedSemantics).thenThrow(RuntimeException("Compose Runtime Error"))
+
+        ComposeViewHierarchyNode.retrieveSemanticsConfiguration(node, logger)
+        verify(logger).log(eq(SentryLevel.ERROR), any<RuntimeException>(), any<String>())
+
+        ComposeViewHierarchyNode.retrieveSemanticsConfiguration(node, logger)
+        verifyNoMoreInteractions(logger)
+    }
+
     @Test
     fun `when maskAllImages is set to false all Image nodes are unmasked`() {
         val activity = buildActivity(ComposeMaskingOptionsActivity::class.java).setup()
@@ -246,6 +302,22 @@ class ComposeMaskingOptionsTest {
         }
         return nodes
     }
+
+    private fun View.lookupComposeView(): View? {
+        if (this.javaClass.name.contains("AndroidComposeView")) {
+            return this
+        }
+        if (this is ViewGroup) {
+            for (i in 0 until childCount) {
+                val child = getChildAt(i)
+                val composeView = child.lookupComposeView()
+                if (composeView != null) {
+                    return composeView
+                }
+            }
+        }
+        return null
+    }
 }
 
 private class ComposeMaskingOptionsActivity : ComponentActivity() {