Add Paparazzi snapshot testing pipeline (#36)

* Add Paparazzi snapshot testing pipeline

Apply the Paparazzi plugin (2.0.0-alpha02, the line that supports this repo's
Kotlin 2.2 / AGP 8.13 toolchain) and add snapshot tests for the AI compose
components.

PaparazziTest is the shared base: it renders inside MaterialTheme and Surface (the
module has no ChatTheme), enables LocalInspectionMode, and provides a no-op
ActivityResultRegistryOwner so the composer's photo-picker launcher renders without
a host activity. Tests cover AITypingIndicator, ChatComposer, and SpeechToTextButton,
producing 9 golden images.

Preview content for each state is extracted into shared internal composables that
both the @Preview functions and the snapshot tests call, so they cannot drift apart.

Snapshot verification runs on CI through the unit test job, which now runs
verifyPaparazziDebug (a superset that also runs the regular unit tests).

* Add StreamingText snapshot and render full text on first non-animated frame

StreamingText revealed its text through a LaunchedEffect, so the first composition
showed empty text before the effect ran. When animate is false, initialize the
displayed text to the full text so it appears immediately, matching the documented
behavior and letting it render in a single Paparazzi frame.

Add the StreamingText snapshot test and its shared preview content function.

* Verify snapshots through testCoverage instead of verifyPaparazziDebug

Align with the other Stream repos: the convention plugin registers a testCoverage task
that runs verifyPaparazziDebug for modules with the Paparazzi plugin. Opt the module into
coverage.includedModules and apply the Paparazzi plugin first so the convention detects it,
then run testCoverage on CI.

Author: andremion

.github/workflows/ci.yml

@@ -64,12 +64,14 @@ jobs:
 
       - uses: GetStream/android-ci-actions/actions/gradle-cache@main
 
-      - name: Run unit tests
-        run: ./gradlew testDebugUnitTest --stacktrace
+      - name: Run unit tests and verify snapshots
+        run: ./gradlew testCoverage --stacktrace
 
       - name: Unit tests results
         uses: actions/upload-artifact@v7
         if: failure()
         with:
           name: unit-tests-results
-          path: ./**/build/reports/tests/**
+          path: |
+            ./**/build/reports/tests/**
+            ./**/build/paparazzi/**

build.gradle.kts

@@ -11,6 +11,9 @@ plugins {
 
 streamProject {
     repositoryName.set("stream-chat-android-ai")
+    coverage {
+        includedModules.set(setOf("stream-chat-android-ai-compose"))
+    }
     publishing {
         description.set("Official AI components for Stream Android Chat SDK")
     }

gradle/libs.versions.toml

@@ -20,6 +20,7 @@ streamChatAndroid = "7.0.0"
 retrofit = "2.11.0"
 okhttp = "4.12.0"
 moshi = "1.15.1"
+paparazzi = "2.0.0-alpha02"
 
 [libraries]
 detekt-formatting = { group = "io.gitlab.arturbosch.detekt", name = "detekt-formatting", version.ref = "detekt" }
@@ -60,6 +61,7 @@ arturbosch-detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt"
 stream-project = { id = "io.getstream.project", version.ref = "streamConventions" }
 stream-android-library = { id = "io.getstream.android.library", version.ref = "streamConventions" }
 stream-android-application = { id = "io.getstream.android.application", version.ref = "streamConventions" }
+paparazzi = { id = "app.cash.paparazzi", version.ref = "paparazzi" }
 
 [bundles]
 stream-chat = [

stream-chat-android-ai-compose/build.gradle.kts

@@ -1,6 +1,7 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
+    alias(libs.plugins.paparazzi)
     alias(libs.plugins.stream.android.library)
     alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)

stream-chat-android-ai-compose/src/main/kotlin/io/getstream/chat/android/ai/compose/ui/component/AITypingIndicator.kt

@@ -165,8 +165,13 @@ private const val ANIMATION_DOUBLE = 2f
 private const val SMOOTHSTEP_FACTOR_1 = 3f
 private const val SMOOTHSTEP_FACTOR_2 = 2f
 
+@Composable
+internal fun AITypingIndicatorWithLabel() {
+    AITypingIndicator(label = { Text(text = "Thinking") })
+}
+
 @Preview(showBackground = true)
 @Composable
-private fun AITypingIndicatorPreview() {
-    AITypingIndicator(label = { Text("Thinking") })
+private fun AITypingIndicatorWithLabelPreview() {
+    AITypingIndicatorWithLabel()
 }

stream-chat-android-ai-compose/src/main/kotlin/io/getstream/chat/android/ai/compose/ui/component/ChatComposer.kt

@@ -441,68 +441,93 @@ private fun Context.openSettings() {
     startActivity(intent)
 }
 
+@Composable
+internal fun ChatComposerEmpty() {
+    ChatComposer(
+        onSendClick = {},
+        onStopClick = {},
+        isGenerating = false,
+    )
+}
+
+@Composable
+internal fun ChatComposerFilled() {
+    ChatComposer(
+        messageData = MessageData(text = "What is Stream Chat?"),
+        onSendClick = {},
+        onStopClick = {},
+        isGenerating = false,
+    )
+}
+
+@Composable
+internal fun ChatComposerLongFilled() {
+    ChatComposer(
+        messageData = MessageData(text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."),
+        onSendClick = {},
+        onStopClick = {},
+        isGenerating = false,
+    )
+}
+
+@Composable
+internal fun ChatComposerWithAttachments() {
+    ChatComposer(
+        messageData = MessageData(
+            text = "What is Stream Chat?",
+            attachments = setOf("1".toUri(), "2".toUri(), "3".toUri()),
+        ),
+        onSendClick = {},
+        onStopClick = {},
+        isGenerating = false,
+    )
+}
+
+@Composable
+internal fun ChatComposerGenerating() {
+    ChatComposer(
+        onSendClick = {},
+        onStopClick = {},
+        isGenerating = true,
+    )
+}
+
 @Preview(showBackground = true)
 @Composable
 private fun ChatComposerEmptyPreview() {
     MaterialTheme {
-        ChatComposer(
-            onSendClick = {},
-            onStopClick = {},
-            isGenerating = false,
-        )
+        ChatComposerEmpty()
     }
 }
 
 @Preview(showBackground = true)
 @Composable
 private fun ChatComposerFilledPreview() {
     MaterialTheme {
-        ChatComposer(
-            messageData = MessageData(text = "What is Stream Chat?"),
-            onSendClick = {},
-            onStopClick = {},
-            isGenerating = false,
-        )
+        ChatComposerFilled()
     }
 }
 
 @Preview(showBackground = true)
 @Composable
 private fun ChatComposerLongFilledPreview() {
     MaterialTheme {
-        ChatComposer(
-            messageData = MessageData(text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit."),
-            onSendClick = {},
-            onStopClick = {},
-            isGenerating = false,
-        )
+        ChatComposerLongFilled()
     }
 }
 
 @Preview(showBackground = true)
 @Composable
 private fun ChatComposerWithAttachmentsPreview() {
     MaterialTheme {
-        ChatComposer(
-            messageData = MessageData(
-                text = "What is Stream Chat?",
-                attachments = setOf("1".toUri(), "2".toUri(), "3".toUri()),
-            ),
-            onSendClick = {},
-            onStopClick = {},
-            isGenerating = false,
-        )
+        ChatComposerWithAttachments()
     }
 }
 
 @Preview(showBackground = true)
 @Composable
 private fun ChatComposerGeneratingPreview() {
     MaterialTheme {
-        ChatComposer(
-            onSendClick = {},
-            onStopClick = {},
-            isGenerating = true,
-        )
+        ChatComposerGenerating()
     }
 }

stream-chat-android-ai-compose/src/main/kotlin/io/getstream/chat/android/ai/compose/ui/component/SpeechToTextButton.kt

@@ -280,16 +280,14 @@ private fun VoiceRecordingBars(
     }
 }
 
-@Preview(showBackground = true)
 @Composable
-private fun SpeechToTextButtonIdlePreview() {
+internal fun SpeechToTextButtonIdle() {
     val state = rememberSpeechToTextButtonState { }
     SpeechToTextButton(state = state)
 }
 
-@Preview(showBackground = true)
 @Composable
-private fun SpeechToTextButtonRecordingPreview() {
+internal fun SpeechToTextButtonRecording() {
     val state = remember {
         SpeechToTextButtonState(
             helper = object : SpeechRecognizerHelper {
@@ -300,3 +298,15 @@ private fun SpeechToTextButtonRecordingPreview() {
     }
     SpeechToTextButton(state = state)
 }
+
+@Preview(showBackground = true)
+@Composable
+private fun SpeechToTextButtonIdlePreview() {
+    SpeechToTextButtonIdle()
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun SpeechToTextButtonRecordingPreview() {
+    SpeechToTextButtonRecording()
+}

stream-chat-android-ai-compose/src/main/kotlin/io/getstream/chat/android/ai/compose/ui/component/StreamingText.kt

@@ -22,6 +22,7 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.tooling.preview.Preview
 import io.getstream.chat.android.ai.compose.ui.component.internal.RichText
 import kotlinx.coroutines.delay
 
@@ -52,8 +53,9 @@ public fun StreamingText(
         RichText(text = displayedText)
     },
 ) {
-    // Track the displayed text for animation
-    var displayedText by remember { mutableStateOf("") }
+    // Track the displayed text for animation. When not animating, start with the full text so
+    // the first frame shows it immediately instead of flashing empty before the effect runs.
+    var displayedText by remember { mutableStateOf(if (animate) "" else text) }
     // Track the previous full text to detect new text vs continuation
     var previousText by remember { mutableStateOf("") }
     // Track previous animate value to detect transition from true to false
@@ -181,3 +183,17 @@ private fun splitIntoWords(text: String): List<String> {
 
 // Regex to match whitespace or non-whitespace sequences for chunking.
 private val WordSplitRegex = Regex("""(\s+|\S+)""")
+
+@Composable
+internal fun StreamingTextRendered() {
+    StreamingText(
+        text = "Hello, I am the Stream AI assistant. How can I help you today?",
+        animate = false,
+    )
+}
+
+@Preview(showBackground = true)
+@Composable
+private fun StreamingTextPreview() {
+    StreamingTextRendered()
+}

stream-chat-android-ai-compose/src/test/kotlin/io/getstream/chat/android/ai/compose/ui/PaparazziTest.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2014-2026 Stream.io Inc. All rights reserved.
+ *
+ * Licensed under the Stream License;
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://github.com/GetStream/stream-chat-android-ai/blob/main/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.getstream.chat.android.ai.compose.ui
+
+import androidx.activity.compose.LocalActivityResultRegistryOwner
+import androidx.activity.result.ActivityResultRegistry
+import androidx.activity.result.ActivityResultRegistryOwner
+import androidx.activity.result.contract.ActivityResultContract
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.ui.platform.LocalInspectionMode
+import androidx.core.app.ActivityOptionsCompat
+import app.cash.paparazzi.Paparazzi
+
+/**
+ * Base for Paparazzi snapshot tests of the AI compose components.
+ *
+ * Implementers expose a [Paparazzi] rule and call [snapshot] to render a component inside the
+ * shared test environment: [MaterialTheme] (the module has no `ChatTheme`), with
+ * [LocalInspectionMode] enabled and a no-op [ActivityResultRegistryOwner] so components that use
+ * `rememberLauncherForActivityResult` (such as the composer) render without a host activity.
+ */
+internal interface PaparazziTest {
+
+    val paparazzi: Paparazzi
+
+    fun snapshot(name: String? = null, composable: @Composable () -> Unit) {
+        paparazzi.snapshot(name) {
+            CompositionLocalProvider(
+                LocalInspectionMode provides true,
+                LocalActivityResultRegistryOwner provides NoOpResultRegistryOwner,
+            ) {
+                MaterialTheme {
+                    Surface {
+                        composable()
+                    }
+                }
+            }
+        }
+    }
+}
+
+private val NoOpResultRegistryOwner = object : ActivityResultRegistryOwner {
+    override val activityResultRegistry = object : ActivityResultRegistry() {
+        override fun <I, O> onLaunch(
+            requestCode: Int,
+            contract: ActivityResultContract<I, O>,
+            input: I,
+            options: ActivityOptionsCompat?,
+        ) {
+            // No-op: snapshots never launch activities.
+        }
+    }
+}

stream-chat-android-ai-compose/src/test/kotlin/io/getstream/chat/android/ai/compose/ui/component/AITypingIndicatorTest.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2014-2026 Stream.io Inc. All rights reserved.
+ *
+ * Licensed under the Stream License;
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://github.com/GetStream/stream-chat-android-ai/blob/main/LICENSE
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.getstream.chat.android.ai.compose.ui.component
+
+import app.cash.paparazzi.DeviceConfig
+import app.cash.paparazzi.Paparazzi
+import com.android.ide.common.rendering.api.SessionParams.RenderingMode
+import io.getstream.chat.android.ai.compose.ui.PaparazziTest
+import org.junit.Rule
+import org.junit.Test
+
+internal class AITypingIndicatorTest : PaparazziTest {
+
+    @get:Rule
+    override val paparazzi = Paparazzi(
+        deviceConfig = DeviceConfig.PIXEL_5,
+        renderingMode = RenderingMode.SHRINK,
+    )
+
+    @Test
+    fun default() {
+        snapshot {
+            AITypingIndicator()
+        }
+    }
+
+    @Test
+    fun `with label`() {
+        snapshot {
+            AITypingIndicatorWithLabel()
+        }
+    }
+}