spinach 0.1.4 → 0.1.5

data/test/spinach/reporter/stdout_test.rb

@@ -193,7 +193,7 @@ describe Spinach::Reporter::Stdout do
     end
 
     it 'tells the user what to write in the file' do
-      @out.string.must_include 'Feature \'This feature does not exist\' do'
+      @out.string.must_include 'This feature does not exist'
     end
   end
 
@@ -238,219 +238,6 @@ describe Spinach::Reporter::Stdout do
     end
   end
 
-  describe '#error_summary' do
-    it 'prints a summary with all the errors' do
-      @reporter.expects(:report_error_steps).once
-      @reporter.expects(:report_failed_steps).once
-      @reporter.expects(:report_undefined_steps).once
-      @reporter.expects(:report_undefined_features).once
-
-      @reporter.error_summary
-
-      @error.string.must_include 'Error summary'
-    end
-  end
-
-  describe '#run_summary' do
-    it 'prints a run summary' do
-      @reporter.run_summary
-
-      @out.string.must_include 'Steps Summary:'
-    end
-  end
-
-  describe '#report_error_steps' do
-    describe 'when some steps have raised an error' do
-      it 'outputs the errors' do
-        steps = [anything]
-        @reporter.stubs(:error_steps).returns(steps)
-        @reporter.expects(:report_errors).with('Errors', steps, :light_red)
-
-        @reporter.report_error_steps
-      end
-    end
-
-    describe 'when there are no error steps' do
-      it 'does nothing' do
-        @reporter.expects(:report_errors).never
-
-        @reporter.report_error_steps
-      end
-    end
-  end
-
-  describe '#report_failed_steps' do
-    describe 'when some steps have failed' do
-      it 'outputs the failing steps' do
-        steps = [anything]
-        @reporter.stubs(:failed_steps).returns(steps)
-        @reporter.expects(:report_errors).with('Failures', steps, :light_red)
-
-        @reporter.report_failed_steps
-      end
-    end
-
-    describe 'when there are no failed steps' do
-      it 'does nothing' do
-        @reporter.expects(:report_errors).never
-
-        @reporter.report_failed_steps
-      end
-    end
-  end
-
-  describe '#report_undefined_steps' do
-    describe 'when some steps have undefined' do
-      it 'outputs the failing steps' do
-        steps = [anything]
-        @reporter.stubs(:undefined_steps).returns(steps)
-        @reporter.expects(:report_errors).with('Undefined steps', steps, :yellow)
-
-        @reporter.report_undefined_steps
-      end
-    end
-
-    describe 'when there are no undefined steps' do
-      it 'does nothing' do
-        @reporter.expects(:report_errors).never
-
-        @reporter.report_undefined_steps
-      end
-    end
-  end
-
-  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.report_undefined_features
-
-        @error.string.must_include "Undefined features (1)"
-        @error.string.must_include "Undefined feature name"
-      end
-    end
-
-    describe 'when there are no undefined features' do
-      it 'does nothing' do
-        error = @error.string.dup
-        @reporter.report_undefined_steps
-
-        error.must_equal @error.string
-      end
-    end
-  end
-
-  describe '#report_errors' do
-    describe 'when some steps have raised an error' do
-      it 'outputs a the banner with the number of steps given' do
-        @reporter.report_errors('Banner', steps, :blue)
-
-        @error.string.must_include 'Banner (1)'
-      end
-
-      it 'prints a summarized error' do
-        @reporter.report_errors('Banner', steps, :blue)
-
-        @error.string.must_include 'My feature :: A scenario :: Keyword step name'
-      end
-
-      it 'colorizes the output' do
-        String.any_instance.expects(:colorize).with(:blue).at_least_once
-
-        @reporter.report_errors('Banner', [], :blue)
-      end
-    end
-  end
-
-  describe '#report_error' do
-    it 'raises when given an unsupported format' do
-      proc {
-        @reporter.report_error(error, :nil)
-      }.must_raise RuntimeError, 'Format not defined'
-    end
-
-    it 'prints a summarized error by default' do
-      @reporter.expects(:summarized_error).with(error).returns('summarized error')
-
-      @reporter.report_error(error)
-
-      @error.string.must_include 'summarized error'
-    end
-
-    it 'prints a summarized error' do
-      @reporter.expects(:summarized_error).with(error).returns('summarized error')
-
-      @reporter.report_error(error, :summarized)
-
-      @error.string.must_include 'summarized error'
-    end
-
-    it 'prints a full error' do
-      @reporter.expects(:full_error).with(error).returns('full error')
-
-      @reporter.report_error(error, :full)
-
-      @error.string.must_include 'full error'
-    end
-  end
-
-  describe '#summarized_error' do
-    it 'prints the error' do
-      summary = @reporter.summarized_error(error)
-
-      summary.must_include 'My feature :: A scenario :: Keyword step name'
-    end
-
-    it 'colorizes the print' do
-      String.any_instance.expects(:red)
-
-      @reporter.summarized_error(error)
-    end
-
-    describe 'when given an undefined step exception' do
-      it 'prints the error in yellow' do
-        undefined_error = error
-        undefined_error.insert(3, Spinach::StepNotDefinedException.new(anything))
-
-        String.any_instance.expects(:yellow)
-
-        @reporter.summarized_error(error)
-      end
-    end
-  end
-
-  describe '#full_error' do
-    before do
-      @reporter.expects(:report_exception).with(exception).returns('Exception backtrace')
-    end
-
-    it 'returns the exception data' do
-      exception.expects(:backtrace).returns(['first backtrace line'])
-      output = @reporter.full_error(error)
-
-      output.must_include 'Exception backtrace'
-    end
-
-    it 'returns the first backtrace line' do
-      exception.expects(:backtrace).returns(['first backtrace line'])
-      output = @reporter.full_error(error)
-
-      output.must_include 'first backtrace line'
-    end
-
-    describe 'when the user wants to print the full backtrace' do
-      it 'prints the full backtrace' do
-        @reporter.stubs(:options).returns({backtrace: true})
-        exception.expects(:backtrace).returns(['first backtrace line', 'second backtrace line'])
-
-        output = @reporter.full_error(error)
-
-        output.must_include 'first backtrace line'
-        output.must_include 'second backtrace line'
-      end
-    end
-  end
-
   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'
@@ -460,28 +247,4 @@ describe Spinach::Reporter::Stdout do
       @reporter.full_step({'keyword' => '   Keyword    ', 'name' => '   step name   '}).must_equal 'Keyword step name'
     end
   end
-
-  describe '#report_exception' do
-    it 'returns the exception data' do
-      output = @reporter.report_exception(exception)
-
-      output.must_include 'Something went wrong'
-    end
-
-    it 'colorizes the print' do
-      String.any_instance.expects(:red)
-
-      @reporter.report_exception(exception)
-    end
-
-    describe 'when given an undefined step exception' do
-      it 'prints the error in yellow' do
-        undefined_exception = Spinach::StepNotDefinedException.new(anything)
-
-        String.any_instance.expects(:yellow)
-
-        @reporter.report_exception(undefined_exception)
-      end
-    end
-  end
 end

data/test/spinach/reporter_test.rb

@@ -10,11 +10,6 @@ module Spinach
       @reporter = Reporter.new(@options)
     end
 
-    describe "#initialize" do
-      it "initializes the option hash" do
-      end
-    end
-
     describe "#options" do
       it "returns the options passed to the reporter" do
         @reporter.options[:backtrace].must_equal true
@@ -52,124 +47,84 @@ module Spinach
         @reporter.stubs(:method)
       end
 
-      it "binds a callback after running all the suite" do
-        @reporter.expects(:method).with(:after_run).returns(@callback)
-        @reporter.runner.expects(:after_run).with(@callback)
-        @reporter.bind
-      end
-
-      it "binds a callback before running every feature" do
-        @reporter.expects(:method).with(:before_feature_run).returns(@callback)
-        @reporter.feature_runner.expects(:before_run).with(@callback)
-        @reporter.bind
-      end
-
-      it "binds a callback after running every feature" do
-        @reporter.expects(:method).with(:after_feature_run).returns(@callback)
-        @reporter.feature_runner.expects(:after_run).with(@callback)
-        @reporter.bind
-      end
-
-      it "binds a callback for not defined features" do
-        @reporter.expects(:method).with(:on_feature_not_found).returns(@callback)
-        @reporter.feature_runner.expects(:when_not_found).with(@callback)
-        @reporter.bind
-      end
-
-      it "binds a callback before running every scenario" do
-        @reporter.expects(:method).with(:before_scenario_run).returns(@callback)
-        @reporter.scenario_runner.expects(:before_run).with(@callback)
-        @reporter.bind
-      end
+      describe "bindings" do
+        before do
+          @reporter.bind
+        end
 
-      it "binds a callback after running every feature" do
-        @reporter.expects(:method).with(:after_scenario_run).returns(@callback)
-        @reporter.scenario_runner.expects(:after_run).with(@callback)
-        @reporter.bind
-      end
+        after do
+          Spinach.hooks.reset
+        end
 
-      describe "when running steps" do
-        %w{successful failed error undefined skipped}.each do |type|
-          it "binds a callback after running a #{type} step" do
-            @reporter.expects(:method).with(:"on_#{type}_step").returns(@callback)
-            @reporter.scenario_runner.expects(:"on_#{type}_step").with(@callback)
-            @reporter.bind
-          end
+        it "binds a callback after running" do
+          @reporter.expects(:after_run)
+          Spinach.hooks.run_after_run
         end
-      end
 
-      describe "binds the context methods" do
-        it "binds the current feature setter" do
-          @reporter.expects(:method).with(:current_feature=).returns(@callback)
-          @reporter.feature_runner.expects(:before_run).with(@callback)
-          @reporter.bind
+        it "binds a callback before running every feature" do
+          @reporter.expects(:before_feature_run)
+          Spinach.hooks.run_before_feature(anything)
         end
 
-        it "binds the current feature clearer" do
-          @reporter.expects(:method).with(:clear_current_feature).returns(@callback)
-          @reporter.feature_runner.expects(:after_run).with(@callback)
-          @reporter.bind
+        it "binds a callback after running every feature" do
+          @reporter.expects(:after_feature_run)
+          Spinach.hooks.run_after_feature
         end
 
-        it "binds the current scenario setter" do
-          @reporter.expects(:method).with(:current_scenario=).returns(@callback)
-          @reporter.scenario_runner.expects(:before_run).with(@callback)
-          @reporter.bind
+        it "binds a callback when a feature is not found" do
+          @reporter.expects(:on_feature_not_found)
+          Spinach.hooks.run_on_undefined_feature
         end
 
-        it "binds the current feature clearer" do
-          @reporter.expects(:method).with(:clear_current_scenario).returns(@callback)
-          @reporter.scenario_runner.expects(:after_run).with(@callback)
-          @reporter.bind
+        it "binds a callback before every scenario" do
+          @reporter.expects(:before_scenario_run)
+          Spinach.hooks.run_before_scenario(anything)
         end
-      end
-    end
 
-    describe "#clear_current_feature" do
-      it "clears the current feature" do
-        @reporter.current_feature = mock
-        @reporter.clear_current_feature
-        @reporter.current_feature.must_equal nil
-      end
-    end
+        it "binds a callback after every scenario" do
+          @reporter.expects(:after_scenario_run)
+          Spinach.hooks.run_after_scenario
+        end
 
-    describe "#clear_current_scenario" do
-      it "clears the current scenario" do
-        @reporter.current_scenario = mock
-        @reporter.clear_current_scenario
-        @reporter.current_scenario.must_equal nil
-      end
-    end
+        it "binds a callback after every successful step" do
+          @reporter.expects(:on_successful_step)
+          Spinach.hooks.run_on_successful_step
+        end
 
-    describe "runner classes" do
-      describe "#feature_runner" do
-        it "returns a runner class" do
-          @reporter.feature_runner.must_be_kind_of Class
+        it "binds a callback after every failed step" do
+          @reporter.expects(:on_failed_step)
+          Spinach.hooks.run_on_failed_step
         end
-      end
 
-      describe "#scenario_runner" do
-        it "returns a runner class" do
-          @reporter.scenario_runner.must_be_kind_of Class
+        it "binds a callback after every error step" do
+          @reporter.expects(:on_error_step)
+          Spinach.hooks.run_on_error_step
         end
-      end
 
-      describe "#runner" do
-        it "returns a runner class" do
-          @reporter.runner.must_be_kind_of Class
+        it "binds a callback after every skipped step" do
+          @reporter.expects(:on_skipped_step)
+          Spinach.hooks.run_on_skipped_step
         end
-      end
-    end
 
-    describe "callback methods" do
-      %w{
-        after_run before_feature_run after_feature_run before_scenario_run
-        after_scenario_run on_successful_step on_failed_step on_error_step
-        on_undefined_step on_skipped_step
-      }.each do |callback|
-        describe "##{callback}" do
-          it "does nothing" do
-            @reporter.send(callback)
+        describe "internals" do
+          it "binds a callback before running" do
+            @reporter.expects(:set_current_feature)
+            Spinach.hooks.run_before_feature({})
+          end
+
+          it "binds a callback after running" do
+            @reporter.expects(:clear_current_feature)
+            Spinach.hooks.run_after_feature
+          end
+
+          it "binds a callback before every scenario" do
+            @reporter.expects(:set_current_scenario)
+            Spinach.hooks.run_before_scenario
+          end
+
+          it "binds a callback after every scenario" do
+            @reporter.expects(:clear_current_scenario)
+            Spinach.hooks.run_after_scenario
           end
         end
       end

data/test/spinach/runner/{feature_test.rb → feature_runner_test.rb}

@@ -1,17 +1,17 @@
 require_relative '../../test_helper'
 
-describe Spinach::Runner::Feature do
+describe Spinach::Runner::FeatureRunner do
   let(:filename) { 'feature/a_cool_feature.feature' }
-  let(:feature) { Spinach::Runner::Feature.new(filename) }
+  subject{ Spinach::Runner::FeatureRunner.new(filename) }
 
   describe '#initialize' do
     it 'initializes the given filename' do
-      feature.filename.must_equal filename
+      subject.filename.must_equal filename
     end
 
     it 'initalizes the given scenario line' do
       @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::Feature.new(@filename)
+      @feature = Spinach::Runner::FeatureRunner.new(@filename)
 
       @feature.instance_variable_get(:@scenario_line).must_equal '12'
     end
@@ -22,77 +22,75 @@ describe Spinach::Runner::Feature do
       parsed_data = {name: 'A cool feature'}
       parser = stub(parse: parsed_data)
       Spinach::Parser.expects(:open_file).returns(parser)
-      feature.data.must_equal parsed_data
+      subject.data.must_equal parsed_data
     end
   end
 
   describe '#scenarios' do
     it 'returns the parsed scenarios' do
-      feature.stubs(data: {'elements' => [1, 2, 3]})
-      feature.scenarios.must_equal [1,2,3]
+      subject.stubs(data: {'elements' => [1, 2, 3]})
+      subject.scenarios.must_equal [1,2,3]
     end
   end
 
   describe '#run' do
     before do
-      feature.stubs(data: {
+      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'}]
       })
-      feature.stubs(feature: stub_everything)
+      subject.stubs(feature: stub_everything)
     end
 
     it 'calls the steps as expected' do
       seq = sequence('feature')
       3.times do
-        Spinach::Runner::Scenario.
+        Spinach::Runner::ScenarioRunner.
           expects(:new).
           returns(stub_everything).
           in_sequence(seq)
       end
-      feature.run
+      subject.run
     end
 
     it 'returns true if the execution succeeds' do
-      Spinach::Runner::Scenario.any_instance.
+      Spinach::Runner::ScenarioRunner.any_instance.
         expects(run: true).times(3)
-      feature.run.must_equal true
+      subject.run.must_equal true
     end
 
     it 'returns false if the execution fails' do
-      Spinach::Runner::Scenario.any_instance.
+      Spinach::Runner::ScenarioRunner.any_instance.
         expects(run: false).times(3)
-      feature.run.must_equal false
+      subject.run.must_equal false
     end
 
     it 'calls only the given scenario' do
       @filename = 'feature/a_cool_feature.feature:12'
-      @feature = Spinach::Runner::Feature.new(@filename)
+      @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'}]
       })
-      @feature.stubs(feature: stub_everything)
 
-      Spinach::Runner::Scenario.expects(:new).with(anything, @feature.scenarios[1], anything).once.returns(stub_everything)
+      Spinach::Runner::ScenarioRunner.expects(:new).with(anything, @feature.scenarios[1], anything).once.returns(stub_everything)
       @feature.run
     end
 
     it "fires a hook if the feature is not defined" do
-      feature = Spinach::Runner::Feature.new(filename)
       data = mock
       exception = Spinach::FeatureStepsNotFoundException.new([anything, anything])
-      feature.stubs(:scenarios).raises(exception)
-      feature.stubs(:data).returns(data)
+      subject.stubs(:scenarios).raises(exception)
+      subject.stubs(:data).returns(data)
       not_found_called = false
-      feature.class.when_not_found do |data, exception|
+      Spinach.hooks.on_undefined_feature do |data, exception|
         not_found_called = [data, exception]
       end
-      feature.run
+      subject.run
       not_found_called.must_equal [data, exception]
     end
   end

data/test/spinach/runner/scenario_runner_test.rb

@@ -0,0 +1,111 @@
+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
+
+  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
+
+  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 'when throwing exceptions' do
+      it 'rescues a MiniTest::Assertion' do
+        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
+      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
+      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
+
+      it 'returns an failure' do
+        feature_steps.expects(:execute_step).raises(MiniTest::Assertion)
+        subject.run.wont_equal nil
+      end
+    end
+
+    it 'runs a step' do
+      feature_steps.expects(:execute_step).with(anything).times(3)
+      subject.run.must_equal true
+    end
+
+    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
+      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)
+        end
+
+        subject.run
+      end
+    end
+  end
+end