ANDROID-17023 Move Loggerazzi fixes to Snaptesting library (#14)

Author: DevPabloGarcia

README.md

@@ -94,6 +94,7 @@ Regular `connectedXXXXAndroidTest` target invocation is enough for verifications
 ```bash
 ./gradlew :app:connectedDebugAndroidTest
 ```
+At the end of each test, Loggerazzi compares the recorded logs with the corresponding baseline logs (previously generated in recording mode) allowing up to 5 seconds for the logs to match the expected output.
 
 In case of any failures due to screenshots or log verifications, regular JUnit reports include failed tests and the comparison failure reason.
 

android-snaptesting/src/main/java/com/telefonica/androidsnaptesting/logs/LogComparator.kt

@@ -9,7 +9,7 @@ public interface LogComparator<LogType> {
 public class DefaultLogComparator<LogType> : LogComparator<LogType> {
     override fun compare(recorded: List<LogType>, golden: List<LogType>): String? {
         if (recorded.size != golden.size) {
-            return "Different number of lines: recorded=${recorded.size}, golden=${golden.size}"
+            return "Different number of lines: golden=${golden.size}, recorded=${recorded.size}"
         }
 
         val compareResult = StringBuilder()
@@ -21,4 +21,29 @@ public class DefaultLogComparator<LogType> : LogComparator<LogType> {
 
         return compareResult.toString().takeIf { it.isNotEmpty() }
     }
-}
+}
+
+@Suppress("unused")
+public class AnyOrderLogComparator<LogType> : LogComparator<LogType> {
+    override fun compare(recorded: List<LogType>, golden: List<LogType>): String? {
+        val goldenSet = golden.toSet()
+        val recordedSet = recorded.toSet()
+
+        val missing = goldenSet - recordedSet
+        val extra = recordedSet - goldenSet
+
+        if (missing.isEmpty() && extra.isEmpty()) {
+            return null
+        }
+
+        val result = StringBuilder()
+        if (missing.isNotEmpty()) {
+            result.appendLine("Missing entries (in golden but not in recorded): ${missing.toList()}")
+        }
+        if (extra.isNotEmpty()) {
+            result.appendLine("Extra entries (in recorded but not in golden): ${extra.toList()}")
+        }
+
+        return result.toString().trimEnd()
+    }
+}

android-snaptesting/src/main/java/com/telefonica/androidsnaptesting/logs/LogsRule.kt

@@ -47,22 +47,54 @@ public open class GenericLogsRule<LogType>(
         val testName = "${description?.className}_${description?.methodName}"
         val fileName = "${testName}.txt.${System.nanoTime()}"
 
-        val recordedLogs = recorder.getRecordedLogs()
-        val log = recordedLogs.joinToString("\n") { stringMapper.fromLog(it) }
-        val testFile = File(directories.recordedDir, fileName)
-        testFile.createNewFile()
-        testFile.writeText(log)
+        val recordedLogs: List<LogType>
 
         if (InstrumentationRegistry.getArguments().getString("record") != "true" && !isTestIgnored) {
             val goldenFile = directories.context.assets.open("${directories.goldenFilesDir}/${testName}.txt")
             val goldenStringLogs = String(goldenFile.readBytes()).takeIf { it.isNotEmpty() }?.split("\n") ?: emptyList()
-            val result = comparator.compare(recordedLogs, goldenStringLogs.map { stringMapper.toLog(it) })
-            if (result != null) {
+            val comparison = compare(goldenStringLogs)
+            if (!comparison.success) {
                 val compareFile = File(directories.failuresDir, fileName)
                 compareFile.createNewFile()
-                compareFile.writeText(result)
-                throw AssertionError("Logs do not match:\n$result")
+                compareFile.writeText(comparison.failure!!)
+                throw AssertionError("Logs do not match:\n${comparison.failure}")
             }
+            recordedLogs = comparison.recordedLogs
+        } else {
+            recordedLogs = recorder.getRecordedLogs()
         }
+
+        val log = recordedLogs.joinToString("\n") { stringMapper.fromLog(it) }
+        val testFile = File(directories.recordedDir, fileName)
+        testFile.createNewFile()
+        testFile.writeText(log)
+    }
+
+    private fun compare(goldenStringLogs: List<String>): Comparison<LogType> {
+        val goldenLogs = goldenStringLogs.map { stringMapper.toLog(it) }
+        val startTime = System.currentTimeMillis()
+        var comparison: Comparison<LogType>
+        do {
+            val recordedLogs = recorder.getRecordedLogs()
+            val comparisonFailure = comparator.compare(recordedLogs, goldenLogs)
+            comparison = Comparison(comparisonFailure, recordedLogs)
+            if (!comparison.success) {
+                Thread.sleep(RESULT_POLLING_INTERVAL_MS)
+            }
+        } while (!comparison.success && System.currentTimeMillis() - startTime < RESULT_TIMEOUT_MS)
+        return comparison
+    }
+
+    private data class Comparison<LogType>(
+        val failure: String?,
+        val recordedLogs: List<LogType>,
+    ) {
+        val success: Boolean
+            get() = failure == null
+    }
+
+    private companion object {
+        const val RESULT_POLLING_INTERVAL_MS = 500L
+        const val RESULT_TIMEOUT_MS = 5000L
     }
 }

app/src/main/java/com/telefonica/androidsnaptesting/MainActivity.kt

@@ -2,10 +2,12 @@ package com.telefonica.androidsnaptesting
 
 import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
+import androidx.activity.enableEdgeToEdge
 
 class MainActivity : AppCompatActivity() {
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
         setContentView(R.layout.activity_main)
     }
 }

gradle/libs.versions.toml

@@ -2,8 +2,8 @@
 agp = "8.10.0"
 constraintlayout = "2.2.1"
 min-sdk = "23"
-target-sdk = "35"
-compile-sdk = "35"
+target-sdk = "36"
+compile-sdk = "36"
 material = "1.12.0"
 kotlin = "2.1.21"
 appcompat = "1.7.0"

include-build/gradle-plugin/src/main/java/com/telefonica/androidsnaptesting/AndroidSnaptestingPlugin.kt

@@ -55,13 +55,12 @@ class AndroidSnaptestingPlugin @Inject constructor(
         val recordedFolderFile = reportsFolder.dir("recorded").asFile.apply {
             mkdirs()
             deviceFileManager.pullRecordedSnapshots(absolutePath)
-            processAndFilterResults()
         }
         val failuresFolderFile = reportsFolder.dir("failures").asFile.apply {
             mkdirs()
             deviceFileManager.pullFailuresSnapshots(absolutePath)
-            processAndFilterResults()
         }
+        filterRecordedAndFailureResults(recordedFolderFile, failuresFolderFile)
         val goldenForFailuresReportFolderFile = reportsFolder.dir("golden").asFile.apply {
             mkdirs()
         }
@@ -133,22 +132,28 @@ class AndroidSnaptestingPlugin @Inject constructor(
         return replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }
     }
 
-    private fun File.processAndFilterResults() {
-        listFiles()
+    private fun filterRecordedAndFailureResults(recordedDir: File, failuresDir: File) {
+        recordedDir.listFiles()
             ?.groupBy {
                 it.name.substringBeforeLast(".")
             }
             ?.forEach { (key, filesGroup) ->
-                val lastFile = filesGroup.maxByOrNull {
+                val lastRecordedFile = filesGroup.maxByOrNull {
                     it.name.substringAfterLast(".").toLong()
                 }
                 filesGroup.forEach { file ->
-                    if (file != lastFile) {
+                    if (file != lastRecordedFile) {
                         file.delete()
+                        File(failuresDir, file.name).takeIf { it.exists() }?.delete()
                     }
                 }
-
-                lastFile?.renameTo(File(this, key))
+                if (lastRecordedFile != null) {
+                    lastRecordedFile
+                        .renameTo(File(recordedDir, "$key.txt"))
+                    File(failuresDir, lastRecordedFile.name)
+                        .takeIf { it.exists() }
+                        ?.renameTo(File(failuresDir, "$key.txt"))
+                }
             }
     }
 }