Gradle/Spock land是否有测试套件的概念？

Groovy/Gradle项目使用Spock进行单元测试

Spock和/或Gradle是否支持测试套件或命名的测试集？由于超出此问题范围的原因，CI服务器无法运行某些Spock测试（

规范

）

因此，将我的应用程序的所有Spock测试分为两组将非常好：

“

ci测试”

”；及

“

仅本地测试

”

然后也许我们可以通过以下方式调用它们：

./gradlew test --suite ci-tests

---

等等，这可能吗？如果是这样，设置/配置是什么样子的？

我将在build.gradle中设置一个子模块

我的应用程序ci测试

：

test {
    enabled = false
}
task functionalTest(type: Test) {
}

然后将测试放在

src/test/groovy

中并运行

/gradlew functionalTest

或者，您可以将它们包括在同一模块中，并使用

包含
/
排除

test {
    exclude '**/*FunctionalTest.groovy'
}
task functionalTest(type: Test) {
    include '**/*FunctionalTest.groovy'
}

您可以使用Spock annotation@IgnoreIf（）注释不应在CI服务器中运行的测试

请参阅此处的文档：

您需要做的就是让CI服务器设置一个环境变量，如果设置了该变量，则排除测试类

Spock甚至在闭包中有一些属性，使其更容易：

@IgnoreIf（{sys.isCiServer}）
如果您使用Junit test runner进行Spock测试，则可以使用
@Category
注释。示例和：

您可以使用以下
SpockConfiguration.groovy
来允许通过系统属性传递include/exclude

    runner {
        exclude {
            System.properties['spock.exclude.annotations']
                ?.split(',')
                *.trim()
                ?.each {
                    try {
                        annotation Class.forName(it)
                        println "Excluding ${it}"
                    } catch (ClassNotFoundException e) {
                        println "Can't load ${it}: ${e.message}"
                    }
                }
        }
        include {
            System.properties['spock.include.annotations']
                ?.split(',')
                *.trim()
                ?.each {
                    try {
                        annotation Class.forName(it)
                        println "Including ${it}"
                    } catch (ClassNotFoundException e) {
                        println "Can't load ${it}: ${e.message}"
                    }
                }
        }
    }

Spock基于JUnit，因此我认为您可以使用标准方法来开发套件。对于Gradle集成，请查看junit的Gradle单元测试插件文档。junit 5中不再支持类别，请参阅以了解解决方法
test {
    useJUnit {
        includeCategories 'package.FastTests'
    }
    testLogging {
        showStandardStreams = true
    }
}

    runner {
        exclude {
            System.properties['spock.exclude.annotations']
                ?.split(',')
                *.trim()
                ?.each {
                    try {
                        annotation Class.forName(it)
                        println "Excluding ${it}"
                    } catch (ClassNotFoundException e) {
                        println "Can't load ${it}: ${e.message}"
                    }
                }
        }
        include {
            System.properties['spock.include.annotations']
                ?.split(',')
                *.trim()
                ?.each {
                    try {
                        annotation Class.forName(it)
                        println "Including ${it}"
                    } catch (ClassNotFoundException e) {
                        println "Can't load ${it}: ${e.message}"
                    }
                }
        }
    }