Unit testing 使用自定义和插件执行任务'；s在sbt中配置？_Unit Testing_Sbt_Scoverage

Unit testing 使用自定义和插件执行任务'；s在sbt中配置？

unit-testing sbt

Unit testing 使用自定义和插件执行任务'；s在sbt中配置？,unit-testing,sbt,scoverage,Unit Testing,Sbt,Scoverage,我有一个SBT项目，它有一个完整的构建定义，带有一个用于测试的自定义配置我添加了一个带有自己配置的插件，如果可能的话，我希望能够使用这两种配置执行任务如果不可能，我想把配置从插件拉到我的自定义配置中细节我的自定义配置是unit，用于将某些测试分类为单元测试，我想使用添加覆盖率我的完整构建定义包括： lazy val UnitTest = config("unit") extend(Test) def unitTestFilter(name: String) = na

我有一个SBT项目，它有一个完整的构建定义，带有一个用于测试的自定义配置

我添加了一个带有自己配置的插件，如果可能的话，我希望能够使用这两种配置执行任务

如果不可能，我想把配置从插件拉到我的自定义配置中

细节我的自定义配置是

unit

，用于将某些测试分类为单元测试，我想使用添加覆盖率

我的完整构建定义包括：

lazy val UnitTest = config("unit") extend(Test)
def unitTestFilter(name: String) = name endsWith "UnitSpec"

lazy val myProject = Project(id="MyProject")
         .configs( UnitTest )
         .settings( inConfig(UnitTest)(Defaults.testTasks) : _*)
         .settings(
            testOptions in UnitTest := Seq(Tests.Filter(unitTestFilter)),
            parallelExecution in UnitTest := true
         )

为了执行单元测试，我运行

sbt unit:test

A）如何将

sbt平均值

添加到构建定义中的

单元

配置中，或B）如何在sbt运行中同时包含

sbt平均值

和

单元

配置，例如

sbt”单元，平均值：test“

根据提供的两个答案进行编辑，我正接近我想要的。我现在的问题是测试过滤器，并将其应用于配置。我已经更新了上面的原始代码片段，以包含我根据文件名使用的过滤器-请参见项目部分中的

testOptions

，以及我如何使用

unitTestFilter

。为了增加覆盖率，我为覆盖率测试添加了新的配置，因此现在有

UnitTest

，

ComponentTest

，

CoverageUnitTest

和

CoverageComponentTest

。现在的问题是，我无法将测试选项/文件名筛选器传播到scoverage配置

方法1：创建扩展scoverageTest的配置在上述方法中，不应用设置。如果我运行

coverUnit:test

，它将执行组件和单元规范。我还尝试在scoverageTest中使用

测试选项，该选项与筛选器一起工作，但问题是我的项目中有两个配置，即CoverageUnitTest和CoverageComponentTest，如果我在scoverageTest

中使用

，则两个任务只应用一个筛选器（即coverUnit:test和coverComponent:test都根据顺序执行单元测试或组件测试）
方法2：扩展测试并添加到仪器中
同样，此方法不使用unitTestFilter过滤测试
从ScoverageSbtPlugin源代码来看，我可能需要以某种方式来覆盖它：inConfig（scoverageTest）（Defaults.testSettings）+
，这是正确的方法吗
编辑#2
这里有一个变通方法，使用方法1，将“CoverageUnitTest”替换为“scoverageTest”：
运行时使用TEST\u TYPE=component规范sbt coverComponent:TEST
我使用sbt0.13.5-M2：
> about
[info] This is sbt 0.13.5-M2
[info] The current project is {file:/Users/jacek/sandbox/so/sbt-scoverage-custom-config/}myProject 0.1-SNAPSHOT
[info] The current project is built against Scala 2.10.4
[info] Available Plugins: sbt.plugins.IvyPlugin, sbt.plugins.JvmPlugin, sbt.plugins.CorePlugin, ScoverageSbtPlugin, scoverage.ScoverageSbtPlugin
[info] sbt, sbt plugins, and build definitions are using Scala 2.10.4

除非我弄错了，否则您要求将scoverage
设置应用于unit
，因此执行unit
的test
与执行test:test
加scoverage
设置相同。如果是，请继续阅读。否则，请告知
我认为，在构建定义中应该包含以下内容（我选择了对我来说更简单的build.sbt
）：
由于我对sbt scoverage
几乎一无所知，除了验证设置外，我无法确认其正确配置：
> unit:libraryDependencies
[info] List(org.scala-lang:scala-library:2.10.4, org.scoverage:scalac-scoverage-plugin:0.97.0:scoverage)
> test:libraryDependencies
[info] List(org.scala-lang:scala-library:2.10.4)

我没有检查这个，但是你可以试试
lazy val UnitTest=config（“单元”）扩展（测试）
lazy val myProject=Project（id=“myProject”）。
配置（单元测试、scoverage、scoverageTest）。
设置（ScoverageSbtPlugin.instrumentSettings:*）。
背景(
UnitTest中的并行执行：=true，
scoverageTest中的源+=（UnitTest中的源）。值，
scoverageTest中的sourceDirectory+=（UnitTest中的sourceDirectory）.value，
scoverageTest+=（UnitTest中的unmanagedResources）中的unmanagedResources，
scoverageTest+=（UnitTest中的resourceDirectory）中的resourceDirectory，
scoverageTest中的externalDependencyClasspath:=类路径
.concat（（scoverageTest中的externalDependencyClasspath）.value，（UnitTest中的externalDependencyClasspath）.value）
)
我使用了这两种建议的组合来设计一个有效的配置。我使用了一个丑陋的hack，因为我不太确定如何停止配置继承，但这里或多或少是我所拥有的（我在这里只显示了1个测试类型-单元，但实际上我有许多不同的类型。只有单元可以并行运行，组件/集成测试配置需要并行设置为false）：
第一组设置控制单元测试（无覆盖），使用单元：测试执行，第二组控制组件测试（组件：测试
）。最后一个配置用于运行启用覆盖率的测试。scoverageTest配置用于单元和组件测试，但我设置了一个系统属性，以便在运行SBT以启用/禁用并行执行时使用标志
sbt coverUnit:test将使用scoverageTest配置执行单元测试并启用并行。
$TEST\u TYPE=ComponentSpec sbt coverComponent:TEST执行scoverageTest配置中的组件测试，并通过determinateparallel函数禁用并行执行。
虽然我回答了，但我仍然不确定。您所说的“在构建定义中向单元配置添加sbt scoverage”是什么意思？您将如何验证您的构建配置是否满足要求？基本上希望运行unit:test
，并从中获得平均报告。我不介意创建一个新配置，例如units平均，它将允许我运行sbt units平均：test
，以使用覆盖率报告运行我的单元测试。谢谢Jacek，我已经运行了一次，它几乎就在那里-添加了ScoverageSbtPlugin.instrumentSettings。但是，我已经更新了我的原始帖子，指出了我遇到的另一个问题。我需要筛选要运行的测试
lazy val dynamicTestFilter(name:String):Boolean = name endsWith scala.util.Properties.envOrElse("TEST_TYPE","UnitSpec")

> about
[info] This is sbt 0.13.5-M2
[info] The current project is {file:/Users/jacek/sandbox/so/sbt-scoverage-custom-config/}myProject 0.1-SNAPSHOT
[info] The current project is built against Scala 2.10.4
[info] Available Plugins: sbt.plugins.IvyPlugin, sbt.plugins.JvmPlugin, sbt.plugins.CorePlugin, ScoverageSbtPlugin, scoverage.ScoverageSbtPlugin
[info] sbt, sbt plugins, and build definitions are using Scala 2.10.4

scalaVersion := "2.10.4"

lazy val UnitTest = config("unit") extend(Test)

lazy val myProject = project
  .in(file("."))
  .configs(UnitTest)
  .settings(
    inConfig(UnitTest)(ScoverageSbtPlugin.instrumentSettings): _*
  )
  .settings(
    parallelExecution in UnitTest := true
  )

> unit:libraryDependencies
[info] List(org.scala-lang:scala-library:2.10.4, org.scoverage:scalac-scoverage-plugin:0.97.0:scoverage)
> test:libraryDependencies
[info] List(org.scala-lang:scala-library:2.10.4)

lazy val UnitTest = config("unit") extend(Test)
lazy val CoverageUnitTest = config("coverUnit") extend (scoverageTest)
def unitTestFilter(name: String) = name endsWith "UnitSpec"
def dynamicTestFilter(name:String): Boolean = name endsWith scala.util.Properties.envOrElse("TEST_TYPE","UnitSpec")

def determineParallel:Boolean = {
  scala.util.Properties.envOrElse("TEST_TYPE","UnitSpec") match {
    case testType:String if testType == "UnitSpec => true
    case _ => false
  }
}

lazy val myProject = Project(id="MyProject")
 .configs( UnitTest, CoverageUnitTest )
 .configs( ComponentTest, CoverageComponentTest )
 .settings( inConfig(UnitTest)(Defaults.testTasks) : _*)
 .settings(
   testOptions in UnitTest := Seq(Tests.Filter(unitTestFilter)),
   parallelExecution in UnitTest := true
 )
 .settings( inConfig(ComponentTest)(Defaults.testTasks) : _*)
 .settings(
   testOptions in ComponentTest := Seq(Tests.Filter(componentTestFilter)),
   parallelExecution in ComponentTest := false
 )
 .settings(
    testOptions in scoverageTest := Seq(Tests.Filter(unitTestFilter)),
    parallelExecution in scoverageTest := determineParallel
 )