Issue: 997 Start of BeforeStep functionality

features/hooks.feature

@@ -63,6 +63,16 @@ Feature: Environment Hooks
     Then it fails
     And the "After" hook has status "passed"
 
+  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: World is this in hooks
     Given a file named "features/support/world.js" with:
       """
@@ -78,14 +88,20 @@ Feature: Environment Hooks
       """
     Given a file named "features/support/hooks.js" with:
       """
-      import {After, Before} from 'cucumber'
+      import {After, Before, BeforeStep } from 'cucumber'
 
       Before(function() {
         if (!this.isWorld()) {
           throw Error("Expected this to be world")
         }
       })
 
+      BeforeStep(function() {
+        if (!this.isWorld()) {
+          throw Error("Expected this to be world")
+        }
+      })
+
       After(function() {
         if (!this.isWorld()) {
           throw Error("Expected this to be world")

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,7 @@ 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 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,7 @@ export default class TestCaseRunner {
       parameters: worldParameters,
     })
     this.beforeHookDefinitions = this.getBeforeHookDefinitions()
+    this.beforeStepHookDefinitions = this.getBeforeStepHookDefinitions()
     this.afterHookDefinitions = this.getAfterHookDefinitions()
     this.testStepIndex = 0
     this.result = {
@@ -91,6 +92,12 @@ export default class TestCaseRunner {
     )
   }
 
+  getBeforeStepHookDefinitions() {
+    return this.supportCodeLibrary.beforeTestStepHookDefinitions.filter(
+      stepHookDefinition => stepHookDefinition.appliesToTestCase(this.testCase)
+    )
+  }
+
   getStepDefinitions(step) {
     return this.supportCodeLibrary.stepDefinitions.filter(stepDefinition =>
       stepDefinition.matchesStepName({
@@ -182,6 +189,12 @@ export default class TestCaseRunner {
     })
   }
 
+  async runStepHooks(hookDefinitions, hookParameter) {
+    await Promise.each(hookDefinitions, async hookDefinition => {
+      await this.runHook(hookDefinition, hookParameter)
+    })
+  }
+
   async runStep(step) {
     const stepDefinitions = this.getStepDefinitions(step)
     if (stepDefinitions.length === 0) {
@@ -199,7 +212,13 @@ export default class TestCaseRunner {
 
   async runSteps() {
     await Promise.each(this.testCase.pickle.steps, async step => {
+      // TODO handle failure
+      await this.runStepHooks(this.beforeStepHookDefinitions, {
+        sourceLocation: this.testCaseSourceLocation,
+        pickle: this.testCase.pickle,
+      })
       await this.aroundTestStep(() => this.runStep(step))
+      // TODO run after step hooks
     })
   }
 }

src/runtime/test_case_runner_spec.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, it } from 'mocha'
 import { expect } from 'chai'
 import sinon from 'sinon'
 import TestCaseHookDefinition from '../models/test_case_hook_definition'
+import TestStepHookDefinition from '../models/test_step_hook_definition'
 import TestCaseRunner from './test_case_runner'
 import Status from '../status'
 import StepRunner from './step_runner'
@@ -29,6 +30,7 @@ describe('TestCaseRunner', () => {
     }
     this.supportCodeLibrary = {
       afterTestCaseHookDefinitions: [],
+      beforeTestStepHookDefinitions: [],
       beforeTestCaseHookDefinitions: [],
       defaultTimeout: 5000,
       stepDefinitions: [],
@@ -148,6 +150,87 @@ describe('TestCaseRunner', () => {
       })
     })
 
+    describe('with a passing step and a before step hook', () => {
+      beforeEach(async function() {
+        const testStepHookDefinition = new TestStepHookDefinition({
+          code() {
+            throw new Error('error')
+          },
+          line: 4,
+          options: {},
+          uri: 'path/to/hooks',
+        })
+        this.supportCodeLibrary.beforeTestStepHookDefinitions = [
+          testStepHookDefinition,
+        ]
+        this.step = { uri: 'path/to/feature', locations: [{ line: 2 }] }
+        this.stepResult = {
+          duration: 1,
+          status: Status.PASSED,
+        }
+        const stepDefinition = {
+          uri: 'path/to/steps',
+          line: 3,
+          matchesStepName: sinon.stub().returns(true),
+        }
+        StepRunner.run.resolves(this.stepResult)
+        this.supportCodeLibrary.stepDefinitions = [stepDefinition]
+        this.testCase.pickle.steps = [this.step]
+        const scenarioRunner = new TestCaseRunner({
+          eventBroadcaster: this.eventBroadcaster,
+          skip: false,
+          testCase: this.testCase,
+          supportCodeLibrary: this.supportCodeLibrary,
+        })
+        await scenarioRunner.run()
+      })
+
+      it('emits test-case-prepared', function() {
+        expect(this.onTestCasePrepared).to.have.callCount(1)
+        expect(this.onTestCasePrepared).to.have.been.calledWith({
+          steps: [
+            {
+              actionLocation: { line: 3, uri: 'path/to/steps' },
+              sourceLocation: { line: 2, uri: 'path/to/feature' },
+            },
+          ],
+          sourceLocation: { line: 1, uri: 'path/to/feature' },
+        })
+      })
+
+      it('emits test-case-started', function() {
+        expect(this.onTestCaseStarted).to.have.callCount(1)
+        expect(this.onTestCaseStarted).to.have.been.calledWith({
+          sourceLocation: { line: 1, uri: 'path/to/feature' },
+        })
+      })
+
+      it('emits test-step-started', function() {
+        expect(this.onTestStepStarted).to.have.callCount(1)
+        expect(this.onTestStepStarted).to.have.been.calledWith({
+          index: 0,
+          testCase: { sourceLocation: { line: 1, uri: 'path/to/feature' } },
+        })
+      })
+
+      it('emits test-step-finished', function() {
+        expect(this.onTestStepFinished).to.have.callCount(1)
+        expect(this.onTestStepFinished).to.have.been.calledWith({
+          index: 0,
+          testCase: { sourceLocation: { line: 1, uri: 'path/to/feature' } },
+          result: { duration: 1, status: Status.PASSED },
+        })
+      })
+
+      it('emits test-case-finished', function() {
+        expect(this.onTestCaseFinished).to.have.callCount(1)
+        expect(this.onTestCaseFinished).to.have.been.calledWith({
+          result: { duration: 1, status: Status.PASSED },
+          sourceLocation: { line: 1, uri: 'path/to/feature' },
+        })
+      })
+    })
+
     describe('with a failing step', () => {
       beforeEach(async function() {
         this.step = { uri: 'path/to/feature', locations: [{ line: 2 }] }

src/support_code_library_builder/define_helpers.js

@@ -5,10 +5,35 @@ import { ParameterType } from 'cucumber-expressions'
 import path from 'path'
 import StackTrace from 'stacktrace-js'
 import StepDefinition from '../models/step_definition'
+import TestStepHookDefinition from '../models/test_step_hook_definition'
 import TestCaseHookDefinition from '../models/test_case_hook_definition'
 import TestRunHookDefinition from '../models/test_run_hook_definition'
 import validateArguments from './validate_arguments'
 
+export function defineTestStepHook(builder, collectionName) {
+  return (options, code) => {
+    if (typeof options === 'string') {
+      options = { tags: options }
+    } else if (typeof options === 'function') {
+      code = options
+      options = {}
+    }
+    const { line, uri } = getDefinitionLineAndUri(builder.cwd)
+    validateArguments({
+      args: { code, options },
+      fnName: 'defineTestStepHook',
+      location: formatLocation({ line, uri }),
+    })
+    const hookDefinition = new TestStepHookDefinition({
+      code,
+      line,
+      options,
+      uri,
+    })
+    builder.options[collectionName].push(hookDefinition)
+  }
+}
+
 export function defineTestCaseHook(builder, collectionName) {
   return (options, code) => {
     if (typeof options === 'string') {

src/support_code_library_builder/index.js

@@ -5,6 +5,7 @@ import {
   defineTestRunHook,
   defineParameterType,
   defineTestCaseHook,
+  defineTestStepHook,
   defineStep,
 } from './define_helpers'
 import { wrapDefinitions } from './finalize_helpers'
@@ -15,6 +16,7 @@ export class SupportCodeLibraryBuilder {
       defineParameterType: defineParameterType(this),
       After: defineTestCaseHook(this, 'afterTestCaseHookDefinitions'),
       AfterAll: defineTestRunHook(this, 'afterTestRunHookDefinitions'),
+      BeforeStep: defineTestStepHook(this, 'beforeTestStepHookDefinitions'),
       Before: defineTestCaseHook(this, 'beforeTestCaseHookDefinitions'),
       BeforeAll: defineTestRunHook(this, 'beforeTestRunHookDefinitions'),
       defineStep: defineStep(this),
@@ -41,6 +43,7 @@ export class SupportCodeLibraryBuilder {
       definitions: _.chain([
         'afterTestCaseHook',
         'afterTestRunHook',
+        'beforeTestStepHook',
         'beforeTestCaseHook',
         'beforeTestRunHook',
         'step',
@@ -59,6 +62,7 @@ export class SupportCodeLibraryBuilder {
     this.options = _.cloneDeep({
       afterTestCaseHookDefinitions: [],
       afterTestRunHookDefinitions: [],
+      beforeTestStepHookDefinitions: [],
       beforeTestCaseHookDefinitions: [],
       beforeTestRunHookDefinitions: [],
       defaultTimeout: 5000,

src/support_code_library_builder/index_spec.js

@@ -184,4 +184,83 @@ describe('supportCodeLibraryBuilder', () => {
       })
     })
   })
+  describe('this.BeforeStep', () => {
+    describe('function only', () => {
+      beforeEach(function() {
+        this.hook = function() {}
+        supportCodeLibraryBuilder.reset('path/to/project')
+        supportCodeLibraryBuilder.methods.BeforeStep(this.hook) // eslint-disable-line babel/new-cap
+        this.options = supportCodeLibraryBuilder.finalize()
+      })
+
+      it('adds a step hook definition', function() {
+        expect(this.options.beforeTestStepHookDefinitions).to.have.lengthOf(1)
+        expect(this.options.beforeTestStepHookDefinitions[0].code).to.eql(
+          this.hook
+        )
+      })
+    })
+
+    describe('tag and function', () => {
+      beforeEach(function() {
+        this.hook = function() {}
+        supportCodeLibraryBuilder.reset('path/to/project')
+        supportCodeLibraryBuilder.methods.BeforeStep('@tagA', this.hook) // eslint-disable-line babel/new-cap
+        this.options = supportCodeLibraryBuilder.finalize()
+      })
+
+      it('adds a step hook definition', function() {
+        expect(this.options.beforeTestStepHookDefinitions).to.have.lengthOf(1)
+        expect(
+          this.options.beforeTestStepHookDefinitions[0].options.tags
+        ).to.eql('@tagA')
+        expect(this.options.beforeTestStepHookDefinitions[0].code).to.eql(
+          this.hook
+        )
+      })
+    })
+
+    describe('options and function', () => {
+      beforeEach(function() {
+        this.hook = function() {}
+        supportCodeLibraryBuilder.reset('path/to/project')
+        supportCodeLibraryBuilder.methods.BeforeStep(
+          { tags: '@tagA' },
+          this.hook
+        ) // eslint-disable-line babel/new-cap
+        this.options = supportCodeLibraryBuilder.finalize()
+      })
+
+      it('adds a step hook definition', function() {
+        expect(this.options.beforeTestStepHookDefinitions).to.have.lengthOf(1)
+        expect(
+          this.options.beforeTestStepHookDefinitions[0].options.tags
+        ).to.eql('@tagA')
+        expect(this.options.beforeTestStepHookDefinitions[0].code).to.eql(
+          this.hook
+        )
+      })
+    })
+
+    describe('multiple', () => {
+      beforeEach(function() {
+        this.hook1 = function hook1() {}
+        this.hook2 = function hook2() {}
+        supportCodeLibraryBuilder.reset('path/to/project')
+        supportCodeLibraryBuilder.methods.BeforeStep(this.hook1) // eslint-disable-line babel/new-cap
+        supportCodeLibraryBuilder.methods.BeforeStep(this.hook2) // eslint-disable-line babel/new-cap
+        this.options = supportCodeLibraryBuilder.finalize()
+      })
+
+      it('adds the step hook definitions in the order of definition', function() {
+        expect(this.options.beforeTestStepHookDefinitions).to.have.lengthOf(2)
+        expect(this.options.beforeTestStepHookDefinitions[0].code).to.eql(
+          this.hook1
+        )
+        expect(this.options.beforeTestStepHookDefinitions[1].code).to.eql(
+          this.hook2
+        )
+      })
+    })
+  })
 })