spinach 0.0.6 → 0.1.0

data/test/spinach/reporter/stdout_test.rb

@@ -3,142 +3,403 @@
 require_relative '../../test_helper'
 
 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'},
+      exception]
+  end
+
+  let(:steps) do
+    [error]
+  end
+
+
   before do
-    @reporter = Spinach::Reporter::Stdout.new
+    @out = StringIO.new
+    @error = StringIO.new
+    @reporter = Spinach::Reporter::Stdout.new(
+      output: @out,
+      error: @error
+    )
+  end
+
+  describe '#before_feature_run' do
+    it 'outputs the feature' do
+      @reporter.before_feature_run('name' => 'A cool feature')
+
+      @out.string.must_include 'Feature'
+      @out.string.must_include 'A cool feature'
+    end
   end
 
-  describe "#feature" do
-    it "outputs a feature name" do
-      out = capture_stdout do
-        @reporter.feature "User authentication"
+  describe '#before_scenario_run' do
+    it 'outputs the scenario' do
+      @reporter.before_scenario_run('name' => 'Arbitrary scenario')
+
+      @out.string.must_include 'Scenario'
+      @out.string.must_include 'Arbitrary scenario'
+    end
+  end
+
+  describe '#after_scenario_run' do
+    describe 'in case of error' do
+      let(:exception) { anything }
+
+      before do
+        @reporter.scenario_error = exception
       end
-      out.string.must_match /Feature:.*User authentication/
+
+      it 'reports the full error' do
+        @reporter.expects(:report_error).with(exception, :full)
+
+        @reporter.after_scenario_run('name' => 'Arbitrary scenario')
+      end
+
+      it 'resets the scenario error' do
+        @reporter.stubs(:report_error)
+        @reporter.after_scenario_run('name' => 'Arbitrary scenario')
+
+        @reporter.scenario_error.must_equal nil
+      end
+    end
+  end
+
+  describe '#on_successful_step' do
+    it 'adds the step to the output buffer' do
+      @reporter.on_successful_step({'keyword' => 'Given', 'name' => 'I am too cool'})
+
+      @out.string.must_include '✔'
+      @out.string.must_include 'Given'
+      @out.string.must_include 'am too cool'
+    end
+  end
+
+  describe '#on_failed_step' do
+    let(:step) { {'keyword' => 'Then', 'name' => 'I write failing steps'} }
+
+    it 'adds the step to the output buffer' do
+      @reporter.on_failed_step(step, anything)
+
+      @out.string.must_include '✘'
+      @out.string.must_include 'Then'
+      @out.string.must_include 'I write failing steps'
+    end
+
+    it 'sets the current scenario error' do
+      @reporter.on_failed_step(step, anything)
+
+      @reporter.scenario_error.must_include step
+    end
+
+    it 'adds the step to the failing steps' do
+      @reporter.on_failed_step(step, anything)
+
+      @reporter.failed_steps.last.must_include step
+    end
+  end
+
+  describe '#on_error_step' do
+    let(:step) { {'keyword' => 'And', 'name' => 'I even make syntax errors'} }
+
+    it 'adds the step to the output buffer' do
+      @reporter.on_error_step(step, anything)
+
+      @out.string.must_include '!'
+      @out.string.must_include 'And'
+      @out.string.must_include 'I even make syntax errors'
+    end
+
+    it 'sets the current scenario error' do
+      @reporter.on_error_step(step, anything)
+
+      @reporter.scenario_error.must_include step
+    end
+
+    it 'adds the step to the error steps' do
+      @reporter.on_error_step(step, anything)
+
+      @reporter.error_steps.last.must_include step
     end
   end
 
-  describe "#scenario" do
-    it "outputs a scenario name" do
-      out = capture_stdout do
-        @reporter.scenario "User logs in"
+  describe '#on_undefined_step' do
+    let(:step) { {'keyword' => 'When', 'name' => 'I forgot to write steps'} }
+
+    it 'adds the step to the output buffer' do
+      @reporter.on_undefined_step(step)
+
+      @out.string.must_include '?'
+      @out.string.must_include 'When'
+      @out.string.must_include 'I forgot to write steps'
+    end
+
+    it 'sets the current scenario error' do
+      @reporter.on_undefined_step(step)
+
+      @reporter.scenario_error.must_include step
+    end
+
+    it 'adds the step to the undefined steps' do
+      @reporter.on_undefined_step(step)
+
+      @reporter.undefined_steps.last.must_include step
+    end
+  end
+
+  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'})
+
+      @out.string.must_include '~'
+      @out.string.must_include 'Then'
+      @out.string.must_include 'some steps are not even called'
+    end
+  end
+
+  describe '#output_step' do
+    it 'adds a step to the output buffer with nice colors' do
+      step = {'keyword' => 'Keyword', 'name' => 'step name'}
+      @reporter.output_step('symbol', step, :blue)
+
+      @out.string.must_include 'symbol'
+      @out.string.must_include 'Keyword'
+      @out.string.must_include 'step name'
+    end
+  end
+
+  describe '#after_run' do
+    describe 'when the run has succeed' do
+      it 'does nothing' do
+        @reporter.after_run(true).must_equal nil
+      end
+    end
+
+    describe 'when the run has succeed' do
+      it 'does nothing' do
+        @reporter.stubs(:error_summary).returns('Error summary')
+
+        @reporter.after_run(false).must_equal 'Error summary'
       end
-      out.string.must_match /Scenario:.*User logs in/
     end
   end
 
-  describe "#step" do
-    before do
-      @feature = stubs(name: "Some cool feature")
+  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.error_summary
+
+      @error.string.must_include 'Error 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 succeeding" do
-      it "outputs the step name" do
-        out = capture_stdout do
-          @reporter.step "Given", "I say goodbye", :success
-        end
-        out.string.must_include "✔"
-        out.string.must_match /Given.*I say goodbye/
+
+    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)
 
-    describe "when undefined" do
-      it "outputs the step name with a question mark" do
-        out = capture_stdout do
-          @reporter.step "Given", "I say goodbye", :undefined_step
-        end
-        out.string.must_include "?"
-        out.string.must_match /Given.*I say goodbye/
+        @reporter.report_failed_steps
       end
     end
 
-    describe "when failing" do
-      it "outputs the step name with a failure mark" do
-        out = capture_stdout do
-          @reporter.step "Given", "I say goodbye", :failure
-        end
-        out.string.must_include "✘"
-        out.string.must_match /Given.*I say goodbye/
+    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 "when failing" do
-      it "outputs the step name with a failure mark" do
-        out = capture_stdout do
-          @reporter.step "Given", "I say goodbye", :error
-        end
-        out.string.must_include "!"
-        out.string.must_match /Given.*I say goodbye/
+  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 skipping" do
-      it "outputs the step name with a failure mark" do
-        out = capture_stdout do
-          @reporter.step "Given", "I say nothing", :skip
-        end
-        out.string.must_include "~"
-        out.string.must_match /Given.*I say nothing/
+    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 "#end" do
-    it "outputs a blank line" do
-      out = capture_stdout do
-        @reporter.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, anything))
+
+        String.any_instance.expects(:yellow)
+
+        @reporter.summarized_error(error)
       end
-      out.string.must_include "\n"
     end
   end
 
-  describe "#error_summary" do
+  describe '#full_error' do
     before do
-      make_error = proc do |message|
-        stub(
-          message: message,
-          backtrace: ["foo:1", "bar:2"]
-        )
-      end
-
-      make_scenario = proc do |name|
-        stub(
-          feature_name: name,
-          feature: stub_everything,
-          name: name
-        )
-      end
-
-      @errors = [
-        [make_error.('omg'), "some_file", "3", make_scenario.('feature')],
-        [make_error.('wtf'), "other_file", "9", make_scenario.('feature')],
-      ]
-
-    end
-
-    it "outputs an error summary" do
-      out = capture_stdout do
-        @reporter.error_summary(@errors)
-      end
-      out.string.must_include "omg"
-      out.string.must_include "some_file"
-      out.string.must_include "(line 3)"
-      out.string.must_include "wtf"
-      out.string.must_include "other_file"
-      out.string.must_include "(line 9)"
-      out.string.wont_include "foo:1"
-      out.string.wont_include "bar:2"
-    end
-    it "outputs an error summary with backtrace" do
-      @reporter.options[:backtrace] = true
-      out = capture_stdout do
-        @reporter.error_summary(@errors)
-      end
-      out.string.must_include "omg"
-      out.string.must_include "some_file"
-      out.string.must_include "(line 3)"
-      out.string.must_include "wtf"
-      out.string.must_include "other_file"
-      out.string.must_include "(line 9)"
-      out.string.must_include "foo:1"
-      out.string.must_include "bar:2"
+      @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'
+    end
+
+    it 'strips the arguments' 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, anything)
+
+        String.any_instance.expects(:yellow)
+
+        @reporter.report_exception(undefined_exception)
+      end
     end
   end
 end

data/test/spinach/reporter_test.rb

@@ -1,36 +1,161 @@
 # encoding: utf-8
 require_relative '../test_helper'
 
-describe Spinach::Reporter do
-  describe "abstract methods" do
+module Spinach
+  describe Reporter do
     before do
-      @reporter = Spinach::Reporter.new
+      @options = {
+        backtrace: true
+      }
+      @reporter = Reporter.new(@options)
     end
-    %w{feature scenario}.each do |abstract_method|
-      describe "#{abstract_method}" do
-        it "raises an error" do
-          Proc.new{
-            @reporter.send(abstract_method, "arbitrary name")
-          }.must_raise RuntimeError
+
+    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
+      end
+    end
+
+    describe "#current_feature" do
+      it "returns nil by default" do
+        @reporter.current_feature.must_equal nil
+      end
+    end
+
+    describe "#current_scenario" do
+      it "returns nil by default" do
+        @reporter.current_feature.must_equal nil
+      end
+    end
+
+    %w{undefined_steps failed_steps error_steps}.each do |errors|
+      describe "##{errors}" do
+        it "returns an empty array by default" do
+          @reporter.send(errors).must_be_empty
+        end
+      end
+    end
+
+    describe "#bind" do
+      before do
+        @reporter.stubs(
+          runner: stub_everything,
+          feature_runner: stub_everything,
+          scenario_runner: stub_everything,
+        )
+        @callback = mock
+        @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 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
+      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
+      describe "when running steps" do
+        %w{successful failed error 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
+        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
+        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
+        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
+        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
         end
       end
     end
 
-    describe "#step" do
-      it "raises an error" do
-        Proc.new{
-          @reporter.step("Given", "arbitrary name", :success)
-        }.must_raise RuntimeError
+    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
 
-    describe "#end" do
-      it "raises an error" do
-        Proc.new{
-          @reporter.end
-        }.must_raise RuntimeError
+    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
-  end
 
+    describe "runner classes" do
+      describe "#feature_runner" do
+        it "returns a runner class" do
+          @reporter.feature_runner.must_be_kind_of Class
+        end
+      end
+      describe "#scenario_runner" do
+        it "returns a runner class" do
+          @reporter.scenario_runner.must_be_kind_of Class
+        end
+      end
+      describe "#runner" do
+        it "returns a runner class" do
+          @reporter.runner.must_be_kind_of Class
+        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)
+          end
+        end
+      end
+    end
+
+  end
 end