rspec 1.0.8 → 1.1.0

data/spec/spec/runner/formatter/story/html_formatter_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
+require 'spec/runner/formatter/story/html_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      module Story
+        describe HtmlFormatter do
+          before :each do
+            @out = StringIO.new
+            @options = mock('options')
+            @reporter = HtmlFormatter.new(@options, @out)
+          end
+          
+          it "should just be poked at" do
+            @reporter.run_started(1)
+            @reporter.story_started('story_title', 'narrative')
+
+            @reporter.scenario_started('story_title', 'succeeded_scenario_name')
+            @reporter.step_succeeded('given', 'succeded_step', 'one', 'two')
+            @reporter.scenario_succeeded('story_title', 'succeeded_scenario_name')
+
+            @reporter.scenario_started('story_title', 'pending_scenario_name')
+            @reporter.step_pending('when', 'pending_step', 'un', 'deux')
+            @reporter.scenario_pending('story_title', 'pending_scenario_name', 'not done')
+
+            @reporter.scenario_started('story_title', 'failed_scenario_name')
+            @reporter.step_failed('then', 'failed_step', 'en', 'to')
+            @reporter.scenario_failed('story_title', 'failed_scenario_name', NameError.new('sup'))
+            
+            @reporter.scenario_started('story_title', 'scenario_with_given_scenario_name')
+            @reporter.found_scenario('given scenario', 'succeeded_scenario_name')
+            
+            @reporter.story_ended('story_title', 'narrative')
+            @reporter.run_ended
+          end
+          
+          it "should create spans for params" do
+            @reporter.step_succeeded('given', 'a $coloured $animal', 'brown', 'dog')
+            @out.string.should == "                <li class=\"passed\">Given a <span class=\"param\">brown</span> <span class=\"param\">dog</span></li>\n"
+          end
+          
+          it "should create a ul for collected_steps" do
+            @reporter.collected_steps(['Given a $coloured $animal', 'Given a $n legged eel'])
+            @out.string.should == (<<-EOF)
+      <ul id="stock_steps" style="display: none;">
+        <li>Given a $coloured $animal</li>
+        <li>Given a $n legged eel</li>
+      </ul>
+EOF
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner/formatter/story/plain_text_formatter_spec.rb

@@ -0,0 +1,289 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper.rb'
+require 'spec/runner/formatter/story/plain_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      module Story
+        describe PlainTextFormatter do
+          before :each do
+            # given
+            @out = StringIO.new
+            @options = mock('options')
+            @options.stub!(:colour).and_return(false)
+            @formatter = PlainTextFormatter.new(@options, @out)
+          end
+        
+          it 'should summarize the number of scenarios when the run ends' do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario2')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario3')
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include('3 scenarios')
+          end
+        
+          it 'should summarize the number of successful scenarios when the run ends' do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario2')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario3')
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include('3 scenarios: 3 succeeded')
+          end
+        
+          it 'should summarize the number of failed scenarios when the run ends' do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("3 scenarios: 1 succeeded, 2 failed")
+          end
+        
+          it 'should summarize the number of pending scenarios when the run ends' do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_pending('story', 'scenario2', 'message')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_pending('story', 'scenario3', 'message')
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("3 scenarios: 1 succeeded, 0 failed, 2 pending")
+          end
+        
+          it "should only count the first failure in one scenario" do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops again' })
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("3 scenarios: 1 succeeded, 2 failed")
+          end
+        
+          it "should only count the first pending in one scenario" do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_pending('story', 'scenario2', 'because ...')
+            @formatter.scenario_pending('story', 'scenario2', 'because ...')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_pending('story', 'scenario3', 'because ...')
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("3 scenarios: 1 succeeded, 0 failed, 2 pending")
+          end
+        
+          it "should only count a failure before the first pending in one scenario" do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_pending('story', 'scenario2', exception_from { raise RuntimeError, 'oops' })
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops again' })
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops' })
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("3 scenarios: 1 succeeded, 1 failed, 1 pending")
+          end
+        
+          it 'should produce details of the first failure each failed scenario when the run ends' do
+            # when
+            @formatter.run_started(3)
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_succeeded('story', 'scenario1')
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops2' })
+            @formatter.scenario_failed('story', 'scenario2', exception_from { raise RuntimeError, 'oops2 - this one should not appear' })
+            @formatter.scenario_started(nil, nil)
+            @formatter.scenario_failed('story', 'scenario3', exception_from { raise RuntimeError, 'oops3' })
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("FAILURES:\n")
+            @out.string.should include("1) story (scenario2) FAILED")
+            @out.string.should include("RuntimeError: oops2")
+            @out.string.should_not include("RuntimeError: oops2 - this one should not appear")
+            @out.string.should include("2) story (scenario3) FAILED")
+            @out.string.should include("RuntimeError: oops3")
+          end
+        
+          it 'should produce details of each pending step when the run ends' do
+            # when
+            @formatter.run_started(2)
+            @formatter.scenario_pending('story', 'scenario2', 'todo2')
+            @formatter.scenario_pending('story', 'scenario3', 'todo3')
+            @formatter.run_ended
+          
+            # then
+            @out.string.should include("Pending Steps:\n")
+            @out.string.should include("1) story (scenario2): todo2")
+            @out.string.should include("2) story (scenario3): todo3")
+          end
+        
+          it 'should document a story title and narrative' do
+            # when
+            @formatter.story_started 'story', 'narrative'
+          
+            # then
+            @out.string.should include("Story: story\n\n  narrative")
+          end
+        
+          it 'should document a scenario name' do
+            # when
+            @formatter.scenario_started 'story', 'scenario'
+          
+            # then
+            @out.string.should include("\n\n  Scenario: scenario")
+          end
+        
+          it 'should document a step by sentence-casing its name' do
+            # when
+            @formatter.step_succeeded :given, 'a context'
+            @formatter.step_succeeded :when, 'an event'
+            @formatter.step_succeeded :then, 'an outcome'
+          
+            # then
+            @out.string.should include("\n\n    Given a context\n\n    When an event\n\n    Then an outcome")
+          end
+        
+          it 'should document additional givens using And' do
+            # when
+            @formatter.step_succeeded :given, 'step 1'
+            @formatter.step_succeeded :given, 'step 2'
+            @formatter.step_succeeded :given, 'step 3'
+          
+            # then
+            @out.string.should include("    Given step 1\n    And step 2\n    And step 3")
+          end
+        
+          it 'should document additional events using And' do
+            # when
+            @formatter.step_succeeded :when, 'step 1'
+            @formatter.step_succeeded :when, 'step 2'
+            @formatter.step_succeeded :when, 'step 3'
+          
+            # then
+            @out.string.should include("    When step 1\n    And step 2\n    And step 3")
+          end
+        
+          it 'should document additional outcomes using And' do
+            # when
+            @formatter.step_succeeded :then, 'step 1'
+            @formatter.step_succeeded :then, 'step 2'
+            @formatter.step_succeeded :then, 'step 3'
+          
+            # then
+            @out.string.should include("    Then step 1\n    And step 2\n    And step 3")
+          end
+        
+          it 'should document a GivenScenario followed by a Given using And' do
+            # when
+            @formatter.step_succeeded :'given scenario', 'a scenario'
+            @formatter.step_succeeded :given, 'a context'
+          
+            # then
+            @out.string.should include("    Given scenario a scenario\n    And a context")
+          end
+        
+          it 'should document steps with replaced params' do
+            @formatter.step_succeeded :given, 'a $coloured dog with $n legs', 'pink', 21
+            @out.string.should include("  Given a pink dog with 21 legs")
+          end
+        
+          it "should append PENDING for the first pending step" do
+            @formatter.scenario_started('','')
+            @formatter.step_pending(:given, 'a context')
+          
+            @out.string.should include('Given a context (PENDING)')
+          end
+        
+          it "should append PENDING for pending after already pending" do
+            @formatter.scenario_started('','')
+            @formatter.step_pending(:given, 'a context')
+            @formatter.step_pending(:when, 'I say hey')
+          
+            @out.string.should include('When I say hey (PENDING)')
+          end
+        
+          it "should append FAILED for the first failiure" do
+            @formatter.scenario_started('','')
+            @formatter.step_failed(:given, 'a context')
+          
+            @out.string.should include('Given a context (FAILED)')
+          end
+        
+          it "should append SKIPPED for the second failiure" do
+            @formatter.scenario_started('','')
+            @formatter.step_failed(:given, 'a context')
+            @formatter.step_failed(:when, 'I say hey')
+          
+            @out.string.should include('When I say hey (SKIPPED)')
+          end
+        
+          it "should append SKIPPED for the a failiure after PENDING" do
+            @formatter.scenario_started('','')
+            @formatter.step_pending(:given, 'a context')
+            @formatter.step_failed(:when, 'I say hey')
+          
+            @out.string.should include('When I say hey (SKIPPED)')
+          end
+        
+          it 'should print some white space after each story' do
+            # when
+            @formatter.story_ended 'title', 'narrative'
+          
+            # then
+            @out.string.should include("\n\n")
+          end
+          
+          it "should print nothing for collected_steps" do
+            @formatter.collected_steps(['Given a $coloured $animal', 'Given a $n legged eel'])
+            @out.string.should == ("")
+          end
+          
+          it "should ignore messages it doesn't care about" do
+            lambda {
+              @formatter.this_method_does_not_exist
+            }.should_not raise_error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner/heckle_runner_spec.rb

@@ -17,47 +17,62 @@ unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM}
   describe "HeckleRunner" do
     before(:each) do
       @heckle = mock("heckle", :null_object => true)
-      @behaviour_runner = mock("behaviour_runner")
       @heckle_class = mock("heckle_class")
     end
 
     it "should heckle all methods in all classes in a module" do
-      @heckle_class.should_receive(:new).with("Foo::Bar", "one", behaviour_runner).and_return(@heckle)
-      @heckle_class.should_receive(:new).with("Foo::Bar", "two", behaviour_runner).and_return(@heckle)
-      @heckle_class.should_receive(:new).with("Foo::Zap", "three", behaviour_runner).and_return(@heckle)
-      @heckle_class.should_receive(:new).with("Foo::Zap", "four", behaviour_runner).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "one", rspec_options).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Zap", "three", rspec_options).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Zap", "four", rspec_options).and_return(@heckle)
 
       heckle_runner = Spec::Runner::HeckleRunner.new("Foo", @heckle_class)
-      heckle_runner.heckle_with(behaviour_runner)
+      heckle_runner.heckle_with
     end
 
     it "should heckle all methods in a class" do
-      @heckle_class.should_receive(:new).with("Foo::Bar", "one", behaviour_runner).and_return(@heckle)
-      @heckle_class.should_receive(:new).with("Foo::Bar", "two", behaviour_runner).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "one", rspec_options).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
 
       heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar", @heckle_class)
-      heckle_runner.heckle_with(behaviour_runner)
+      heckle_runner.heckle_with
     end
 
     it "should fail heckling when the class is not found" do
       lambda do
         heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bob", @heckle_class)
-        heckle_runner.heckle_with(behaviour_runner)
+        heckle_runner.heckle_with
       end.should raise_error(StandardError, "Heckling failed - \"Foo::Bob\" is not a known class or module")
     end
 
     it "should heckle specific method in a class (with #)" do
-      @heckle_class.should_receive(:new).with("Foo::Bar", "two", behaviour_runner).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
 
       heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar#two", @heckle_class)
-      heckle_runner.heckle_with(behaviour_runner)
+      heckle_runner.heckle_with
     end
 
     it "should heckle specific method in a class (with .)" do
-      @heckle_class.should_receive(:new).with("Foo::Bar", "two", behaviour_runner).and_return(@heckle)
+      @heckle_class.should_receive(:new).with("Foo::Bar", "two", rspec_options).and_return(@heckle)
 
       heckle_runner = Spec::Runner::HeckleRunner.new("Foo::Bar.two", @heckle_class)
-      heckle_runner.heckle_with(behaviour_runner)
+      heckle_runner.heckle_with
+    end
+  end
+  
+  describe "Heckler" do
+    it "should say yes to tests_pass? if specs pass" do
+      options = mock("options", :null_object => true)
+      options.should_receive(:run_examples).and_return(true)
+      heckler = Spec::Runner::Heckler.new("Foo", nil, options)
+      heckler.tests_pass?.should be_true
+    end
+
+    it "should say no to tests_pass? if specs fail" do
+      options = mock("options", :null_object => true)
+      options.should_receive(:run_examples).and_return(false)
+      heckler = Spec::Runner::Heckler.new("Foo", nil, options)
+      heckler.tests_pass?.should be_false
     end
   end
 end

data/spec/spec/runner/heckler_spec.rb

@@ -3,11 +3,10 @@ unless [/mswin/, /java/].detect{|p| p =~ RUBY_PLATFORM}
   require 'spec/runner/heckle_runner'
 
   describe "Heckler" do
-    it "should run behaviour_runner on tests_pass?" do
-      behaviour_runner = mock("behaviour_runner")
-      behaviour_runner.should_receive(:run).with([], false)
-      heckler = Spec::Runner::Heckler.new('Array', 'push', behaviour_runner)
-
+    it "should run examples on tests_pass?" do
+      options = Spec::Runner::Options.new(StringIO.new, StringIO.new)
+      options.should_receive(:run_examples).with().and_return(&options.method(:run_examples))
+      heckler = Spec::Runner::Heckler.new('Array', 'push', options)
       heckler.tests_pass?
     end
   end

data/spec/spec/runner/noisy_backtrace_tweaker_spec.rb

@@ -11,32 +11,32 @@ module Spec
       it "should leave anything in lib spec dir" do
         ["expectations", "mocks", "runner", "stubs"].each do |child|
           @error.set_backtrace(["/lib/spec/#{child}/anything.rb"])
-          @tweaker.tweak_backtrace(@error, "spec name")
+          @tweaker.tweak_backtrace(@error)
           @error.backtrace.should_not be_empty
         end
       end
 
       it "should leave anything in spec dir" do
         @error.set_backtrace(["/lib/spec/expectations/anything.rb"])
-        @tweaker.tweak_backtrace(@error, "spec name")
+        @tweaker.tweak_backtrace(@error)
         @error.backtrace.should_not be_empty
       end
 
       it "should leave bin spec" do
         @error.set_backtrace(["bin/spec:"])
-        @tweaker.tweak_backtrace(@error, "spec name")
+        @tweaker.tweak_backtrace(@error)
         @error.backtrace.should_not be_empty
       end
 
       it "should not barf on nil backtrace" do
         lambda do
-          @tweaker.tweak_backtrace(@error, "spec name")
+          @tweaker.tweak_backtrace(@error)
         end.should_not raise_error
       end
       
       it "should clean up double slashes" do
         @error.set_backtrace(["/a//b/c//d.rb"])
-        @tweaker.tweak_backtrace(@error, "spec name")
+        @tweaker.tweak_backtrace(@error)
         @error.backtrace.should include("/a/b/c/d.rb")
       end