Passing Scenario reference in Before and After hooks. Added idea plugin in pom to generate idea files

Author: anshulbajpai

scala/pom.xml

@@ -55,6 +55,12 @@
         </dependency>
     </dependencies>
 
+<pluginRepositories>
+    <pluginRepository>
+        <id>maven-idea-plugin-repo</id>
+        <url>http://maven-idea-plugin.googlecode.com/svn/maven-repo</url>
+    </pluginRepository>
+</pluginRepositories>
     <build>
         <plugins>
             <plugin>
@@ -124,6 +130,11 @@ file.write(template.toString(), "UTF-8")
                     </execution>
                 </executions>
             </plugin>
+ <plugin>
+            <groupId>com.googlecode</groupId>
+            <artifactId>maven-idea-plugin</artifactId>
+            <version>1.6</version>
+        </plugin>
         </plugins>
     </build>
 </project>

scala/src/main/scala/cucumber/api/scala/ScalaDsl.scala

@@ -1,6 +1,6 @@
 package cucumber.api.scala
 
-import _root_.cucumber.runtime._
+import _root_.cucumber.api.Scenario
 import _root_.cucumber.runtime.scala.Transform
 import _root_.cucumber.runtime.scala.ScalaHookDefinition
 import _root_.cucumber.runtime.scala.ScalaStepDefinition
@@ -14,28 +14,28 @@ trait ScalaDsl { self =>
   private [cucumber] val beforeHooks = new ArrayBuffer[HookDefinition]
   private [cucumber] val afterHooks = new ArrayBuffer[HookDefinition]
 
-  def Before(f: => Unit){
+  def Before(f: Scenario => Unit){
     Before()(f)
   }
 
-  def Before(tags: String*)(f: => Unit) {
+  def Before(tags: String*)(f: Scenario => Unit) {
     Before(Int.MaxValue, tags :_*)(f)
   }
 
-  def Before(order:Int, tags:String*)(f: => Unit){
-    beforeHooks += new ScalaHookDefinition(f _, order, tags)
+  def Before(order:Int, tags:String*)(f: Scenario => Unit){
+    beforeHooks += new ScalaHookDefinition(f, order, tags)
   }
 
-  def After(f: => Unit){
+  def After(f: Scenario => Unit){
     After()(f)
   }
 
-  def After(tags: String*)(f: => Unit) {
+  def After(tags: String*)(f: Scenario => Unit) {
     After(Int.MaxValue, tags:_*)(f)
   }
 
-  def After(order:Int, tags: String*)(f: => Unit){
-    afterHooks += new ScalaHookDefinition(f _, order, tags)
+  def After(order:Int, tags: String*)(f: Scenario => Unit){
+    afterHooks += new ScalaHookDefinition(f, order, tags)
   }
 
   final class Step(name: String) {

scala/src/main/scala/cucumber/runtime/scala/ScalaHookDefinition.scala

@@ -7,12 +7,12 @@ import _root_.cucumber.api.Scenario
 import _root_.cucumber.runtime.HookDefinition
 import collection.JavaConverters._
 
-class ScalaHookDefinition(f:() => Unit, order:Int, tags:Seq[String]) extends HookDefinition {
+class ScalaHookDefinition(f:Scenario => Unit, order:Int, tags:Seq[String]) extends HookDefinition {
   val tagExpression = new TagExpression(tags.asJava)
 
   def getLocation(detail: Boolean) = "TODO: Implement getLocation in similar fashion to ScalaStepDefinition"
 
-  def execute(scenario: Scenario) { f() }
+  def execute(scenario: Scenario) { f(scenario) }
 
   def matches(tags: Collection[Tag]) = tagExpression.eval(tags)
 

scala/src/test/scala/cucumber/api/scala/ScalaDslTest.scala

@@ -7,36 +7,43 @@ import _root_.gherkin.formatter.model.Tag
 import collection.JavaConverters._
 
 import _root_.cucumber.runtime.scala.Transform
+import cucumber.api.Scenario
 
 class ScalaDslTest {
 
+  object StubScenario extends Scenario{
+    def getStatus =  ""
+
+    def isFailed = false
+
+    def embed(p1: Array[Byte], p2: String) {}
+
+    def write(p1: String) {}
+  }
+
   @Test
   def emptyBefore {
 
-    var called = false
+    var actualScenario : Scenario = null
 
     object Befores extends ScalaDsl with EN {
-      Before {
-        called = true
-      }
+      Before { actualScenario = _ }
     }
 
     assertEquals(1, Befores.beforeHooks.size)
     val hook = Befores.beforeHooks.head
     assertTrue(hook.matches(List[Tag]().asJava))
-    hook.execute(null)
-    assertTrue(called)
+    hook.execute(StubScenario)
     assertEquals(Int.MaxValue, hook.getOrder)
+    assertEquals(StubScenario, actualScenario)
   }
 
   @Test
   def taggedBefore {
-    var called = false
+    var actualScenario : Scenario = null
 
     object Befores extends ScalaDsl with EN {
-      Before("@foo,@bar", "@zap"){
-        called = true
-      }
+      Before("@foo,@bar", "@zap"){ actualScenario = _ }
     }
 
     assertEquals(1, Befores.beforeHooks.size)
@@ -46,20 +53,16 @@ class ScalaDslTest {
     assertTrue(hook.matches(List(new Tag("@bar", 0), new Tag("@zap", 0)).asJava))
     assertFalse(hook.matches(List(new Tag("@bar", 1)).asJava))
 
-    hook.execute(null)
-    assertTrue(called)
+    hook.execute(StubScenario)
+    assertEquals(StubScenario, actualScenario)
     assertEquals(Int.MaxValue, hook.getOrder)
   }
 
   @Test
   def orderedBefore {
 
-    var called = false
-
     object Befores extends ScalaDsl with EN {
-      Before(10){
-        called = true
-      }
+      Before(10){ scenario : Scenario =>   }
     }
 
     val hook = Befores.beforeHooks(0)
@@ -69,12 +72,8 @@ class ScalaDslTest {
   @Test
   def taggedOrderedBefore {
 
-    var called = false
-
     object Befores extends ScalaDsl with EN {
-      Before(10, "@foo,@bar", "@zap"){
-        called = true
-      }
+      Before(10, "@foo,@bar", "@zap"){  scenario : Scenario => }
     }
 
     val hook = Befores.beforeHooks(0)
@@ -84,29 +83,25 @@ class ScalaDslTest {
   @Test
   def emptyAfter {
 
-    var called = false
+    var actualScenario : Scenario = null
 
     object Afters extends ScalaDsl with EN {
-      After {
-        called = true
-      }
+      After {  actualScenario = _ }
     }
 
     assertEquals(1, Afters.afterHooks.size)
     val hook = Afters.afterHooks.head
     assertTrue(hook.matches(List[Tag]().asJava))
-    hook.execute(null)
-    assertTrue(called)
+    hook.execute(StubScenario)
+    assertEquals(StubScenario, actualScenario)
   }
 
   @Test
   def taggedAfter {
-    var called = false
+    var actualScenario : Scenario = null
 
     object Afters extends ScalaDsl with EN {
-      After("@foo,@bar", "@zap"){
-        called = true
-      }
+      After("@foo,@bar", "@zap"){ actualScenario = _ }
     }
 
     assertEquals(1, Afters.afterHooks.size)
@@ -116,8 +111,8 @@ class ScalaDslTest {
     assertTrue(hook.matches(List(new Tag("@bar", 0), new Tag("@zap", 0)).asJava))
     assertFalse(hook.matches(List(new Tag("@bar", 1)).asJava))
 
-    hook.execute(null)
-    assertTrue(called)
+    hook.execute(StubScenario)
+    assertEquals(StubScenario, actualScenario)
   }
 
   @Test
@@ -132,7 +127,7 @@ class ScalaDslTest {
 
     assertEquals(1, Dummy.stepDefinitions.size)
     val step = Dummy.stepDefinitions.head
-    assertEquals("ScalaDslTest.scala:128", step.getLocation(true)) // be careful with formatting or this test will break
+    assertEquals("ScalaDslTest.scala:123", step.getLocation(true)) // be careful with formatting or this test will break
     assertEquals("x", step.getPattern)
     step.execute(new I18n("en"), Array())
     assertTrue(called)