Extract code coverage from Android device

core/src/main/kotlin/com/malinskiy/marathon/analytics/tracker/TrackerFactory.kt

@@ -4,6 +4,7 @@ import com.google.gson.Gson
 import com.malinskiy.marathon.analytics.tracker.local.DeviceTracker
 import com.malinskiy.marathon.analytics.tracker.local.JUnitTracker
 import com.malinskiy.marathon.analytics.tracker.local.RawTestResultTracker
+import com.malinskiy.marathon.analytics.tracker.local.TestCoverageTracker
 import com.malinskiy.marathon.analytics.tracker.local.TestResultsTracker
 import com.malinskiy.marathon.analytics.tracker.remote.influx.InfluxDbProvider
 import com.malinskiy.marathon.analytics.tracker.remote.influx.InfluxDbTracker
@@ -12,6 +13,7 @@ import com.malinskiy.marathon.execution.Configuration
 import com.malinskiy.marathon.io.FileManager
 import com.malinskiy.marathon.report.allure.AllureTestListener
 import com.malinskiy.marathon.report.internal.DeviceInfoReporter
+import com.malinskiy.marathon.report.internal.TestCoverageReporter
 import com.malinskiy.marathon.report.internal.TestResultReporter
 import com.malinskiy.marathon.report.junit.JUnitReporter
 import java.io.File
@@ -26,13 +28,24 @@ internal class TrackerFactory(private val configuration: Configuration,
     val allureTracker = AllureTestListener(configuration, File(configuration.outputDir, "allure-results"))
 
     fun create(): Tracker {
-        val defaultTrackers = listOf(
+        val defaultTrackers = if (configuration.isCodeCoverageEnabled) {
+            listOf(
+                TestCoverageTracker(TestCoverageReporter(fileManager)),
                 JUnitTracker(JUnitReporter(fileManager)),
                 DeviceTracker(deviceInfoReporter),
                 TestResultsTracker(testResultReporter),
                 rawTestResultTracker,
                 allureTracker
-        )
+            )
+        } else {
+            listOf(
+                JUnitTracker(JUnitReporter(fileManager)),
+                DeviceTracker(deviceInfoReporter),
+                TestResultsTracker(testResultReporter),
+                rawTestResultTracker,
+                allureTracker
+            )
+        }
         return when {
             configuration.analyticsConfiguration is InfluxDbConfiguration -> {
                 val config = configuration.analyticsConfiguration

core/src/main/kotlin/com/malinskiy/marathon/analytics/tracker/local/TestCoverageTracker.kt

@@ -0,0 +1,19 @@
+package com.malinskiy.marathon.analytics.tracker.local
+
+import com.malinskiy.marathon.analytics.tracker.NoOpTracker
+import com.malinskiy.marathon.device.DeviceInfo
+import com.malinskiy.marathon.device.DevicePoolId
+import com.malinskiy.marathon.execution.TestResult
+import com.malinskiy.marathon.report.internal.TestCoverageReporter
+
+internal class TestCoverageTracker(private val testCoverageReporter: TestCoverageReporter) :
+    NoOpTracker() {
+
+    override fun trackTestFinished(
+        poolId: DevicePoolId,
+        device: DeviceInfo,
+        testResult: TestResult
+    ) {
+        testCoverageReporter.testFinished(poolId, device, testResult)
+    }
+}

core/src/main/kotlin/com/malinskiy/marathon/analytics/tracker/remote/influx/InfluxDbTracker.kt

@@ -5,25 +5,35 @@ import com.malinskiy.marathon.device.DeviceInfo
 import com.malinskiy.marathon.device.DevicePoolId
 import com.malinskiy.marathon.execution.TestResult
 import com.malinskiy.marathon.execution.TestStatus
+import com.malinskiy.marathon.log.MarathonLogging
 import com.malinskiy.marathon.test.toSafeTestName
 import org.influxdb.InfluxDB
 import org.influxdb.dto.Point
 import java.util.concurrent.TimeUnit
 
 internal class InfluxDbTracker(private val influxDb: InfluxDB) : NoOpTracker() {
 
+    private val logger = MarathonLogging.logger("InfluxDB")
+
     override fun trackRawTestRun(poolId: DevicePoolId, device: DeviceInfo, testResult: TestResult) {
-        influxDb.write(Point.measurement("tests")
-                .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
-                .tag("testname", testResult.test.toSafeTestName())
-                .tag("package", testResult.test.pkg)
-                .tag("class", testResult.test.clazz)
-                .tag("method", testResult.test.method)
-                .tag("deviceSerial", device.serialNumber)
-                .addField("ignored", if (testResult.isIgnored) 1.0 else 0.0)
-                .addField("success", if (testResult.status == TestStatus.PASSED) 1.0 else 0.0)
-                .addField("duration", testResult.durationMillis())
-                .build())
+        val point = Point.measurement("tests")
+            .time(System.currentTimeMillis(), TimeUnit.MILLISECONDS)
+            .tag("testname", testResult.test.toSafeTestName())
+            .tag("package", testResult.test.pkg)
+            .tag("class", testResult.test.clazz)
+            .tag("method", testResult.test.method)
+            .tag("deviceSerial", device.serialNumber)
+            .addField("ignored", if (testResult.isIgnored) 1.0 else 0.0)
+            .addField("success", if (testResult.status == TestStatus.PASSED) 1.0 else 0.0)
+            .addField("duration", testResult.durationMillis())
+            .build()
+        runCatching {
+            influxDb.write(point)
+        }.onSuccess {
+            logger.trace { "Tracked in influxDB $point" }
+        }.onFailure {
+            logger.error(it) { "Error writing to influxDB with $point" }
+        }
     }
 
     override fun terminate() {

core/src/main/kotlin/com/malinskiy/marathon/execution/Attachment.kt

@@ -7,11 +7,13 @@ data class Attachment(val file: File, val type: AttachmentType)
 enum class AttachmentType {
     SCREENSHOT,
     VIDEO,
+    COVERAGE,
     LOG;
 
     fun toMimeType() = when(this) {
         SCREENSHOT -> "image/gif"
         VIDEO -> "video/mp4"
+        COVERAGE -> "application/ec"
         LOG -> "text/txt"
     }
 }

core/src/main/kotlin/com/malinskiy/marathon/io/FileType.kt

@@ -7,6 +7,6 @@ enum class FileType(val dir: String, val suffix: String) {
     LOG("logs", "log"),
     DEVICE_INFO("devices", "json"),
     VIDEO("video", "mp4"),
-    SCREENSHOT("screenshot", "gif")
-
+    SCREENSHOT("screenshot", "gif"),
+    COVERAGE("coverage", "ec")
 }

core/src/main/kotlin/com/malinskiy/marathon/report/internal/TestCoverageReporter.kt

@@ -0,0 +1,19 @@
+package com.malinskiy.marathon.report.internal
+
+import com.malinskiy.marathon.device.DeviceInfo
+import com.malinskiy.marathon.device.DevicePoolId
+import com.malinskiy.marathon.execution.TestResult
+import com.malinskiy.marathon.io.FileManager
+import com.malinskiy.marathon.io.FileType
+
+class TestCoverageReporter(private val fileManager: FileManager) {
+
+    fun testFinished(poolId: DevicePoolId, device: DeviceInfo, testResult: TestResult) {
+        val file = fileManager.createFile(FileType.COVERAGE, poolId, device, testResult.test)
+        file.setWritable(true)
+        testResult.attachments.forEach {
+            val bytes = it.file.readBytes()
+            file.appendBytes(bytes)
+        }
+    }
+}

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/AndroidDevice.kt

@@ -11,6 +11,7 @@ import com.malinskiy.marathon.android.executor.listeners.DebugTestRunListener
 import com.malinskiy.marathon.android.executor.listeners.LogCatListener
 import com.malinskiy.marathon.android.executor.listeners.NoOpTestRunListener
 import com.malinskiy.marathon.android.executor.listeners.ProgressTestRunListener
+import com.malinskiy.marathon.android.executor.listeners.TestCoverageResultListener
 import com.malinskiy.marathon.android.executor.listeners.TestRunResultsListener
 import com.malinskiy.marathon.android.executor.listeners.screenshot.ScreenCapturerTestRunListener
 import com.malinskiy.marathon.android.executor.listeners.video.ScreenRecorderTestRunListener
@@ -164,14 +165,27 @@ class AndroidDevice(val ddmsDevice: IDevice,
 
         val timer = SystemTimer()
 
+        val coverageListener = TestCoverageResultListener(fileManager, devicePoolId, this)
+
         return CompositeTestRunListener(
-                listOf(
+                if (configuration.isCodeCoverageEnabled) {
+                    listOf(
+                        coverageListener,
                         recorderListener,
                         logCatListener,
                         TestRunResultsListener(testBatch, this, deferred, timer, attachmentProviders),
                         DebugTestRunListener(this),
                         ProgressTestRunListener(this, devicePoolId, progressReporter)
-                )
+                    )
+                } else {
+                    listOf(
+                        recorderListener,
+                        logCatListener,
+                        TestRunResultsListener(testBatch, this, deferred, timer, attachmentProviders),
+                        DebugTestRunListener(this),
+                        ProgressTestRunListener(this, devicePoolId, progressReporter)
+                    )
+                }
         )
     }
 

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/RemoteFileManager.kt

@@ -53,6 +53,10 @@ class RemoteFileManager(private val device: IDevice) {
         return remoteFileForTest(videoFileName(test))
     }
 
+    fun remoteCoverageForTest(): String {
+        return remoteFileForTest("coverage.ec")
+    }
+
     private fun remoteFileForTest(filename: String): String {
         return "$outputDir/$filename"
     }

vendor/vendor-android/src/main/kotlin/com/malinskiy/marathon/android/executor/listeners/TestCoverageResultListener.kt

@@ -0,0 +1,68 @@
+package com.malinskiy.marathon.android.executor.listeners
+
+import com.android.ddmlib.testrunner.TestIdentifier
+import com.malinskiy.marathon.android.AndroidDevice
+import com.malinskiy.marathon.android.toTest
+import com.malinskiy.marathon.device.DevicePoolId
+import com.malinskiy.marathon.device.toDeviceInfo
+import com.malinskiy.marathon.execution.Attachment
+import com.malinskiy.marathon.execution.AttachmentType
+import com.malinskiy.marathon.io.FileManager
+import com.malinskiy.marathon.io.FileType
+import com.malinskiy.marathon.log.MarathonLogging
+import com.malinskiy.marathon.report.attachment.AttachmentListener
+import com.malinskiy.marathon.report.attachment.AttachmentProvider
+import kotlin.system.measureTimeMillis
+
+class TestCoverageResultListener(
+    private val fileManager: FileManager,
+    private val pool: DevicePoolId,
+    private val device: AndroidDevice
+) : NoOpTestRunListener(), AttachmentProvider {
+
+    private val logger = MarathonLogging.logger("CoverageListener")
+
+    private val attachmentListeners = mutableListOf<AttachmentListener>()
+
+    private lateinit var lastTestIdentifier: TestIdentifier
+
+    override fun testEnded(test: TestIdentifier, testMetrics: Map<String, String>) {
+        super.testEnded(test, testMetrics)
+        lastTestIdentifier = test
+    }
+
+    override fun testRunEnded(elapsedTime: Long, runMetrics: Map<String, String>) {
+        super.testRunEnded(elapsedTime, runMetrics)
+        pullCoverageFile(lastTestIdentifier)
+        removeCoverageFile()
+    }
+
+    private fun pullCoverageFile(test: TestIdentifier) {
+        val localCoverageFile =
+            fileManager.createFile(FileType.COVERAGE, pool, device.toDeviceInfo(), test.toTest())
+        val remoteFilePath = device.fileManager.remoteCoverageForTest()
+        logger.trace { "Pulling from $remoteFilePath" }
+        val millis = measureTimeMillis {
+            device.fileManager.pullFile(remoteFilePath, localCoverageFile.toString())
+        }
+        logger.trace { "Pulling file finished in ${millis}ms $remoteFilePath " }
+        attachmentListeners.forEach {
+            it.onAttachment(
+                test.toTest(),
+                Attachment(localCoverageFile, AttachmentType.COVERAGE)
+            )
+        }
+    }
+
+    private fun removeCoverageFile() {
+        val remoteFilePath = device.fileManager.remoteCoverageForTest()
+        val millis = measureTimeMillis {
+            device.fileManager.removeRemotePath(remoteFilePath)
+        }
+        logger.trace { "Removed file in ${millis}ms $remoteFilePath" }
+    }
+
+    override fun registerListener(listener: AttachmentListener) {
+        attachmentListeners.add(listener)
+    }
+}