spinach 0.1.5.4 → 0.2.0.1

data/test/spinach/parser_test.rb

@@ -2,38 +2,25 @@ require_relative '../test_helper'
 
 describe Spinach::Parser do
   before do
-    @parser = Spinach::Parser.new(
-      "Feature: User authentication
-           Scenario: User logs in
-             Given I am on the front page
-             When I fill in the login form and press 'login'
-             Then I should be on my dashboard
-      ")
+    @contents = """
+Feature: User authentication
+
+  Scenario: User logs in
+    Given I am on the front page
+    When I fill in the login form and press 'login'
+    Then I should be on my dashboard
+"""
+    @parser = Spinach::Parser.new(@contents)
   end
 
   let(:parsed) { @parser.parse }
 
   describe '#parse' do
-    it 'parses the feature name' do
-      parsed['name'].must_equal 'User authentication'
-    end
-
-    describe 'scenario' do
-      before do
-        @scenario = parsed['elements'][0]
-      end
-
-      it 'parses the scenario name' do
-        @scenario['name'].must_equal 'User logs in'
-      end
-
-      it 'parses the scenario steps' do
-        @scenario['steps'][0]['name'].must_equal 'I am on the front page'
-        @scenario['steps'][1]['name'].must_equal(
-         'I fill in the login form and press \'login\''
-        )
-        @scenario['steps'][2]['name'].must_equal 'I should be on my dashboard'
-      end
+    it 'parses the file' do
+      Gherkin.expects(:parse).with(@contents.strip).returns ast = stub
+      Spinach::Parser::Visitor.stubs(:new).returns visitor = stub
+      visitor.expects(:visit).with ast
+      @parser.parse
     end
   end
 

data/test/spinach/reporter/stdout/error_reporting_test.rb

@@ -6,9 +6,9 @@ describe Spinach::Reporter::Stdout do
   let(:exception) { StandardError.new('Something went wrong') }
 
   let(:error) do
-    [{'name' => 'My feature'},
-      {'name' => 'A scenario'},
-      {'keyword' => 'Keyword', 'name' => 'step name'},
+    [stub(name: 'My feature'),
+      stub(name: 'A scenario'),
+      stub(keyword: 'Keyword', name: 'step name'),
       exception]
   end
 
@@ -110,7 +110,7 @@ describe Spinach::Reporter::Stdout do
   describe '#report_undefined_features' do
     describe 'when some features are undefined' do
       it 'outputs the undefined features' do
-        @reporter.undefined_features << {'name' => 'Undefined feature name'}
+        @reporter.undefined_features << stub(name: 'Undefined feature name')
         @reporter.report_undefined_features
 
         @error.string.must_include "Undefined features (1)"
@@ -242,10 +242,10 @@ describe Spinach::Reporter::Stdout do
 
     describe "when it's a step not defined exception" do
       it "returns a suggestion" do
-        @exception = Spinach::StepNotDefinedException.new("foo")
-        @error = [{'name' => 'My feature'},
-          {'name' => 'A scenario'},
-          {'keyword' => 'Given', 'name' => 'foo'},
+        @exception = Spinach::StepNotDefinedException.new(stub(name: "foo"))
+        @error = [stub(name: 'My feature'),
+          stub(name: 'A scenario'),
+          stub(keyword: 'Given', name: 'foo'),
           @exception]
         output = @reporter.full_error(@error)
         output.must_include "Given"
@@ -269,7 +269,7 @@ describe Spinach::Reporter::Stdout do
 
     describe 'when given an undefined step exception' do
       it 'prints the error in yellow' do
-        undefined_exception = Spinach::StepNotDefinedException.new(anything)
+        undefined_exception = Spinach::StepNotDefinedException.new(stub(name: 'some step'))
 
         String.any_instance.expects(:yellow)
 

data/test/spinach/reporter/stdout_test.rb

@@ -6,9 +6,9 @@ describe Spinach::Reporter::Stdout do
   let(:exception) { StandardError.new('Something went wrong') }
 
   let(:error) do
-    [{'name' => 'My feature'},
-      {'name' => 'A scenario'},
-      {'keyword' => 'Keyword', 'name' => 'step name'},
+    [stub(name: 'My feature'),
+      stub(name: 'A scenario'),
+      stub(keyword: 'Keyword', name: 'step name'),
       exception]
   end
 
@@ -28,7 +28,8 @@ describe Spinach::Reporter::Stdout do
 
   describe '#before_feature_run' do
     it 'outputs the feature' do
-      @reporter.before_feature_run('name' => 'A cool feature')
+      feature = stub_everything(name: 'A cool feature')
+      @reporter.before_feature_run(feature)
 
       @out.string.must_include 'Feature'
       @out.string.must_include 'A cool feature'
@@ -37,7 +38,8 @@ describe Spinach::Reporter::Stdout do
 
   describe '#before_scenario_run' do
     it 'outputs the scenario' do
-      @reporter.before_scenario_run('name' => 'Arbitrary scenario')
+      scenario = stub_everything(name: 'Arbitrary scenario', steps: [])
+      @reporter.before_scenario_run(scenario)
 
       @out.string.must_include 'Scenario'
       @out.string.must_include 'Arbitrary scenario'
@@ -68,7 +70,7 @@ describe Spinach::Reporter::Stdout do
   end
 
   describe '#on_successful_step' do
-    let(:step) { {'keyword' => 'Given', 'name' => 'I am too cool'} }
+    let(:step) { stub(keyword: 'Given', name: 'I am too cool') }
     let(:step_location){['error_step_location', 1]}
     it 'adds the step to the output buffer' do
       @reporter.on_successful_step(step, step_location)
@@ -92,7 +94,7 @@ describe Spinach::Reporter::Stdout do
   end
 
   describe '#on_failed_step' do
-    let(:step) { {'keyword' => 'Then', 'name' => 'I write failing steps'} }
+    let(:step) { stub(keyword: 'Then', name: 'I write failing steps') }
     let(:step_location){['error_step_location', 1]}
 
     it 'adds the step to the output buffer' do
@@ -117,7 +119,7 @@ describe Spinach::Reporter::Stdout do
   end
 
   describe '#on_error_step' do
-    let(:step) { {'keyword' => 'And', 'name' => 'I even make syntax errors'} }
+    let(:step) { stub(keyword: 'And', name: 'I even make syntax errors') }
     let(:step_location){['error_step_location', 1]}
 
     it 'adds the step to the output buffer' do
@@ -142,7 +144,7 @@ describe Spinach::Reporter::Stdout do
   end
 
   describe '#on_undefined_step' do
-    let(:step) { {'keyword' => 'When', 'name' => 'I forgot to write steps'} }
+    let(:step) { stub(keyword: 'When', name: 'I forgot to write steps') }
 
     it 'adds the step to the output buffer' do
       @reporter.on_undefined_step(step, anything)
@@ -167,9 +169,7 @@ describe Spinach::Reporter::Stdout do
 
   describe "#on_feature_not_found" do
     before do
-      @feature = {
-        'name' => 'This feature does not exist'
-      }
+      @feature = stub(name: 'This feature does not exist', scenarios: [], background_steps: [])
       Spinach.config.stubs(:step_definitions_path).returns('my/path')
       @reporter.on_feature_not_found(@feature)
     end
@@ -195,7 +195,7 @@ describe Spinach::Reporter::Stdout do
 
   describe '#on_skipped_step' do
     it 'adds the step to the output buffer' do
-      @reporter.on_skipped_step({'keyword' => 'Then', 'name' => 'some steps are not even called'})
+      @reporter.on_skipped_step(stub(keyword: 'Then', name: 'some steps are not even called'))
 
       @out.string.must_include '~'
       @out.string.must_include 'Then'
@@ -205,7 +205,7 @@ describe Spinach::Reporter::Stdout do
 
   describe '#output_step' do
     it 'adds a step to the output buffer with nice colors' do
-      step = {'keyword' => 'Keyword', 'name' => 'step name'}
+      step = stub(keyword: 'Keyword', name: 'step name')
       @reporter.output_step('symbol', step, :blue)
 
       @out.string.must_include 'symbol'
@@ -236,11 +236,7 @@ describe Spinach::Reporter::Stdout do
 
   describe '#full_step' do
     it 'returns the step with keyword and name' do
-      @reporter.full_step({'keyword' => 'Keyword', 'name' => 'step name'}).must_equal 'Keyword step name'
-    end
-
-    it 'strips the arguments' do
-      @reporter.full_step({'keyword' => '   Keyword    ', 'name' => '   step name   '}).must_equal 'Keyword step name'
+      @reporter.full_step(stub(keyword: 'Keyword', name: 'step name')).must_equal 'Keyword step name'
     end
   end
 end

data/test/spinach/reporter_test.rb

@@ -81,6 +81,21 @@ module Spinach
           Spinach.hooks.run_before_scenario(anything)
         end
 
+        it "binds a callback around every scenario" do
+          @reporter.expects(:around_scenario_run)
+          Spinach.hooks.run_around_scenario(anything) do
+            yield
+          end
+        end
+
+        it "yields to around scenario callback" do
+          called = false
+          @reporter.around_scenario_run do
+            called = true
+          end
+          called.must_equal true
+        end
+
         it "binds a callback after every scenario" do
           @reporter.expects(:after_scenario_run)
           Spinach.hooks.run_after_scenario

data/test/spinach/runner/feature_runner_test.rb

@@ -1,100 +1,110 @@
 require_relative '../../test_helper'
 
 describe Spinach::Runner::FeatureRunner do
-  let(:filename) { 'feature/a_cool_feature.feature' }
-  subject{ Spinach::Runner::FeatureRunner.new(filename) }
+  let(:feature) { stub('feature', name: 'Feature') }
+  subject{ Spinach::Runner::FeatureRunner.new(feature) }
 
   describe '#initialize' do
     it 'initializes the given filename' do
-      subject.filename.must_equal filename
+      subject.feature.must_equal feature
     end
 
     it 'initalizes the given scenario line' do
-      @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::FeatureRunner.new(@filename)
-
-      @feature.instance_variable_get(:@scenario_line).must_equal '12'
-    end
-  end
-
-  describe '#data' do
-    it 'returns the parsed data' do
-      parsed_data = {name: 'A cool feature'}
-      parser = stub(parse: parsed_data)
-      Spinach::Parser.expects(:open_file).returns(parser)
-      subject.data.must_equal parsed_data
+      @runner = Spinach::Runner::FeatureRunner.new(feature, '34')
+      @runner.instance_variable_get(:@line).must_equal 34
     end
   end
 
   describe '#scenarios' do
-    it 'returns the parsed scenarios' do
-      subject.stubs(data: {'elements' => [1, 2, 3]})
+    it 'delegates to the feature' do
+      subject.feature.stubs(scenarios: [1,2,3])
       subject.scenarios.must_equal [1,2,3]
     end
   end
 
   describe '#run' do
-    before do
-      subject.stubs(data: {
-        'name' => 'A cool feature',
-        'elements' => [{'keyword'=>'Scenario', 'name'=>'Basic guess', 'line'=>6, 'description'=>'', 'type'=>'scenario'},
-                       {'keyword'=>'Scenario', 'name'=>'Basic guess II', 'line'=>12, 'description'=>'', 'type'=>'scenario'},
-                       {'keyword'=>'Scenario', 'name'=>'Basic guess III', 'line'=>18, 'description'=>'', 'type'=>'scenario'}]
-      })
-      subject.stubs(feature: stub_everything)
-    end
+    it 'runs the hooks in order' do
+      hooks = sequence('hooks')
+      Spinach.hooks.expects(:run_before_feature).with(feature).in_sequence(hooks)
+      Spinach.expects(:find_step_definitions).returns(false).in_sequence(hooks)
+      Spinach.hooks.expects(:run_after_feature).with(feature).in_sequence(hooks)
 
-    it 'calls the steps as expected' do
-      Spinach.expects(:find_feature_steps).returns(true)
-      seq = sequence('feature')
-      3.times do
-        Spinach::Runner::ScenarioRunner.
-          expects(:new).
-          returns(stub_everything).
-          in_sequence(seq)
-      end
       subject.run
     end
 
-    it 'returns true if the execution succeeds' do
-      Spinach.expects(:find_feature_steps).returns(true)
-      Spinach::Runner::ScenarioRunner.any_instance.
-        expects(run: true).times(3)
-      subject.run.must_equal true
-    end
+    describe 'when the steps exist' do
+      before do
+        @feature = stub('feature', name: 'Feature')
+        Spinach.stubs(:find_step_definitions).returns(true)
+        @scenarios = [
+          scenario         = stub,
+          another_scenario = stub
+        ]
+        @feature.stubs(:scenarios).returns @scenarios
+        @runner = Spinach::Runner::FeatureRunner.new(@feature)
+      end
 
-    it 'returns false if the execution fails' do
-      Spinach.expects(:find_feature_steps).returns(true)
-      Spinach::Runner::ScenarioRunner.any_instance.
-        expects(run: false).times(3)
-      subject.run.must_equal false
-    end
+      describe 'and the scenarios pass' do
+        it 'runs the scenarios and returns true' do
+          @scenarios.each do |scenario|
+            runner = stub(run: true)
+            Spinach::Runner::ScenarioRunner.expects(:new).with(scenario).returns runner
+          end
+
+          @runner.run.must_equal true
+        end
+      end
 
-    it 'calls only the given scenario' do
-      Spinach.expects(:find_feature_steps).returns(true)
-      @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::FeatureRunner.new(@filename)
-      @feature.stubs(data: {
-        'name' => 'A cool feature',
-        'elements' => [{'keyword'=>'Scenario', 'name'=>'Basic guess', 'line'=>6, 'description'=>'', 'type'=>'scenario'},
-                       {'keyword'=>'Scenario', 'name'=>'Basic guess II', 'line'=>12, 'description'=>'', 'type'=>'scenario'},
-                       {'keyword'=>'Scenario', 'name'=>'Basic guess III', 'line'=>18, 'description'=>'', 'type'=>'scenario'}]
-      })
+      describe 'and the scenarios fail' do
+        it 'runs the scenarios and returns false' do
+          @scenarios.each do |scenario|
+            runner = stub(run: false)
+            Spinach::Runner::ScenarioRunner.expects(:new).with(scenario).returns runner
+          end
 
-      Spinach::Runner::ScenarioRunner.expects(:new).with(anything, @feature.scenarios[1], anything).once.returns(stub_everything)
-      @feature.run
+          @runner.run.must_equal false
+        end
+      end
     end
 
-    it "fires a hook if the feature is not defined" do
-      data = stub_everything
-      Spinach.expects(:find_feature_steps).returns(false)
-      subject.stubs(:data).returns(data)
-      not_found_called = false
-      Spinach.hooks.on_undefined_feature do |data|
-        not_found_called = data
+    describe "when the steps don't exist" do
+      it 'runs the corresponding hooks and returns false' do
+        Spinach.stubs(:find_step_definitions).returns(false)
+        Spinach.hooks.expects(:run_on_undefined_feature).with(feature)
+        subject.run.must_equal false
+      end
+    end
+
+    describe "when a line is given" do
+      before do
+        @feature = stub('feature', name: 'Feature')
+        Spinach.stubs(:find_step_definitions).returns(true)
+        @scenarios = [
+          scenario         = stub(line: 4),
+          another_scenario = stub(line: 12)
+        ]
+        @feature.stubs(:scenarios).returns @scenarios
+      end
+      it "runs exactly matching scenario" do
+        Spinach::Runner::ScenarioRunner.expects(:new).with(@scenarios[1]).returns stub(run: true)
+        @runner = Spinach::Runner::FeatureRunner.new(@feature, "12")
+        @runner.run
+      end
+      it "runs no scenario and returns false" do
+        Spinach::Runner::ScenarioRunner.expects(:new).never
+        @runner = Spinach::Runner::FeatureRunner.new(@feature, "3")
+        @runner.run
+      end
+      it "runs matching scenario" do
+        Spinach::Runner::ScenarioRunner.expects(:new).with(@scenarios[0]).returns stub(run: true)
+        @runner = Spinach::Runner::FeatureRunner.new(@feature, "8")
+        @runner.run
+      end
+      it "runs last scenario" do
+        Spinach::Runner::ScenarioRunner.expects(:new).with(@scenarios[1]).returns stub(run: true)
+        @runner = Spinach::Runner::FeatureRunner.new(@feature, "15")
+        @runner.run
       end
-      subject.run
-      not_found_called.must_equal data
     end
   end
 end

data/test/spinach/runner/scenario_runner_test.rb

@@ -1,111 +1,137 @@
 require_relative '../../test_helper'
 
-describe Spinach::Runner::ScenarioRunner do
-  let(:data) do
-    {
-      'name' => 'A cool scenario',
-      'steps' => [
-        {'keyword' => 'Given', 'name' => 'I herd you like steps'},
-        {'keyword' => 'When', 'name' => 'I test steps'},
-        {'keyword' => 'Then', 'name' => 'I go step by step'}
-      ]
-    }
-  end
-
-  let(:feature_steps) { stub_everything }
-  let(:feature_name) { 'My feature' }
-  subject{
-    scenario = Spinach::Runner::ScenarioRunner.new(feature_name, data)
-    scenario.stubs(feature_steps: feature_steps)
-    scenario
-  }
-
-  describe '#initialize' do
-    it 'lists all the steps' do
-      subject.steps.count.must_equal 3
-    end
-
-    it 'sets the feature' do
-      subject.feature_steps.must_equal feature_steps
-    end
-  end
+module Spinach
+  class Runner
+    describe ScenarioRunner do
+      let(:feature) { stub(name: 'Feature', background_steps: []) }
+      let(:steps) { [stub(name: 'go shopping'), stub(name: 'do something')] }
+      let(:scenario) do
+        stub(
+          feature: feature,
+          steps:   steps
+        )
+      end
 
-  describe '#feature' do
-    it 'finds the feature given a feature name' do
-      subject.unstub(:feature_steps)
-      @feature = stub_everything
-      subject.stubs(feature_name: 'A cool feature')
-      Spinach.expects(:find_feature_steps).with('A cool feature').returns(@feature)
-      subject.feature_steps
-    end
-  end
+      subject { ScenarioRunner.new(scenario) }
 
-  describe '#run' do
-    it 'calls the appropiate feature steps' do
-      feature_steps.expects(:execute_step).with('I herd you like steps')
-      feature_steps.expects(:execute_step).with('I test steps')
-      feature_steps.expects(:execute_step).with('I go step by step')
-      subject.run
-    end
+      describe 'delegations' do
+        it 'delegates #feature to the scenario' do
+          subject.feature.must_equal feature
+        end
 
-    describe 'when throwing exceptions' do
-      it 'rescues a MiniTest::Assertion' do
-        Spinach.config[:failure_exceptions] << MiniTest::Assertion
-        feature_steps.expects(:execute_step).raises(MiniTest::Assertion)
-        Spinach.hooks.expects("run_before_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects("run_after_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects('run_on_failed_step').with(anything, anything, anything)
-        Spinach.hooks.expects('run_on_skipped_step').with(anything, anything).twice
-        subject.run
+        it 'delegates #steps to the scenario' do
+          subject.steps.must_equal steps
+        end
       end
 
-      it 'rescues a Spinach::StepNotDefinedException' do
-        feature_steps.expects(:execute_step).raises(
-          Spinach::StepNotDefinedException.new('bar'))
-        Spinach.hooks.expects("run_before_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects("run_after_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects("run_on_undefined_step").with(
-          anything, anything, anything)
-        Spinach.hooks.expects("run_on_skipped_step").with(
-          anything, anything).twice
-        subject.run
+      describe '#step_definitions' do
+        it 'looks up the step definitions' do
+          klass = Class.new
+          Spinach.expects(:find_step_definitions).with('Feature').returns klass
+          subject.step_definitions
+        end
       end
 
-      it 'rescues any other error' do
-        feature_steps.expects(:execute_step).raises
-        Spinach.hooks.expects("run_after_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects("run_before_scenario").with(has_value("A cool scenario"))
-        Spinach.hooks.expects("run_on_error_step").with(anything, anything, anything)
-        Spinach.hooks.expects("run_on_skipped_step").with(anything, anything).twice
-        subject.run
-      end
+      describe '#run' do
+        describe 'hooks' do
+          it 'runs hooks in order' do
+            hooks = sequence('hooks')
+            subject.stubs(:step_definitions).returns step_definitions = stub
 
-      it 'returns an failure' do
-        feature_steps.expects(:execute_step).raises(MiniTest::Assertion)
-        subject.run.wont_equal nil
-      end
-    end
+            Spinach.hooks.expects(:run_before_scenario).with(scenario).in_sequence(hooks)
+            Spinach.hooks.expects(:run_around_scenario).with(scenario).in_sequence(hooks).yields
 
-    it 'runs a step' do
-      feature_steps.expects(:execute_step).with(anything).times(3)
-      subject.run.must_equal true
-    end
+            Spinach.hooks.expects(:run_before_step).with(steps.first).in_sequence(hooks)
+            subject.expects(:run_step).with(steps.first)
+            Spinach.hooks.expects(:run_after_step).with(steps.first).in_sequence(hooks)
+
+            Spinach.hooks.expects(:run_before_step).with(steps.last).in_sequence(hooks)
+            subject.expects(:run_step).with(steps.last)
+            Spinach.hooks.expects(:run_after_step).with(steps.last).in_sequence(hooks)
+
+            Spinach.hooks.expects(:run_after_scenario).with(scenario).in_sequence(hooks)
 
-    describe 'hooks' do
-      it 'fires up the scenario hooks' do
-        feature_steps.expects(:execute_step).raises(Spinach::StepNotDefinedException.new('bar'))
-        Spinach.hooks.expects(:run_before_scenario).with(has_value("A cool scenario"))
-        Spinach.hooks.expects(:run_after_scenario).with(has_value("A cool scenario"))
-        subject.run
+            subject.run
+          end
+
+          it 'raises if around hook does not yield' do
+            subject.stubs(:step_definitions).returns stub
+
+            Spinach.hooks.stubs(:run_around_scenario).with(scenario)
+
+            proc do
+              subject.run
+            end.must_raise RuntimeError
+          end
+        end
       end
 
-      it 'fires up the step hooks' do
-        feature_steps.expects(:execute_step).raises(Spinach::StepNotDefinedException.new('bar'))
-        %w{before_step after_step}.each do |hook|
-          Spinach.hooks.expects("run_#{hook}").with(kind_of(Hash)).times(3)
+      describe '#run_step' do
+        before do
+          @step             = stub(name: 'Go shopping')
+          @step_definitions = stub
+          @step_definitions.stubs(:step_location_for).with('Go shopping').returns @location = stub
+          subject.stubs(:step_definitions).returns @step_definitions
+        end
+
+        describe 'when the step is successful' do
+          it 'runs the successful hooks' do
+            @step_definitions.stubs(:execute).with(@step).returns true
+            Spinach.hooks.expects(:run_on_successful_step).with(@step, @location)
+
+            subject.run_step(@step)
+          end
+        end
+
+        describe 'when the step fails' do
+          before do
+            @failure_exception = Class.new(StandardError)
+            Spinach.stubs(:config).returns({ failure_exceptions: [@failure_exception] })
+            @step_definitions.stubs(:execute).with(@step).raises @failure_exception
+          end
+
+          it 'sets the exception' do
+            subject.run_step(@step)
+            subject.instance_variable_get(:@exception).must_be_kind_of(@failure_exception)
+          end
+
+          it 'runs the failed hooks' do
+            Spinach.hooks.expects(:run_on_failed_step).with(@step, kind_of(@failure_exception), @location)
+            subject.run_step(@step)
+          end
         end
 
-        subject.run
+        describe 'when the step is undefined' do
+          before do
+            @step_definitions.stubs(:execute).with(@step).raises Spinach::StepNotDefinedException, @step
+          end
+
+          it 'sets the exception' do
+            subject.run_step(@step)
+            subject.instance_variable_get(:@exception).must_be_kind_of(Spinach::StepNotDefinedException)
+          end
+
+          it 'runs the undefined hooks' do
+            Spinach.hooks.expects(:run_on_undefined_step).with(@step, kind_of(Spinach::StepNotDefinedException))
+            subject.run_step(@step)
+          end
+        end
+
+        describe 'when the step raises an error' do
+          before do
+            @step_definitions.stubs(:execute).with(@step).raises StandardError
+          end
+
+          it 'sets the exception' do
+            subject.run_step(@step)
+            subject.instance_variable_get(:@exception).must_be_kind_of(StandardError)
+          end
+
+          it 'runs the error hooks' do
+            Spinach.hooks.expects(:run_on_error_step).with(@step, kind_of(StandardError), @location)
+            subject.run_step(@step)
+          end
+        end
       end
     end
   end