Gradle 的自定义 Android 测试任务

Question

问题

我想创建一个自定义 gradle 测试任务，仅用于运行 JUNIT 测试并忽略 Robolectric 测试。我试图通过创建一个新的测试注释并省略任何包含该新注释的测试来完成此任务。

错误

当我运行 gradle 任务时不包括 JUNIT 包。

error: package android.test.suitebuilder.annotation does not exist
import android.test.suitebuilder.annotation.SmallTest;

详情

新注释

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface RobolectricTest {
}

Gradle 文件

apply plugin: 'com.android.application'
apply plugin: 'com.google.gms.google-services'

repositories {
    mavenCentral()
    maven { url     'http://artifactory.ops.am1.qa.ext.bamgrid.com/artifactory/mobile-resources' }
    maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
}

buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.google.gms:google-services:1.3.0-beta1'
    }
}

android {
    compileSdkVersion rootProject.ext.compileSDKVersion
    buildToolsVersion rootProject.ext.buildToolsVersion

    defaultConfig {
        applicationId "com.example"
        minSdkVersion 17
        targetSdkVersion rootProject.ext.targetSdkVersion
        buildConfigField "String", "BUILD_TIME", "\"" + getDateAndTime() + "\""
        buildConfigField "String", "VERSION_BUILD", "\"" +     project["VERSION_BUILD"] + "\""
        versionCode Integer.parseInt(project.VERSION_CODE)
        versionName project.VERSION_NAME
    }

    signingConfigs {
        debug {
            storeFile file(project.DEBUG_KEYSTORE)
            storePassword project.DEBUG_KEYSTORE_PASSWORD
            keyAlias project.DEBUG_KEYSTORE_ALIAS
            keyPassword project.DEBUG_KEY_PASS
        }

        release {
            storeFile file(project.RELEASE_KEYSTORE)
            storePassword project.RELEASE_KEYSTORE_PASSWORD
            keyAlias project.RELEASE_KEYSTORE_ALIAS
            keyPassword project.RELEASE_KEY_PASS
        }
    }

    sourceSets {
        main {
            res.srcDirs = ['src/main/res/',
                           'src/main/abc']
        }
    }

    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            zipAlignEnabled true
            proguardFile getDefaultProguardFile('proguard-android-optimize.txt')
            proguardFile 'proguard-rules.pro'
            signingConfig signingConfigs.release

        }
        debug {
            testCoverageEnabled = true
            debuggable true
            signingConfig signingConfigs.debug
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])

    testCompile ('junit:junit:4.12')
    testCompile ('org.apache.maven:maven-ant-tasks:2.1.3')
    testCompile ('org.robolectric:robolectric:3.0')
    testCompile ('org.robolectric:shadows-support-v4:3.0')
}

sourceSets {
    unitTest {
        java.srcDirs = ['src/test/java']
        resources.srcDirs = ['src/test/resources']
    }
}

ClassLoader getClassLoader() {
    List urls = sourceSets.test.runtimeClasspath.collect {
        it.toURI().toURL()
    }
    return URLClassLoader.newInstance( urls as URL[] )
}    

/**
 *  Filters out files that have specific annotation
 * @param map - map of things to filter
 * @return - list of acceptable files after filter
 */
List annotationFilter( Map map ) {
   map.prefix = map?.prefix ?: '' // prefix: provide convenience for passing in annotation names

    ClassLoader loader = classLoader
    List result

    // filter with annotations
    if( !map.includes ) {
        result = map?.names
    } else {
        result = []
        map?.names.each { name ->
            Class klass = loader.loadClass( name )
            map?.includes.each { annotationName ->
                String fullName = map.prefix + annotationName
                Class annotation = loader.loadClass( fullName ).asSubclass( Annotation )
                if( !klass.isAnnotationPresent( annotation ) ) {
                    result << name
                }
            }
        }
    }

    if( result?.size() == 0 ) result = [ 'no.tests.to.run' ]
    return result
}

/**
 * Gradle task to run only robolectric tests.
 */
task unitTest( type: Test, description: 'Run all junit tests' ) {

    android.sourceSets.main.java.srcDirs.each { dir ->
        def buildDir = dir.getAbsolutePath().split('/')
        buildDir =  (buildDir[0..(buildDir.length - 4)] + ['build',     'classes', 'debug']).join('/')


        sourceSets.unitTest.compileClasspath += files(buildDir)
        sourceSets.unitTest.runtimeClasspath += files(buildDir)
    }

    testClassesDir = sourceSets.unitTest.output.classesDir
    classpath = sourceSets.unitTest.runtimeClasspath

    doLast {
        println "Doing Last"
        List names = testClassNames()
        List filtered = annotationFilter( names: names, includes:   ['testUtils.RobolectricTest'] )
        println 'Running ' + filtered.size() + ' tests:\n' +     filtered*.toString()*.replaceAll('^','\t').join('\n')

       filter {
            setIncludePatterns( filtered as String[] )
        }
    }
}

Answer 1

你在 Ubuntu

上测试多维风味项目时说 Robolectric 找不到 AndroidManifest.xml

尝试在@Config 注释中明确给出清单文件的路径

@Config(constants = BuildConfig.class, manifest = "../<path to>/AndroidManifest.xml")

Answer 2

与其说是 Robolectric 特有的，但是关于用 Gradle 为 Android 声明自定义测试任务，我运行遇到了很多麻烦这个。如您所见，所有文档和示例都使用 Java 插件，但 Android 插件颠覆了大部分内容。

我在 Android 插件中找到的唯一解决方案是创建另一种构建类型，这将导致 Android 插件在后台为我创建新的测试任务。然后我就可以轻松修改任务了。

这是相关设置，我将其保存在 <rootProject>/gradle/test.gradle 文件中（此特定示例使用类别注释将单元测试过滤到一个任务中，并将集成测试过滤到一个单独的任务中。有关那部分的信息它看到 https://github.com/junit-team/junit4/wiki/Categories):

android {

    buildTypes {
        integration
    }

    testOptions {
        unitTests.all {
            useJUnit()

            if (it.name == 'testIntegrationUnitTest') {
                options {
                    excludeCategories 'com.example.categories.UnitTest'
                }
            } else {
                options {
                    excludeCategories 'com.example.categories.IntegrationTest'
                }
            }
        }
    }
}

然后 <module>/build.gradle 文件从此文件应用 apply from: "../gradle/test.gradle"

这导致合并两个文件的 android 闭包，导致新的 integration 构建类型，进而导致项目上的新 testIntegrationUnitTest 任务除了标准 testDebugUnitTest 和 testReleaseUnitTest 任务。

但现在，testDebugUnitTest 仅运行 "real" 单元测试，而 testIntegrationUnitTest 仅运行集成测试。

您的 mileage/implementation 可能会有所不同。一旦进入 unitTest.all 闭包，您就可以对选项进行任何需要的操作。

Answer 3

自定义 Gradle 仅任务运行特定测试

基于@alphonzo79 的回答，我解决了这个问题。

要知道的事情

Android gradle 省略了 gradle 中的常见测试功能，例如排除和自定义 sourceSets。
保留和目标没有帮助。只有类别有效。
不需要新的构建类型，只需要在编译自己的任务时更改测试选项即可。
不要使用这个 - https://github.com/pkainulainen/gradle-examples/blob/master/integration-tests/build.gradle

完整的答案是创建一个自定义任务，将 android testOptions 的标志更改为 excludeCategories。

LINK

代码

def integrationTests = false

...

testOptions {
    unitTests.all {
        useJUnit()
        if (integrationTests.toBoolean()) {
            println "Integration Tests Only for " + it.name
            options {
                excludeCategories 'com.example.reactivemvp.categories.UnitTest'
            }
        } else {
            println "Unit Tests Only for " + it.name
            options {
                excludeCategories 'com.example.reactivemvp.categories.IntegrationTest'
            }
        }
    }
}

...

task integrationTest(
    type: Test,
    description: 'Run integration tests only. Pass in \'-Pintegration=true\'',
    dependsOn: ['testDebugUnitTest', 'clean'] ) {

    //Here for task completion, not actually used since sub task of testDebugUnitTest
    testClassesDir = file("src/integrationTest/java/");
    classpath = files("$System.env.ANDROID_HOME/sources/android-18")

    //
    //Turn on integration testing when argument exists and is true
    //
    if (project.hasProperty('integration')) {
        println integration
        if (integration == 'true') {
            integrationTests = true
        }
    }
  }

Answer 4

我们可以使用以下配置按名称排除多个测试：

def integrationTests = project.hasProperty('integrationTests') ? project.getProperty('integrationTests') : false //Default value false
android {
    //...
    testOptions {
        unitTests {
            includeAndroidResources = true
            returnDefaultValues = true
            all {                
                test {
                    filter {
                        if (integrationTests.toBoolean()) {
                            includeTestsMatching "*IntegrationTest"
                        } else {
                            includeTestsMatching "*UnitTest"
                        }
                    }
                }
            }
        }
    }
}

在命令行中：

gradlew test // Run only *UnitTest, Default value is false.
gradlew test -PintegrationTests=false // Run only *UnitTest
gradlew test -PintegrationTests=true // Run only *IntegrationTest

Gradle 的自定义 Android 测试任务

Custom Gradle Test Task For Android

android

unit-testing

gradle

robolectric