refactor: Structural output refresh last run

buildSrc/src/main/kotlin/Dependencies.kt

@@ -56,6 +56,7 @@ object Dependencies {
     const val SYSTEM_RULES = "com.github.stefanbirkner:system-rules:${Versions.SYSTEM_RULES}"
     const val TRUTH = "com.google.truth:truth:${Versions.TRUTH}"
     const val MOCKK = "io.mockk:mockk:${Versions.MOCKK}"
+    const val KOTLIN_COROUTINES_TEST = "org.jetbrains.kotlinx:kotlinx-coroutines-test:${Versions.KOTLIN_COROUTINES}"
     //endregion
 
     const val COMMON_TEXT = "org.apache.commons:commons-text:${Versions.COMMON_TEXT}"

check_version_updated/src/main/kotlin/com/github/flank/gradle/CheckVersionUpdatedTask.kt

@@ -11,8 +11,12 @@ open class CheckVersionUpdatedTask : DefaultTask() {
     @TaskAction
     fun action() {
         project.execAndGetStdout("git", "fetch", "--no-tags")
-        val changedFiles = project.execAndGetStdout("git", "diff", "origin/master", "HEAD", "--name-only").split("\n") +
-            project.execAndGetStdout("git", "diff", "origin/master", "--name-only").split("\n")
+        val changedFiles = (project.execAndGetStdout("git", "diff", "origin/master", "HEAD", "--name-only").split("\n") +
+            project.execAndGetStdout("git", "diff", "origin/master", "--name-only").split("\n"))
+            .toSet()
+            .filterNot { file -> ignoredFiles.any { ignoredFile -> file.endsWith(ignoredFile) } }
+
+
         val isVersionChanged = changedFiles.any { it.startsWith(project.name) }.not() ||
             (changedFiles.contains("${project.name}/build.gradle.kts") && project.isVersionChangedInBuildGradle())
 
@@ -44,4 +48,6 @@ open class CheckVersionUpdatedTask : DefaultTask() {
         return (commitedResultsStream + localResultsStream)
             .any { it.startsWith("-version = ") || it.startsWith("+version = ") }
     }
+
+    private val ignoredFiles = listOf("gradle-wrapper.properties", "main/resources/version.txt")
 }

flank_wrapper/build.gradle.kts

@@ -24,7 +24,7 @@ shadowJar.apply {
     }
 }
 // <breaking change>.<feature added>.<fix/minor change>
-version = "1.2.4"
+version = "1.2.5"
 group = "com.github.flank"
 
 repositories {

test_runner/build.gradle.kts

@@ -217,6 +217,7 @@ dependencies {
     testImplementation(Dependencies.SYSTEM_RULES)
     testImplementation(Dependencies.TRUTH)
     testImplementation(Dependencies.MOCKK)
+    testImplementation(Dependencies.KOTLIN_COROUTINES_TEST)
 }
 
 buildscript {
@@ -231,6 +232,10 @@ buildscript {
 
 tasks.withType<KotlinCompile> {
     kotlinOptions.jvmTarget = "1.8"
+    kotlinOptions.freeCompilerArgs += listOf(
+        "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+        "-Xopt-in=kotlinx.coroutines.FlowPreview",
+    )
 }
 
 // https://github.com/gradle/kotlin-dsl/blob/master/samples/task-dependencies/build.gradle.kts#L41

test_runner/src/main/kotlin/ftl/client/google/AndroidCatalog.kt

@@ -4,12 +4,9 @@ import com.google.testing.model.AndroidDevice
 import com.google.testing.model.AndroidDeviceCatalog
 import com.google.testing.model.AndroidModel
 import com.google.testing.model.Orientation
-import flank.common.logLn
-import ftl.api.fetchAndroidOsVersion
-import ftl.environment.android.getDescription
-import ftl.environment.getLocaleDescription
 import ftl.http.executeWithRetry
-import ftl.presentation.cli.firebase.test.android.versions.toCliTable
+import ftl.presentation.cli.firebase.test.reportmanager.ReportManagerState
+import ftl.presentation.publish
 
 /**
  * Contains lists of possible Android device and version ids, as well as checks
@@ -34,19 +31,9 @@ object AndroidCatalog {
 
     fun getModels(projectId: String): List<AndroidModel> = deviceCatalog(projectId).models.orEmpty()
 
-    fun supportedVersionsAsTable(projectId: String) = fetchAndroidOsVersion(projectId).toCliTable()
-
-    fun describeSoftwareVersion(projectId: String, versionId: String) =
-        fetchAndroidOsVersion(projectId).getDescription(versionId)
-
-    private fun getVersionsList(projectId: String) = deviceCatalog(projectId).versions
-
     fun supportedOrientations(projectId: String): List<Orientation> =
         deviceCatalog(projectId).runtimeConfiguration.orientations
 
-    private fun getLocaleDescription(projectId: String, locale: String) =
-        getLocales(projectId).getLocaleDescription(locale)
-
     internal fun getLocales(projectId: String) = deviceCatalog(projectId).runtimeConfiguration.locales
 
     fun androidModelIds(projectId: String) =
@@ -64,7 +51,9 @@ object AndroidCatalog {
         val form = deviceCatalog(projectId).models
             .find { it.id.equals(modelId, ignoreCase = true) }?.form
             ?: DeviceType.PHYSICAL.name.also {
-                logLn("Unable to find device type for $modelId. PHYSICAL used as fallback in cost calculations")
+                ReportManagerState.Log(
+                    "Unable to find device type for $modelId. PHYSICAL used as fallback in cost calculations"
+                ).publish()
             }
 
         return form.equals(DeviceType.VIRTUAL.name, ignoreCase = true) || form.equals(

test_runner/src/main/kotlin/ftl/client/google/GcStorage.kt

@@ -106,6 +106,7 @@ object GcStorage {
         path: String,
         name: String
     ) {
+        // TODO #2136 handle messages with state
         runWithProgress(
             startMessage = "Uploading [$name] to ${GCS_STORAGE_LINK + join(bucket, path).replace(name, "")}..",
             action = { storage.create(BlobInfo.newBuilder(bucket, path).build(), this) },

test_runner/src/main/kotlin/ftl/domain/RefreshLastRun.kt

@@ -1,13 +1,26 @@
 package ftl.domain
 
 import ftl.args.AndroidArgs
+import ftl.presentation.Output
+import ftl.presentation.RunState
+import ftl.presentation.runBlockingWithObservingRunState
 import ftl.run.refreshLastRun
 
-interface RefreshLastRun
+interface RefreshLastRun : Output
 
-suspend operator fun RefreshLastRun.invoke() {
-    refreshLastRun(
-        currentArgs = AndroidArgs.default(),
-        testShardChunks = emptyList()
-    )
+operator fun RefreshLastRun.invoke() {
+    runBlockingWithObservingRunState {
+        refreshLastRun(
+            currentArgs = AndroidArgs.default(),
+            testShardChunks = emptyList()
+        )
+    }
+}
+
+sealed interface RefreshLastRunState : RunState {
+    data class LoadingRun(val lastRun: String) : RefreshLastRunState
+    object RefreshMatricesStarted : RefreshLastRunState
+    data class RefreshMatrices(val matrixCount: Int) : RefreshLastRunState
+    data class RefreshMatrix(val matrixState: String, val matrixId: String) : RefreshLastRunState
+    object UpdatingMatrixFile : RefreshLastRunState
 }

test_runner/src/main/kotlin/ftl/domain/RunTestAndroid.kt

@@ -10,6 +10,8 @@ import ftl.config.defaultAndroidConfig
 import ftl.config.loadAndroidConfig
 import ftl.config.plus
 import ftl.mock.MockServer
+import ftl.presentation.Output
+import ftl.presentation.runBlockingWithObservingRunState
 import ftl.reports.addStepTime
 import ftl.reports.output.configure
 import ftl.reports.output.log
@@ -24,10 +26,9 @@ import ftl.util.TEST_TYPE
 import ftl.util.loadFile
 import ftl.util.printVersionInfo
 import ftl.util.setCrashReportTag
-import kotlinx.coroutines.runBlocking
 import java.nio.file.Paths
 
-interface RunTestAndroid {
+interface RunTestAndroid : Output {
     val configPath: String
     val config: AndroidConfig
     val dryRun: Boolean
@@ -59,7 +60,7 @@ operator fun RunTestAndroid.invoke() {
         )
         reportConfiguration()
     }.validate().also { args ->
-        runBlocking {
+        runBlockingWithObservingRunState {
             if (dumpShards)
                 args.dumpShards()
             else {

test_runner/src/main/kotlin/ftl/domain/RunTestIos.kt

@@ -10,6 +10,8 @@ import ftl.config.defaultIosConfig
 import ftl.config.loadIosConfig
 import ftl.config.plus
 import ftl.mock.MockServer
+import ftl.presentation.Output
+import ftl.presentation.runBlockingWithObservingRunState
 import ftl.reports.addStepTime
 import ftl.reports.output.configure
 import ftl.reports.output.log
@@ -24,10 +26,9 @@ import ftl.util.TEST_TYPE
 import ftl.util.loadFile
 import ftl.util.printVersionInfo
 import ftl.util.setCrashReportTag
-import kotlinx.coroutines.runBlocking
 import java.nio.file.Paths
 
-interface RunIosTest {
+interface RunIosTest : Output {
     val configPath: String
     val config: IosConfig
     val dryRun: Boolean
@@ -63,7 +64,7 @@ operator fun RunIosTest.invoke() {
         if (dumpShards.not()) logLn(this)
     }.validate().run {
         if (dumpShards) dumpShards()
-        else runBlocking {
+        else runBlockingWithObservingRunState {
             addStepTime("Preparation", prepareStopWatch.check())
             newTestRun()
         }

test_runner/src/main/kotlin/ftl/presentation/RunState.kt

@@ -0,0 +1,28 @@
+package ftl.presentation
+
+import com.google.common.annotations.VisibleForTesting
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+
+interface RunState
+
+@VisibleForTesting
+internal val runSharedFlow by lazy {
+    MutableSharedFlow<RunState>(extraBufferCapacity = 1)
+}
+
+internal fun Output.runBlockingWithObservingRunState(block: suspend () -> Unit) {
+    runBlocking {
+        val runStateCollectJob = launch {
+            runSharedFlow.collect { runState -> runState.out() }
+        }
+        block()
+        runStateCollectJob.cancel()
+    }
+}
+
+internal fun RunState.publish() {
+    runSharedFlow.tryEmit(this)
+}

test_runner/src/main/kotlin/ftl/presentation/cli/FirebaseCommand.kt

@@ -1,8 +1,8 @@
 package ftl.presentation.cli
 
 import ftl.presentation.cli.firebase.CancelCommand
-import ftl.presentation.cli.firebase.RefreshCommand
 import ftl.presentation.cli.firebase.TestCommand
+import ftl.presentation.cli.firebase.test.refresh.RefreshCommand
 import ftl.util.PrintHelpCommand
 import picocli.CommandLine.Command
 

test_runner/src/main/kotlin/ftl/presentation/cli/MainCommand.kt

@@ -2,12 +2,12 @@ package ftl.presentation.cli
 
 import ftl.log.setDebugLogging
 import ftl.presentation.cli.firebase.CancelCommand
-import ftl.presentation.cli.firebase.RefreshCommand
 import ftl.presentation.cli.firebase.test.AndroidCommand
 import ftl.presentation.cli.firebase.test.IPBlocksCommand
 import ftl.presentation.cli.firebase.test.IosCommand
 import ftl.presentation.cli.firebase.test.NetworkProfilesCommand
 import ftl.presentation.cli.firebase.test.ProvidedSoftwareCommand
+import ftl.presentation.cli.firebase.test.refresh.RefreshCommand
 import ftl.util.PrintHelpCommand
 import ftl.util.printVersionInfo
 import picocli.CommandLine

test_runner/src/main/kotlin/ftl/presentation/cli/firebase/test/android/AndroidRunCommand.kt

@@ -7,6 +7,10 @@ import ftl.config.createConfiguration
 import ftl.domain.RunTestAndroid
 import ftl.domain.invoke
 import ftl.presentation.cli.firebase.test.CommonRunCommand
+import ftl.presentation.cli.firebase.test.reportmanager.ReportManagerState
+import ftl.presentation.cli.firebase.test.reportmanager.handleReportManagerState
+import ftl.presentation.outputLogger
+import ftl.presentation.throwUnknownType
 import ftl.run.ANDROID_SHARD_FILE
 import picocli.CommandLine
 import picocli.CommandLine.Command
@@ -52,4 +56,12 @@ class AndroidRunCommand :
     }
 
     override fun run() = invoke()
+
+    override val out = outputLogger {
+        // TODO add more types in #1870
+        when (this) {
+            is ReportManagerState -> handleReportManagerState(this)
+            else -> throwUnknownType()
+        }
+    }
 }

test_runner/src/main/kotlin/ftl/presentation/cli/firebase/test/ios/IosRunCommand.kt

@@ -7,6 +7,10 @@ import ftl.config.ios.IosGcloudConfig
 import ftl.domain.RunIosTest
 import ftl.domain.invoke
 import ftl.presentation.cli.firebase.test.CommonRunCommand
+import ftl.presentation.cli.firebase.test.reportmanager.ReportManagerState
+import ftl.presentation.cli.firebase.test.reportmanager.handleReportManagerState
+import ftl.presentation.outputLogger
+import ftl.presentation.throwUnknownType
 import ftl.run.IOS_SHARD_FILE
 import picocli.CommandLine
 import picocli.CommandLine.Command
@@ -52,4 +56,12 @@ class IosRunCommand :
     }
 
     override fun run() = invoke()
+
+    override val out = outputLogger {
+        // TODO add more types in #1871
+        when (this) {
+            is ReportManagerState -> handleReportManagerState(this)
+            else -> throwUnknownType()
+        }
+    }
 }

test_runner/src/main/kotlin/ftl/presentation/cli/firebase/test/refresh/HandleRefreshRunState.kt

@@ -0,0 +1,12 @@
+package ftl.presentation.cli.firebase.test.refresh
+
+import ftl.config.FtlConstants
+import ftl.domain.RefreshLastRunState
+
+internal fun handleRefreshLastRunState(state: RefreshLastRunState): String = when (state) {
+    is RefreshLastRunState.LoadingRun -> "Loading run ${state.lastRun}"
+    is RefreshLastRunState.RefreshMatrices -> "${FtlConstants.indent}Refreshing ${state.matrixCount}x matrices"
+    RefreshLastRunState.RefreshMatricesStarted -> "RefreshMatrices"
+    is RefreshLastRunState.RefreshMatrix -> "${FtlConstants.indent} ${state.matrixState} ${state.matrixId}"
+    RefreshLastRunState.UpdatingMatrixFile -> "${FtlConstants.indent}Updating matrix file"
+}

test_runner/src/main/kotlin/ftl/presentation/cli/firebase/RefreshCommand.kt → test_runner/src/main/kotlin/ftl/presentation/cli/firebase/test/refresh/RefreshCommand.kt

@@ -1,9 +1,13 @@
-package ftl.presentation.cli.firebase
+package ftl.presentation.cli.firebase.test.refresh
 
 import ftl.domain.RefreshLastRun
+import ftl.domain.RefreshLastRunState
 import ftl.domain.invoke
+import ftl.presentation.cli.firebase.test.reportmanager.ReportManagerState
+import ftl.presentation.cli.firebase.test.reportmanager.handleReportManagerState
+import ftl.presentation.outputLogger
+import ftl.presentation.throwUnknownType
 import ftl.util.PrintHelpCommand
-import kotlinx.coroutines.runBlocking
 import picocli.CommandLine.Command
 
 @Command(
@@ -26,5 +30,14 @@ class RefreshCommand :
     PrintHelpCommand(),
     RefreshLastRun {
 
-    override fun run() = runBlocking { invoke() }
+    override fun run() = invoke()
+
+    override val out = outputLogger {
+        when (this) {
+            is RefreshLastRunState -> handleRefreshLastRunState(this)
+            is ReportManagerState -> handleReportManagerState(this)
+            // TODO #2136 handle uploading file here
+            else -> throwUnknownType()
+        }
+    }
 }

test_runner/src/main/kotlin/ftl/presentation/cli/firebase/test/reportmanager/HandleReportManagerState.kt

@@ -0,0 +1,21 @@
+package ftl.presentation.cli.firebase.test.reportmanager
+
+import flank.common.newLine
+import flank.common.withNewLineAtTheEnd
+import ftl.presentation.RunState
+import ftl.reports.util.ReportManager
+import kotlin.math.roundToInt
+
+sealed interface ReportManagerState : RunState {
+    data class Log(val message: String) : ReportManagerState
+    data class Warning(val message: String) : ReportManagerState
+    data class ShardTimes(val shards: List<ReportManager.ShardEfficiency>) : ReportManagerState
+}
+
+internal fun handleReportManagerState(state: ReportManagerState): String = when (state) {
+    is ReportManagerState.Log -> state.message
+    is ReportManagerState.Warning -> "WARNING: ${state.message}"
+    is ReportManagerState.ShardTimes -> "Actual shard times:$newLine" + state.shards.joinToString(newLine) {
+        "  ${it.shard}: Expected: ${it.expectedTime.roundToInt()}s, Actual: ${it.finalTime.roundToInt()}s, Diff: ${it.timeDiff.roundToInt()}s"
+    }.withNewLineAtTheEnd()
+}

test_runner/src/main/kotlin/ftl/reports/MatrixResultsReport.kt

@@ -10,6 +10,8 @@ import ftl.config.FtlConstants.indent
 import ftl.json.MatrixMap
 import ftl.json.asPrintableTable
 import ftl.json.isFailed
+import ftl.presentation.cli.firebase.test.reportmanager.ReportManagerState
+import ftl.presentation.publish
 import ftl.reports.output.log
 import ftl.reports.output.outputReport
 import ftl.reports.util.IReport
@@ -36,7 +38,7 @@ object MatrixResultsReport : IReport {
 
     override fun run(matrices: MatrixMap, result: JUnitTest.Result?, printToStdout: Boolean, args: IArgs) {
         val output = generate(matrices)
-        if (printToStdout) log(output)
+        if (printToStdout) ReportManagerState.Log(output).publish()
         write(matrices, output, args)
         ReportManager.uploadReportResult(output, args, fileName())
     }