Improved the integration of cucumber into the test task.

- The integration project now depends on the correct cucumber version
- The integration project is added as a dependency jar to a project by the plugin (thus pulling in the correct cucumber version)
- Cucumber is now launched with less reflection
- System.out is now no longer closed when the cucumber tests finish running
- README updated with the changes

Author: skipoleschris

README.markdown

@@ -9,8 +9,7 @@ It adds the ability to run cucumber as a standalone SBT task but also as a test
 ### EXPERIMENTAL RELEASE ###
 This is currently an experimental release of the ability to run cucumber as a standard SBT test framework. The basic mechanisms are in place, but currently the following are broken / do not work:
 
-* When running the 'test' target, cucumber runs but then seems to lock up rather than return control back to SBT [Major]
-* Currently does not work with Scala 2.10.0-RC1 (I've only been testing against 2.9.2 projects and need to cross-build the integration project to allow it to work)
+* Currently MAY not work with Scala 2.10.0-RC1 (I've only been testing against 2.9.2 projects and need to cross-build the integration project to allow it to work)
 * There is currently no support for 'test-only' and no way to just run features with specific names or tags
 * When running in a multi-project setup, the cucumbers for each project are run in parallel and the output is interleaved and thus unreadable.
 
@@ -119,16 +118,10 @@ To add the cucumber plugin settings to a basic project, just add the following t
 The testProjects/testProject in the plugin source repository shows this configuration.
 
 #### Running as a test framework ####
-If you wish to support cucumber running as a test framework (via the test task) then the following settings should be placed in the build.sbt file instead:
-
-    libraryDependencies ++= Seq(
-      "templemore" %% "sbt-cucumber-integration" % "0.7.0" % "test"
-    )
+If you wish to support cucumber running as a test framework (via the test task) then use this alternative settings group instead:
 
     seq(cucumberSettingsWithTestPhaseIntegration : _*)
 
-Note that cucumberSettingsWithTestPhaseIntegration replaces cucumberSettings in this case. The testProjects/testIntegrationProject in the plugin source repository showns this configuration.
-
 ### Full Configuration ###
 To add the cucumber plugin settings to a full configuration (often a multi-module) project, the best way is to implement a project/Build.scala file:
 
@@ -149,12 +142,9 @@ The testProjects/multiModuleTestProject in the plugin source repository shows th
 #### Running as a test framework ####
 If you wish to support cucumber running as a test framework (via the test task) then the following settings should be placed in the build file instead:
 
-    val testIntegration = "templemore" %% "sbt-cucumber-integration" % "0.7.0" % "test"
-
     lazy val myProject = Project ("my-project", file ("."),
                                   settings = Defaults.defaultSettings ++ 
-                                             CucumberPlugin.cucumberSettingsWithTestPhaseIntegration ++
-                                             Seq(libraryDependencies ++= Seq(testIntegration)))
+                                             CucumberPlugin.cucumberSettingsWithTestPhaseIntegration)
 
 ## Customisation ##
 The plugin supports a number of customisations and settings. Note that these setting customisations only apply to running using the standalone 'cucumber' task. Running cucumber as a test framework does not support any customisation options.

integration/src/main/scala/templemore/sbt/cucumber/CucumberFramework.scala

@@ -21,7 +21,7 @@ class CucumberFramework extends Framework {
 }
 
 class CucumberRunner(testClassLoader: ClassLoader, loggers: Array[Logger]) extends Runner2 {
-  private val cucumber = new ReflectingCucumberLauncher(debug = logDebug, error = logError)
+  private val cucumber = new CucumberLauncher(debug = logDebug, error = logError)
 
   def run(testClassName: String, fingerprint: Fingerprint, eventHandler: EventHandler, args: Array[String]) = try {
     val arguments = Array("--glue", "", "--format", "pretty", "classpath:")

integration/src/main/scala/templemore/sbt/cucumber/CucumberLauncher.scala

@@ -0,0 +1,103 @@
+package templemore.sbt.cucumber
+
+import scala.collection.JavaConverters._
+import java.lang.reflect.InvocationTargetException
+import java.util.Properties
+
+import cucumber.runtime.Runtime
+import cucumber.runtime.RuntimeOptions
+import cucumber.runtime.snippets.SummaryPrinter
+import cucumber.runtime.model.CucumberFeature
+import gherkin.formatter.Formatter
+import gherkin.formatter.Reporter
+
+class CucumberLauncher(debug: (String) => Unit, error: (String) => Unit) {
+  
+  private val MultiLoaderClassName = "cucumber.runtime.io.MultiLoader"
+  private val MultiLoaderClassName_1_0_9 = "cucumber.io.MultiLoader"
+
+  def apply(cucumberArguments: Array[String],
+            testClassLoader: ClassLoader): Int = {
+    debug("Cucumber arguments: " + cucumberArguments.mkString(" "))
+    val runtime = buildRuntime(System.getProperties, cucumberArguments, testClassLoader)
+    runCucumber(runtime).asInstanceOf[Byte].intValue
+  }
+
+  private def runCucumber(runtime: CucumberRuntime) = try { 
+    runtime.initialise
+    runtime.run
+    runtime.printSummary
+    runtime.exitStatus
+  } catch {
+    case e: InvocationTargetException => {
+      val cause = if ( e.getCause == null ) e else e.getCause
+      error("Error running cucumber. Cause: " + cause.getMessage)
+      throw cause
+    }
+  }
+
+  case class CucumberRuntime(runtime: Runtime, options: RuntimeOptions, loader: AnyRef, 
+                             formatter: Formatter, reporter: Reporter, summaryPrinter: SummaryPrinter) {
+    private val loaderClass = loader.getClass.getInterfaces()(0)
+
+    def initialise = runtime.writeStepdefsJson()
+    def printSummary = summaryPrinter.print(runtime)
+    def exitStatus = runtime.exitStatus
+
+    def run = {
+      val featureList = (classOf[RuntimeOptions].getMethod("cucumberFeatures", loaderClass)
+                                                .invoke(options, loader)
+                                                .asInstanceOf[java.util.List[CucumberFeature]]
+                                                .asScala)
+      featureList foreach { feature => feature.run(formatter, reporter, runtime) }
+    }
+  }
+
+  private def buildRuntime(properties: Properties, 
+                           arguments: Array[String], 
+                           classLoader: ClassLoader): CucumberRuntime = try {
+    def buildLoader(clazz: Class[_]) = 
+      clazz.getConstructor(classOf[ClassLoader]).newInstance(classLoader).asInstanceOf[AnyRef]
+  
+    val loaderClass = loadCucumberClasses(classLoader)
+
+    val options = new RuntimeOptions(properties, arguments :_*)
+    val loader = buildLoader(loaderClass)
+
+    val runtimeConstructor = classOf[Runtime].getConstructor(loaderClass.getInterfaces()(0), classOf[ClassLoader], classOf[RuntimeOptions])
+    val runtime = runtimeConstructor.newInstance(loader, classLoader, options).asInstanceOf[Runtime]
+
+    CucumberRuntime(runtime, options, loader, 
+                    options.formatter(classLoader), options.reporter(classLoader), new SummaryPrinter(System.out))
+  } catch {
+    case e => 
+      error("Unable to construct cucumber runtime. Please report this as an error. (Details: " + e.getMessage + ")")
+      throw e
+  }
+
+  private def loadCucumberClasses(classLoader: ClassLoader) = try {
+    val multiLoaderClassName = cucumberVersion(classLoader) match {
+      case "1.0.9" => MultiLoaderClassName_1_0_9
+      case _ => MultiLoaderClassName
+    } 
+
+    classLoader.loadClass(multiLoaderClassName)
+  } catch {
+    case e: ClassNotFoundException =>
+      error("Unable to load Cucumber classes. Please check your project dependencies. (Details: " + e.getMessage + ")")
+      throw e
+  }
+
+  private def cucumberVersion(classLoader: ClassLoader) = {
+    val stream = classLoader.getResourceAsStream("cucumber/version.properties")
+    try {
+      val props = new Properties()
+      props.load(stream)
+      val version = props.getProperty("cucumber-jvm.version")
+      debug("Determined cucumber-jvm version to be: " + version)
+      version
+    } finally {
+      stream.close()
+    }
+  }
+}

integration/src/main/scala/templemore/sbt/cucumber/ReflectingCucumberLauncher.scala

@@ -11,8 +11,6 @@ import templemore.sbt.util._
 object CucumberPlugin extends Plugin with Integration {
 
   private val projectVersion = "0.7.0"
-  private val CucumberVersionForScala2_9 = "1.0.9"
-  private val CucumberVersionForScala2_10 = "1.1.1"
 
   type LifecycleCallback = () => Unit
 
@@ -67,16 +65,11 @@ object CucumberPlugin extends Plugin with Integration {
   private def defaultBefore() = {}
   private def defaultAfter() = {}
 
-  private def cucumberVersion(scalaVersion: String) = 
-    if ( scalaVersion.startsWith("2.10") ) CucumberVersionForScala2_10 else CucumberVersionForScala2_9
-
   private def cucumberMain(scalaVersion: String) = 
     if ( scalaVersion.startsWith("2.10") ) "cucumber.api.cli.Main" else "cucumber.cli.Main"
 
   val cucumberSettings: Seq[Setting[_]] = Seq(
-    libraryDependencies <+= scalaVersion { sv =>
-      "info.cukes" % "cucumber-scala" % cucumberVersion(sv) % "test"      
-    },
+    libraryDependencies += "templemore" %% "sbt-cucumber-integration" % projectVersion % "test",
 
     cucumber <<= inputTask(cucumberTask),
     cucumberTestSettings <<= cucumberSettingsTask,
@@ -90,7 +83,6 @@ object CucumberPlugin extends Plugin with Integration {
 
     cucumberMainClass <<= (scalaVersion) { sv => cucumberMain(sv) },
     cucumberFeaturesLocation := "classpath:",
-    // Replaced with cucumber on the classpath: cucumberFeaturesLocation <<= (baseDirectory) { (_ / "src" / "test" / "features").getPath },
     cucumberStepsBasePackage := "",
     cucumberExtraOptions := List.empty[String],
 
@@ -109,9 +101,6 @@ object CucumberPlugin extends Plugin with Integration {
   )
 
   val cucumberSettingsWithTestPhaseIntegration = cucumberSettings ++ Seq(
-    libraryDependencies ++= Seq(
-      "templemore" %% "sbt-cucumber-integration" % projectVersion % "test"
-    ),
     testFrameworks += new TestFramework("templemore.sbt.cucumber.CucumberFramework")
   ) 
 }

plugin/src/main/scala/templemore/sbt/cucumber/CucumberPlugin.scala

@@ -14,7 +14,17 @@ object Settings {
 }
 
 object Dependencies {
-  val testInterface = "org.scala-tools.testing" % "test-interface" % "0.5"
+
+  private val CucumberVersionForScala2_9 = "1.0.9"
+  private val CucumberVersionForScala2_10 = "1.1.1"
+
+  def cucumberScala(scalaVersion: String) = {
+    def cucumberVersion = if ( scalaVersion.startsWith("2.10") ) CucumberVersionForScala2_10 else CucumberVersionForScala2_9
+    "info.cukes" % "cucumber-scala" % cucumberVersion % "compile"      
+  }
+  val cucumber = "info.cukes" % "cucumber-scala" % "1.0.9" % "compile"
+
+  val testInterface = "org.scala-tools.testing" % "test-interface" % "0.5" % "compile"
 }
 
 object Build extends Build {
@@ -30,6 +40,8 @@ object Build extends Build {
 
   lazy val integrationProject = Project ("sbt-cucumber-integration", file ("integration"),
     settings = buildSettings ++ 
-               Seq(crossScalaVersions := Seq("2.9.2", "2.10.0-RC1"),
-                   libraryDependencies ++= Seq(testInterface)))
+               Seq(crossScalaVersions := Seq("2.9.2", "2.10.0-RC1", "2.10.0-RC2"),
+                   libraryDependencies <+= scalaVersion { sv => cucumberScala(sv) },
+                   libraryDependencies += testInterface))
 }
+

project/Build.scala

@@ -7,8 +7,7 @@ organization := "templemore"
 scalaVersion := "2.9.2"
 
 libraryDependencies ++= Seq(
-	"org.scalatest" %% "scalatest" % "1.7.2" % "test",
-  "templemore" %% "sbt-cucumber-integration" % "0.7.0" % "test"
+	"org.scalatest" %% "scalatest" % "1.7.2" % "test"
 )
 
 seq(cucumberSettingsWithTestPhaseIntegration : _*)

testProjects/testIntegrationProject/build.sbt

@@ -10,7 +10,6 @@ libraryDependencies ++= Seq(
 	"org.scalatest" %% "scalatest" % "1.7.2" % "test"
 )
 
-
 seq(cucumberSettings : _*)
 
 cucumberStepsBasePackage := "test"