merge from upstream, refactor

Author: zbynek

README.md

@@ -1,28 +1,30 @@
 # Firebase Test Lab Plugin for Android
-[![Kotlin version badge](https://img.shields.io/badge/kotlin-1.1.60-blue.svg)](http://kotlinlang.org/)
+[![Kotlin version badge](https://img.shields.io/badge/kotlin-2.0.0-blue.svg)](http://kotlinlang.org/)
 [![License](https://img.shields.io/crates/l/rustc-serialize.svg)](https://github.com/piotrmadry/FirebaseTestLab-Android/blob/master/LICENSE)
 
-![firebase](https://i.ytimg.com/vi/4_ZEEX1x17k/maxresdefault.jpg)
-
 ## Introduction
-Firebase is actually the most popular developer tool platform, wchich handles almost every aspect of the app. It also gives possibility to run Android Tests on physical or virtual devices hosted in a Google data center through [Firebase Test Lab](https://firebase.google.com/docs/test-lab/). In order to fully exploit the potential of this tool I've created plugin to simplify process of creating tests configurations. It allows to run tests locally as well as on you CI server.
+Plugin for which integrates Firebase Test Lab with Android Project. Simplify running Android Tests on Firebase platform locally as well as on using Continuous integration. 
 
 ### Contributors
 - [Jacek Marchwicki](https://github.com/jacek-marchwicki)
 
 #### Available features
+
 - Automatic installation of `gcloud` command line tool
 - Creating tasks for testable `buildType`[By default it is `debug`. If you want to change it use `testBuildType "buildTypeName"`]
-- Creating tasks for every defined device and configuration separetly [ including Instrumented / Robo tests ]
+- Creating tasks for every defined device and configuration separately [ including Instrumented / Robo tests ]
 - Creating tasks which runs all configurations at once
 - Ability to download tests results to specific location
 - Ability to clear directory inside bucket before test run
+- Instrumented tests sharding
 
 #### Benefits
+
 - Readability
 - Simplicity
 - Remote and Local Testing
 - Compatible with Gradle 3.0 
+- Instrumented Tests sharding for parallel test execution
 
 #### Setup 
 
@@ -120,6 +122,9 @@ firebaseTestLab {
 
             // If you are using ABI splits you can remove testing universal APK
             // testUniversalApk = false
+            
+            // For instrumented test you can specify number of shards, which allows to split all the tests for [numShards] times and execute them in parallel
+            // numShards = 4
 
             // You can set timeout (in seconds) for test
             // timeout = 6000

plugin/build.gradle

@@ -6,7 +6,7 @@ apply plugin: "com.gradle.plugin-publish"
 apply plugin: "org.gradle.kotlin.kotlin-dsl"
 
 group = "firebase.test.lab"
-version = "1.1.6"
+version = "2.0.0"
 
 gradlePlugin {
     plugins {

plugin/src/main/java/com/appunite/firebasetestlabplugin/FirebaseTestLabPlugin.kt

@@ -6,9 +6,11 @@ import com.android.build.gradle.api.BaseVariantOutput
 import com.android.build.gradle.api.TestVariant
 import com.appunite.firebasetestlabplugin.cloud.CloudTestResultDownloader
 import com.appunite.firebasetestlabplugin.cloud.FirebaseTestLabProcessCreator
+import com.appunite.firebasetestlabplugin.cloud.ProcessData
 import com.appunite.firebasetestlabplugin.cloud.TestType
 import com.appunite.firebasetestlabplugin.model.Device
 import com.appunite.firebasetestlabplugin.model.TestResults
+import com.appunite.firebasetestlabplugin.tasks.InstrumentationShardingTask
 import com.appunite.firebasetestlabplugin.utils.Constants
 import org.apache.tools.ant.taskdefs.condition.Os
 import org.gradle.api.GradleException
@@ -21,8 +23,9 @@ import org.gradle.kotlin.dsl.register
 import groovy.lang.Closure
 import java.io.ByteArrayOutputStream
 import java.io.File
+import java.io.Serializable
 
-internal class FirebaseTestLabPlugin : Plugin<Project> {
+class FirebaseTestLabPlugin : Plugin<Project> {
 
     open class HiddenExec : Exec() {
         init {
@@ -69,7 +72,7 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
         }
     }
 
-    data class Sdk(val gcloud: File, val gsutil: File)
+    data class Sdk(val gcloud: File, val gsutil: File): Serializable
 
     private fun createDownloadSdkTask(project: Project, cloudSdkPath: String?): Sdk =
             if (cloudSdkPath != null) {
@@ -190,16 +193,9 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
                 throw IllegalStateException("If you want to clear directory before run you need to setup cloudBucketName and cloudDirectoryName")
             }
 
-            val firebaseTestLabProcessCreator = FirebaseTestLabProcessCreator(
-                    sdk,
-                    cloudBucketName,
-                    cloudDirectoryName,
-                    project.logger
-            )
-
             (project.extensions.findByName(ANDROID) as AppExtension).apply {
                 testVariants.toList().forEach { testVariant ->
-                    createGroupedTestLabTask(devices, testVariant, firebaseTestLabProcessCreator, ignoreFailures, downloader)
+                    createGroupedTestLabTask(devices, testVariant, ignoreFailures, downloader, sdk, cloudBucketName, cloudDirectoryName)
                 }
             }
 
@@ -209,19 +205,23 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
 
     data class DeviceAppMap(val device: Device, val apk: BaseVariantOutput)
 
-    data class Test(val device: Device, val apk: BaseVariantOutput, val testApk: BaseVariantOutput)
-
+    data class Test(val device: Device, val apk: BaseVariantOutput, val testApk: BaseVariantOutput): Serializable
+    
     private fun createGroupedTestLabTask(
-            devices: List<Device>,
-            variant: TestVariant,
-            firebaseTestLabProcessCreator: FirebaseTestLabProcessCreator,
-            ignoreFailures: Boolean,
-            downloader: CloudTestResultDownloader?) {
+        devices: List<Device>,
+        variant: TestVariant,
+        ignoreFailures: Boolean,
+        downloader: CloudTestResultDownloader?,
+        sdk: Sdk,
+        cloudBucketName: String?,
+        cloudDirectoryName: String?
+    ) {
         val variantName = variant.testedVariant?.name?.capitalize() ?: ""
 
         val cleanTask = "firebaseTestLabClean${variantName.capitalize()}"
 
-        val runTestsTask = taskPrefixExecute + variantName.capitalize()
+        val variantSuffix = variantName.capitalize()
+        val runTestsTask = taskPrefixExecute + variantSuffix
         val runTestsTaskInstrumentation = "${runTestsTask}Instrumentation"
         val runTestsTaskRobo = "${runTestsTask}Robo"
 
@@ -266,19 +266,73 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
                         dependsOn(taskSetup)
                         dependsOn(arrayOf(test.apk.assemble))
                         doLast {
-                            val result = firebaseTestLabProcessCreator.callFirebaseTestLab(test.device, test.apk.outputFile, TestType.Robo)
+                            val result = FirebaseTestLabProcessCreator.callFirebaseTestLab(ProcessData(
+                                sdk = sdk,
+                                gCloudBucketName = cloudBucketName,
+                                gCloudDirectory = cloudDirectoryName,
+                                device = test.device,
+                                apk = test.apk.outputFile,
+                                
+                                testType = TestType.Robo
+                            ))
                             processResult(result, ignoreFailures)
                         }
                     })
                 }
-
-        val instrumentationTasks = combineAll(appVersions, variant.outputs, {deviceAndMap, testApk -> Test(deviceAndMap.device, deviceAndMap.apk, testApk)})
-                .map {
-                    test ->
-                    val devicePart = test.device.name.capitalize()
-                    val apkPart = dashToCamelCase(test.apk.name).capitalize()
-                    val testApkPart = test.testApk.let { if (it.filters.isEmpty()) "" else dashToCamelCase(it.name).capitalize() }
-                    val taskName = "$runTestsTaskInstrumentation$devicePart$apkPart$testApkPart"
+    
+        val testResultFile = File(project.buildDir, "TestResults.txt")
+        
+        val instrumentationTasks: List<Task> = combineAll(appVersions, variant.outputs)
+        { deviceAndMap, testApk -> Test(deviceAndMap.device, deviceAndMap.apk, testApk) }
+            .map { test ->
+                val devicePart = test.device.name.capitalize()
+                val apkPart = dashToCamelCase(test.apk.name).capitalize()
+                val testApkPart = test.testApk.let { if (it.filters.isEmpty()) "" else dashToCamelCase(it.name).capitalize() }
+                val taskName = "$runTestsTaskInstrumentation$devicePart$apkPart$testApkPart"
+                val numShards = test.device.numShards
+    
+                if (numShards > 0) {
+                    project.tasks.create(taskName, InstrumentationShardingTask::class.java) {
+                        group = Constants.FIREBASE_TEST_LAB
+                        description = "Run Instrumentation test for ${test.device.name} device on $variantName/${test.apk.name} in Firebase Test Lab"
+                        this.processData = ProcessData(
+                            sdk = sdk,
+                            gCloudBucketName = cloudBucketName,
+                            gCloudDirectory = cloudDirectoryName,
+                            device = test.device,
+                            apk = test.apk.outputFile,
+                            testType = TestType.Instrumentation(test.testApk.outputFile)
+                        )
+                        this.stateFile = testResultFile
+            
+                        if (downloader != null) {
+                            mustRunAfter(cleanTask)
+                        }
+                        dependsOn(taskSetup)
+                        dependsOn(arrayOf(test.apk.assemble, test.testApk.assemble))
+    
+                        doFirst {
+                            testResultFile.writeText("")
+                        }
+            
+                        doLast {
+                            val testResults = testResultFile.readText()
+                            val resultCode: Int? = testResults.toIntOrNull()
+    
+                            logger.lifecycle("TESTS RESULTS: Every digit represents single shard.")
+                            logger.lifecycle("\"0\" means -> tests for particular shard passed.")
+                            logger.lifecycle("\"1\" means -> tests for particular shard failed.")
+    
+                            logger.lifecycle("RESULTS_CODE: $resultCode")
+                            logger.lifecycle("When result code is equal to 0 means that all tests for all shards passed, otherwise some of them failed.")
+    
+                            if (resultCode != null) {
+                                processResult(resultCode, ignoreFailures)
+                            }
+                        }
+                    }
+        
+                } else {
                     project.task(taskName, closureOf<Task> {
                         inputs.files(test.testApk.outputFile, test.apk.outputFile)
                         group = Constants.FIREBASE_TEST_LAB
@@ -289,13 +343,21 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
                         dependsOn(taskSetup)
                         dependsOn(arrayOf(test.apk.assemble, test.testApk.assemble))
                         doLast {
-                            val result = firebaseTestLabProcessCreator.callFirebaseTestLab(test.device, test.apk.outputFile, TestType.Instrumentation(test.testApk.outputFile))
+                            val result = FirebaseTestLabProcessCreator.callFirebaseTestLab(ProcessData(
+                                sdk = sdk,
+                                gCloudBucketName = cloudBucketName,
+                                gCloudDirectory = cloudDirectoryName,
+                                device = test.device,
+                                apk = test.apk.outputFile,
+                                testType = TestType.Instrumentation(test.testApk.outputFile)
+                            ))
                             processResult(result, ignoreFailures)
                         }
                     })
                 }
+            }
 
-        val allInstrumentation = addExecuteAndDownload(runTestsTaskInstrumentation, downloader, cleanTask, closureOf<Task> {
+        val allInstrumentation: Task = project.task(runTestsTaskInstrumentation, closureOf<Task> {
             group = Constants.FIREBASE_TEST_LAB
             description = "Run all Instrumentation tests for $variantName in Firebase Test Lab"
             dependsOn(instrumentationTasks)
@@ -316,7 +378,7 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
             }
         })
 
-        val allRobo = project.task(runTestsTaskRobo, closureOf<Task> {
+        val allRobo: Task = project.task(runTestsTaskRobo, closureOf<Task> {
             group = Constants.FIREBASE_TEST_LAB
             description = "Run all Robo tests for $variantName in Firebase Test Lab"
             dependsOn(roboTasks)
@@ -337,14 +399,29 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
             }
         })
 
-        addExecuteAndDownload(runTestsTask, downloader, cleanTask, closureOf<Task> {
+        project.task(runTestsTask, closureOf<Task> {
             group = Constants.FIREBASE_TEST_LAB
             description = "Run all tests for $variantName in Firebase Test Lab"
             dependsOn(allRobo, allInstrumentation)
         })
+    
+        if (downloader != null) {
+            listOf(variantSuffix, "${variantSuffix}Instrumentation").map{suffix ->
+               project.task(taskPrefixDownload + suffix, closureOf<Task> {
+                    group = Constants.FIREBASE_TEST_LAB
+                    description = "Run Android Tests in Firebase Test Lab and download artifacts from google storage"
+                    dependsOn(taskSetup)
+                    dependsOn(taskPrefixExecute + suffix)
+                    mustRunAfter(cleanTask)
 
+                    doLast {
+                        downloader.getResults()
+                    }
+                })
+            }
+        }
     }
-
+    
     private fun processResult(result: TestResults, ignoreFailures: Boolean) {
         if (result.isSuccessful) {
             project.logger.lifecycle(result.message)
@@ -356,30 +433,22 @@ internal class FirebaseTestLabPlugin : Plugin<Project> {
             }
         }
     }
-
-    private fun addExecuteAndDownload(name: String, downloader: CloudTestResultDownloader?, cleanTask: String, taskClosure: Closure<Any?>): Task {
-        val runTask = project.task(name, taskClosure)
-        if (downloader != null) {
-            val configuration = name.substring(taskPrefixExecute.length)
-            project.task(taskPrefixDownload + configuration, closureOf<Task> {
-                group = Constants.FIREBASE_TEST_LAB
-                description = "Run Android Tests for $configuration in Firebase Test Lab and download artifacts from google storage"
-                dependsOn(taskSetup)
-                dependsOn(name)
-                mustRunAfter(cleanTask)
-
-                doLast {
-                    downloader.getResults()
-                }
-            })
+    
+    private fun processResult(resultCode: Int, ignoreFailures: Boolean) =
+        if (resultCode == 0) {
+            project.logger.lifecycle("SUCCESS: All tests passed.")
+        } else {
+            if (ignoreFailures) {
+                println("FAILURE: Tests failed.")
+                project.logger.error("FAILURE: Tests failed.")
+            } else {
+                throw GradleException("FAILURE: Tests failed.")
+            }
         }
-        return runTask
-    }
 }
 
-
 private fun <T1, T2, R> combineAll(l1: Collection<T1>, l2: Collection<T2>, func: (T1, T2) -> R): List<R> =
         l1.flatMap { t1 -> l2.map { t2 -> func(t1, t2)} }
 
-private fun dashToCamelCase(dash: String): String =
+fun dashToCamelCase(dash: String): String =
         dash.split('-', '_').joinToString("") { it.capitalize() }