Add integration with Teamcity status message

configuration/src/main/kotlin/com/malinskiy/marathon/config/Configuration.kt

@@ -48,6 +48,8 @@ data class Configuration private constructor(
 
     val analyticsTracking: Boolean,
     val deviceInitializationTimeoutMillis: Long,
+
+    val buildSystem: String,
 ) {
     fun toMap() =
         mapOf<String, String>(
@@ -73,7 +75,8 @@ data class Configuration private constructor(
             "debug" to debug.toString(),
             "screenRecordingPolicy" to screenRecordingPolicy.toString(),
             "vendorConfiguration" to vendorConfiguration.toString(),
-            "deviceInitializationTimeoutMillis" to deviceInitializationTimeoutMillis.toString()
+            "deviceInitializationTimeoutMillis" to deviceInitializationTimeoutMillis.toString(),
+            "buildSystem" to buildSystem
         )
 
     override fun equals(other: Any?): Boolean {
@@ -108,6 +111,7 @@ data class Configuration private constructor(
         if (vendorConfiguration != other.vendorConfiguration) return false
         if (analyticsTracking != other.analyticsTracking) return false
         if (deviceInitializationTimeoutMillis != other.deviceInitializationTimeoutMillis) return false
+        if (buildSystem != other.buildSystem) return false
 
         return true
     }
@@ -138,6 +142,7 @@ data class Configuration private constructor(
         result = 31 * result + vendorConfiguration.hashCode()
         result = 31 * result + analyticsTracking.hashCode()
         result = 31 * result + deviceInitializationTimeoutMillis.hashCode()
+        result = 31 * result + buildSystem.hashCode()
         return result
     }
 
@@ -175,6 +180,8 @@ data class Configuration private constructor(
         var analyticsTracking: Boolean = false
         var deviceInitializationTimeoutMillis: Long = DEFAULT_DEVICE_INITIALIZATION_TIMEOUT_MILLIS
 
+        var buildSystem = ""
+
         fun build(): Configuration {
             return Configuration(
                 name = name,
@@ -201,7 +208,8 @@ data class Configuration private constructor(
                 screenRecordingPolicy = screenRecordingPolicy,
                 vendorConfiguration = vendorConfiguration,
                 analyticsTracking = analyticsTracking,
-                deviceInitializationTimeoutMillis = deviceInitializationTimeoutMillis
+                deviceInitializationTimeoutMillis = deviceInitializationTimeoutMillis,
+                buildSystem = buildSystem
             )
         }
     }

core/build.gradle.kts

@@ -41,6 +41,7 @@ buildConfig {
 
 dependencies {
     api(project(":configuration"))
+    implementation(project(":integrations:buildsystem"))
     implementation(project(":report:html-report"))
     implementation(project(":report:execution-timeline"))
 

core/src/main/kotlin/com/malinskiy/marathon/execution/progress/ProgressReporter.kt

@@ -4,6 +4,9 @@ import com.malinskiy.marathon.config.Configuration
 import com.malinskiy.marathon.device.DeviceInfo
 import com.malinskiy.marathon.device.DevicePoolId
 import com.malinskiy.marathon.execution.progress.tracker.PoolProgressTracker
+import com.malinskiy.marathon.integrations.buildsystem.BuildSystem
+import com.malinskiy.marathon.integrations.buildsystem.BuildSystemId
+import com.malinskiy.marathon.integrations.buildsystem.Teamcity
 import com.malinskiy.marathon.test.Test
 import com.malinskiy.marathon.test.toTestName
 import java.util.concurrent.ConcurrentHashMap
@@ -13,6 +16,14 @@ const val HUNDRED_PERCENT_IN_FLOAT: Float = 100.0f
 
 class ProgressReporter(private val configuration: Configuration) {
     private val reporters = ConcurrentHashMap<DevicePoolId, PoolProgressTracker>()
+    private val buildSystem = if (configuration.buildSystem.isNotEmpty())
+        BuildSystemId
+            .valueOf(configuration.buildSystem)
+            .let {
+                when (it) {
+                    BuildSystemId.Teamcity -> Teamcity
+                } as BuildSystem
+            } else null
 
     private inline fun <T> execute(poolId: DevicePoolId, f: (PoolProgressTracker) -> T): T {
         val reporter = reporters[poolId] ?: PoolProgressTracker(configuration)
@@ -29,22 +40,30 @@ class ProgressReporter(private val configuration: Configuration) {
 
     fun testStarted(poolId: DevicePoolId, device: DeviceInfo, test: Test) {
         execute(poolId) { it.testStarted(test) }
-        println("${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} started")
+        val message = "${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} started"
+        println(message)
+        buildSystem?.setBuildMessage(message)
     }
 
     fun testFailed(poolId: DevicePoolId, device: DeviceInfo, test: Test) {
         execute(poolId) { it.testFailed(test) }
-        println("${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} failed")
+        val message = "${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} failed"
+        println(message)
+        buildSystem?.setBuildMessage(message)
     }
 
     fun testPassed(poolId: DevicePoolId, device: DeviceInfo, test: Test) {
         execute(poolId) { it.testPassed(test) }
-        println("${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} ended")
+        val message = "${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} ended"
+        println(message)
+        buildSystem?.setBuildMessage(message)
     }
 
     fun testIgnored(poolId: DevicePoolId, device: DeviceInfo, test: Test) {
         execute(poolId) { it.testIgnored(test) }
-        println("${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} ignored")
+        val message = "${toPercent(progress(poolId))} | [${poolId.name}]-[${device.serialNumber}] ${test.toTestName()} ignored"
+        println(message)
+        buildSystem?.setBuildMessage(message)
     }
 
     fun aggregateResult(): Boolean {

integrations/buildsystem/build.gradle.kts

@@ -0,0 +1,20 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    `java-library`
+    id("org.jetbrains.kotlin.jvm")
+    id("org.jetbrains.dokka")
+}
+
+Deployment.initialize(project)
+
+tasks.withType<KotlinCompile> {
+    kotlinOptions.jvmTarget = "1.8"
+    kotlinOptions.apiVersion = "1.5"
+}
+
+dependencies {
+    implementation(Libraries.kotlinStdLib)
+    testImplementation(TestLibraries.kluent)
+    testImplementation(TestLibraries.mockitoKotlin)
+}

integrations/buildsystem/src/main/kotlin/com/malinskiy/marathon/integrations/buildsystem/BuildSystem.kt

@@ -0,0 +1,6 @@
+package com.malinskiy.marathon.integrations.buildsystem
+
+interface BuildSystem {
+    fun setBuildMessage(message: String)
+    fun setKeyValue(key: String, value: String)
+}

integrations/buildsystem/src/main/kotlin/com/malinskiy/marathon/integrations/buildsystem/BuildSystemId.kt

@@ -0,0 +1,5 @@
+package com.malinskiy.marathon.integrations.buildsystem
+
+enum class BuildSystemId {
+    Teamcity
+}

integrations/buildsystem/src/main/kotlin/com/malinskiy/marathon/integrations/buildsystem/Teamcity.kt

@@ -0,0 +1,6 @@
+package com.malinskiy.marathon.integrations.buildsystem
+
+object Teamcity : BuildSystem {
+    override fun setBuildMessage(message: String) = println("##teamcity[buildStatus text='$message']")
+    override fun setKeyValue(key: String, value: String) = println("##teamcity[buildStatisticValue key='$key' value='$value']")
+}

settings.gradle.kts

@@ -26,3 +26,4 @@ include("report:html-report")
 include("report:execution-timeline")
 include("cli")
 include(":analytics:usage")
+include(":integrations:buildsystem")