Issue: 997 Start of BeforeStep functionality

features/before_after_step_hooks.feature

@@ -0,0 +1,59 @@
+Feature: Before and After Step Hooks
+
+  Background:
+    Given a file named "features/a.feature" with:
+      """
+      Feature: some feature
+        Scenario: some scenario
+          Given a step
+      """
+    And a file named "features/step_definitions/cucumber_steps.js" with:
+      """
+      import {Given} from 'cucumber'
+
+      Given(/^a step$/, function() {})
+      """
+
+  Scenario: Failing before step fails the scenario
+    Given a file named "features/support/hooks.js" with:
+      """
+      import {BeforeStep} from 'cucumber'
+
+      BeforeStep(function() { throw 'Fail' })
+      """
+    When I run cucumber-js
+    Then it fails
+
+  Scenario: Failing after step fails the scenario
+    Given a file named "features/support/hooks.js" with:
+      """
+      import {AfterStep} from 'cucumber'
+
+      AfterStep(function() { throw 'Fail' })
+      """
+    When I run cucumber-js
+    Then it fails
+
+  Scenario: Only run BeforeStep hooks with appropriate tags
+    Given a file named "features/support/hooks.js" with:
+      """
+      import { BeforeStep } from 'cucumber'
+
+      BeforeStep('@any-tag', function() {
+        throw Error("Would fail if ran")
+      })
+      """
+    When I run cucumber-js
+    Then it passes
+
+  Scenario: Only run BeforeStep hooks with appropriate tags
+    Given a file named "features/support/hooks.js" with:
+      """
+      import { AfterStep } from 'cucumber'
+
+      AfterStep('@any-tag', function() {
+        throw Error("Would fail if ran")
+      })
+      """
+    When I run cucumber-js
+    Then it passes

features/hooks.feature

@@ -62,35 +62,3 @@ Feature: Environment Hooks
     When I run cucumber-js
     Then it fails
     And the "After" hook has status "passed"
-
-  Scenario: World is this in hooks
-    Given a file named "features/support/world.js" with:
-      """
-      import {setWorldConstructor} from 'cucumber'
-
-      function WorldConstructor() {
-        return {
-          isWorld: function() { return true }
-        }
-      }
-
-      setWorldConstructor(WorldConstructor)
-      """
-    Given a file named "features/support/hooks.js" with:
-      """
-      import {After, Before} from 'cucumber'
-
-      Before(function() {
-        if (!this.isWorld()) {
-          throw Error("Expected this to be world")
-        }
-      })
-
-      After(function() {
-        if (!this.isWorld()) {
-          throw Error("Expected this to be world")
-        }
-      })
-      """
-    When I run cucumber-js
-    Then it passes

features/world_in_hooks.feature

@@ -0,0 +1,75 @@
+Feature: World in Hooks
+
+  Background:
+    Given a file named "features/a.feature" with:
+      """
+      Feature: some feature
+        Scenario: some scenario
+          Given a step
+      """
+    And a file named "features/step_definitions/cucumber_steps.js" with:
+      """
+      import {Given} from 'cucumber'
+
+      Given(/^a step$/, function() {})
+      """
+    And a file named "features/support/world.js" with:
+      """
+      import {setWorldConstructor} from 'cucumber'
+
+      function WorldConstructor() {
+        return {
+          isWorld: function() { return true }
+        }
+      }
+
+      setWorldConstructor(WorldConstructor)
+      """
+
+  Scenario: World is this in hooks
+    Given a file named "features/support/hooks.js" with:
+      """
+      import {After, Before } from 'cucumber'
+
+      Before(function() {
+        if (!this.isWorld()) {
+          throw Error("Expected this to be world")
+        }
+      })
+
+      After(function() {
+        if (!this.isWorld()) {
+          throw Error("Expected this to be world")
+        }
+      })
+      """
+    When I run cucumber-js
+    Then it passes
+
+  Scenario: World is this in BeforeStep hooks
+    Given a file named "features/support/hooks.js" with:
+      """
+      import {BeforeStep } from 'cucumber'
+
+      BeforeStep(function() {
+        if (!this.isWorld()) {
+          throw Error("Expected this to be world")
+        }
+      })
+      """
+    When I run cucumber-js
+    Then it passes
+
+  Scenario: World is this in AfterStep hooks
+    Given a file named "features/support/hooks.js" with:
+      """
+      import {AfterStep } from 'cucumber'
+
+      AfterStep(function() {
+        if (!this.isWorld()) {
+          throw Error("Expected this to be world")
+        }
+      })
+      """
+    When I run cucumber-js
+    Then it passes

src/formatter/rerun_formatter_spec.js

@@ -120,8 +120,9 @@ describe('RerunFormatter', () => {
 
           it('outputs the references needed to run the scenarios again', function() {
             expect(this.output).to.eql(
-              `${this.feature1Path}:1${separator.expected}${this
-                .feature2Path}:2`
+              `${this.feature1Path}:1${separator.expected}${
+                this.feature2Path
+              }:2`
             )
           })
         })

src/index.js

@@ -28,6 +28,8 @@ const { methods } = supportCodeLibraryBuilder
 export const After = methods.After
 export const AfterAll = methods.AfterAll
 export const Before = methods.Before
+export const BeforeStep = methods.BeforeStep
+export const AfterStep = methods.AfterStep
 export const BeforeAll = methods.BeforeAll
 export const defineParameterType = methods.defineParameterType
 export const defineStep = methods.defineStep

src/models/test_step_hook_definition.js

@@ -0,0 +1,27 @@
+import PickleFilter from '../pickle_filter'
+import StepDefinition from './step_definition'
+
+export default class TestStepHookDefinition extends StepDefinition {
+  constructor(data) {
+    super(data)
+    this.pickleFilter = new PickleFilter({
+      tagExpression: this.options.tags,
+    })
+  }
+
+  appliesToTestCase({ pickle, uri }) {
+    return this.pickleFilter.matches({ pickle, uri })
+  }
+
+  getInvalidCodeLengthMessage() {
+    return this.buildInvalidCodeLengthMessage('0 or 1', '2')
+  }
+
+  getInvocationParameters({ hookParameter }) {
+    return [hookParameter]
+  }
+
+  getValidCodeLengths() {
+    return [0, 1, 2]
+  }
+}

src/runtime/test_case_runner.js

@@ -29,6 +29,8 @@ export default class TestCaseRunner {
       parameters: worldParameters,
     })
     this.beforeHookDefinitions = this.getBeforeHookDefinitions()
+    this.afterStepHookDefinitions = this.getAfterStepHookDefinitions()
+    this.beforeStepHookDefinitions = this.getBeforeStepHookDefinitions()
     this.afterHookDefinitions = this.getAfterHookDefinitions()
     this.testStepIndex = 0
     this.result = {
@@ -91,6 +93,18 @@ export default class TestCaseRunner {
     )
   }
 
+  getBeforeStepHookDefinitions() {
+    return this.supportCodeLibrary.beforeTestStepHookDefinitions.filter(
+      stepHookDefinition => stepHookDefinition.appliesToTestCase(this.testCase)
+    )
+  }
+
+  getAfterStepHookDefinitions() {
+    return this.supportCodeLibrary.afterTestStepHookDefinitions.filter(
+      stepHookDefinition => stepHookDefinition.appliesToTestCase(this.testCase)
+    )
+  }
+
   getStepDefinitions(step) {
     return this.supportCodeLibrary.stepDefinitions.filter(stepDefinition =>
       stepDefinition.matchesStepName({
@@ -174,6 +188,13 @@ export default class TestCaseRunner {
     return this.invokeStep(null, hookDefinition, hookParameter)
   }
 
+  async runStepHook(step, hookDefinition, hookParameter) {
+    if (this.skip) {
+      return { status: Status.SKIPPED }
+    }
+    return this.invokeStep(step, hookDefinition, hookParameter)
+  }
+
   async runHooks(hookDefinitions, hookParameter) {
     await Promise.each(hookDefinitions, async hookDefinition => {
       await this.aroundTestStep(() =>
@@ -182,6 +203,25 @@ export default class TestCaseRunner {
     })
   }
 
+  async runStepHooks(step, hookDefinitions) {
+    const stepHookResults = await Promise.all(
+      hookDefinitions.map(async hookDefinition =>
+        this.runStepHook(step, hookDefinition)
+      )
+    )
+    const errors = stepHookResults.filter(result => result.exception)
+    if (errors && errors.length) {
+      return {
+        exception: 'Errors running step hooks',
+        status: Status.FAILED,
+      }
+    } else {
+      return {
+        status: Status.PASSED,
+      }
+    }
+  }
+
   async runStep(step) {
     const stepDefinitions = this.getStepDefinitions(step)
     if (stepDefinitions.length === 0) {
@@ -194,7 +234,28 @@ export default class TestCaseRunner {
     } else if (this.isSkippingSteps()) {
       return { status: Status.SKIPPED }
     }
-    return this.invokeStep(step, stepDefinitions[0])
+    const beforeStepsResult = await this.runStepHooks(
+      step,
+      this.beforeStepHookDefinitions
+    )
+    if (beforeStepsResult.status !== Status.PASSED) {
+      return beforeStepsResult
+    } else {
+      const stepResult = await this.invokeStep(step, stepDefinitions[0])
+      if (stepResult.status !== Status.PASSED) {
+        return stepResult
+      } else {
+        const afterStepResult = await this.runStepHooks(
+          step,
+          this.afterStepHookDefinitions
+        )
+        if (afterStepResult.status === Status.PASSED) {
+          return stepResult
+        } else {
+          return afterStepResult
+        }
+      }
+    }
   }
 
   async runSteps() {