rspec 1.2.9 → 1.3.1

data/spec/spec/matchers/throw_symbol_spec.rb

@@ -4,91 +4,116 @@ module Spec
   module Matchers
     describe ThrowSymbol do
       describe "with no args" do
-        before(:each) { @matcher = ThrowSymbol.new }
-      
-        it "should match if any Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_true
+        let(:matcher) { throw_symbol }
+
+        it "matches if any Symbol is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_true
         end
-        it "should match if any Symbol is thrown with an arg" do
-          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+
+        it "matches if any Symbol is thrown with an arg" do
+          matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
         end
-        it "should not match if no Symbol is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
+
+        it "does not match if no Symbol is thrown" do
+          matcher.matches?(lambda{ }).should be_false
         end
-        it "should provide a failure message" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown"
+
+        it "provides a failure message" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == "expected a Symbol but nothing was thrown"
         end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym})
-          @matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym"
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym})
+          matcher.failure_message_for_should_not.should == "expected no Symbol, got :sym"
         end
       end
-          
+
       describe "with a symbol" do
-        before(:each) { @matcher = ThrowSymbol.new(:sym) }
-      
-        it "should match if correct Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_true
+        let(:matcher) { throw_symbol(:sym) }
+
+        it "matches if correct Symbol is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_true
         end
-        it "should match if correct Symbol is thrown with an arg" do
-          @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+
+        it "matches if correct Symbol is thrown with an arg" do
+          matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
         end
-        it "should not match if no Symbol is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
+
+        it "does not match if no Symbol is thrown" do
+          matcher.matches?(lambda{ }).should be_false
         end
-        it "should not match if correct Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym }).should be_false
+
+        it "does not match if correct Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym }).should be_false
         end
-        it "should provide a failure message when no Symbol is thrown" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == "expected :sym but nothing was thrown"
+
+        it "provides a failure message when no Symbol is thrown" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == "expected :sym but nothing was thrown"
         end
-        it "should provide a failure message when wrong Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == "expected :sym, got :other_sym"
+
+        it "provides a failure message when wrong Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym })
+          matcher.failure_message_for_should.should == "expected :sym, got :other_sym"
         end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown"
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym })
+          matcher.failure_message_for_should_not.should == "expected :sym not to be thrown"
         end
+
         it "should only match NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+          matcher.matches?(lambda{ :sym }).should be_false
+        end
+        
+        it "bubbles up errors other than NameError" do
+          lambda do
+            matcher.matches?(lambda{ raise 'foo' })
+          end.should raise_error('foo')
         end
       end
 
       describe "with a symbol and an arg" do
-        before(:each) { @matcher = ThrowSymbol.new(:sym, "a") }
-    
-        it "should match if correct Symbol and args are thrown" do
-          @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+        let(:matcher) { throw_symbol(:sym, "a") }
+
+        it "matches if correct Symbol and args are thrown" do
+          matcher.matches?(lambda{ throw :sym, "a" }).should be_true
         end
-        it "should not match if nothing is thrown" do
-          @matcher.matches?(lambda{ }).should be_false
+
+        it "does not match if nothing is thrown" do
+          matcher.matches?(lambda{ }).should be_false
         end
-        it "should not match if other Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+
+        it "does not match if other Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
         end
-        it "should not match if no arg is thrown" do
-          @matcher.matches?(lambda{ throw :sym }).should be_false
+
+        it "does not match if no arg is thrown" do
+          matcher.matches?(lambda{ throw :sym }).should be_false
         end
-        it "should not match if wrong arg is thrown" do
-          @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+
+        it "does not match if wrong arg is thrown" do
+          matcher.matches?(lambda{ throw :sym, "b" }).should be_false
         end
-        it "should provide a failure message when no Symbol is thrown" do
-          @matcher.matches?(lambda{})
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown]
+
+        it "provides a failure message when no Symbol is thrown" do
+          matcher.matches?(lambda{})
+          matcher.failure_message_for_should.should == %q[expected :sym with "a" but nothing was thrown]
         end
-        it "should provide a failure message when wrong Symbol is thrown" do
-          @matcher.matches?(lambda{ throw :other_sym })
-          @matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym]
+
+        it "provides a failure message when wrong Symbol is thrown" do
+          matcher.matches?(lambda{ throw :other_sym })
+          matcher.failure_message_for_should.should == %q[expected :sym with "a", got :other_sym]
         end
-        it "should provide a negative failure message" do
-          @matcher.matches?(lambda{ throw :sym })
-          @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown]
+
+        it "provides a negative failure message" do
+          matcher.matches?(lambda{ throw :sym })
+          matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown]
         end
-        it "should only match NameErrors raised by uncaught throws" do
-          @matcher.matches?(lambda{ sym }).should be_false
+
+        it "only matches NameErrors raised by uncaught throws" do
+          matcher.matches?(lambda{ :sym }).should be_false
         end
       end
     end

data/spec/spec/mocks/and_yield_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module Spec
+  module Mocks
+    describe Mock do
+      describe "#and_yield" do
+
+        context "with eval context as block argument" do
+          let(:obj) { double }
+
+          it "evaluates the supplied block as it is read" do
+            evaluated = false
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              evaluated = true
+            end
+            evaluated.should be_true
+          end
+
+          it "passes an eval context object to the supplied block" do
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              eval_context.should_not be_nil
+            end
+          end
+
+          it "evaluates the block passed to the stubbed method in the context of the supplied eval context" do
+            expected_eval_context = nil
+            actual_eval_context = nil
+
+            obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+              expected_eval_context = eval_context
+            end
+
+            obj.method_that_accepts_a_block do
+              actual_eval_context = self
+            end
+
+            actual_eval_context.should equal(expected_eval_context)
+          end
+
+          context "and no yielded arguments" do
+
+            it "passes when expectations set on the eval context are met" do
+              configured_eval_context = nil
+              obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+              end
+
+              obj.method_that_accepts_a_block do
+                foo
+              end
+
+              configured_eval_context.rspec_verify
+            end
+
+            it "fails when expectations set on the eval context are not met" do
+              configured_eval_context = nil
+              obj.stub(:method_that_accepts_a_block).and_yield do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+              end
+
+              obj.method_that_accepts_a_block do
+                # foo is not called here
+              end
+
+              lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError)
+            end
+
+          end
+
+          context "and yielded arguments" do
+
+            it "passes when expectations set on the eval context and yielded arguments are met" do
+              configured_eval_context = nil
+              yielded_arg = Object.new
+              obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+                yielded_arg.should_receive(:bar)
+              end
+
+              obj.method_that_accepts_a_block do |obj|
+                obj.bar
+                foo
+              end
+
+              configured_eval_context.rspec_verify
+              yielded_arg.rspec_verify
+            end
+
+            it "fails when expectations set on the eval context and yielded arguments are not met" do
+              configured_eval_context = nil
+              yielded_arg = Object.new
+              obj.stub(:method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
+                configured_eval_context = eval_context
+                configured_eval_context.should_receive(:foo)
+                yielded_arg.should_receive(:bar)
+              end
+
+              obj.method_that_accepts_a_block do |obj|
+                # obj.bar is not called here
+                # foo is not called here
+              end
+
+              lambda {configured_eval_context.rspec_verify}.should raise_error(MockExpectationError)
+              lambda {yielded_arg.rspec_verify}.should raise_error(MockExpectationError)
+            end
+
+          end
+
+        end
+      end
+    end
+  end
+end
+

data/spec/spec/mocks/bug_report_496_spec.rb

@@ -9,10 +9,8 @@ module BugReport496
 
   describe "a message expectation on a base class object" do
     it "should correctly pick up message sent to it subclass" do
-      pending("fix for http://rspec.lighthouseapp.com/projects/5645/tickets/496") do
-        BaseClass.should_receive(:new).once
-        SubClass.new
-      end
+      BaseClass.should_receive(:new).once
+      SubClass.new
     end
   end
 end

data/spec/spec/mocks/mock_spec.rb

@@ -150,7 +150,7 @@ module Spec
         @mock.should_receive(:something) {| bool | bool.should be_true}
         lambda {
           @mock.something false
-        }.should raise_error(MockExpectationError, /Mock "test mock" received :something but passed block failed with: expected true, got false/)
+        }.should raise_error(MockExpectationError, /Mock "test mock" received :something but passed block failed with: expected false to be true/)
       end
 
       it "should fail right away when method defined as never is received" do
@@ -359,7 +359,7 @@ module Spec
           @mock.yield_back
         }.should raise_error(MockExpectationError, "Mock \"test mock\" asked to yield |[\"wha\", \"zup\"]| but no block was passed")
       end
-
+      
       it "should be able to mock send" do
         @mock.should_receive(:send).with(any_args)
         @mock.send 'hi'

data/spec/spec/runner/command_line_spec.rb

@@ -9,7 +9,7 @@ module Spec
           @err = options.error_stream
           @out = options.output_stream
         end
-      
+
         it "should run directory" do
           file = File.dirname(__FILE__) + '/../../../examples/passing'
           run_with(OptionParser.parse([file,"-p","**/*_spec.rb,**/*_example.rb"], @err, @out))
@@ -41,7 +41,7 @@ module Spec
           ).should be_true
         end
 
-        it "should dump even if Interrupt exception is occurred" do
+        it "should exit if Interrupt exception occurrs during the spec" do
           example_group = Class.new(::Spec::Example::ExampleGroup) do
             describe("example_group")
             it "no error" do
@@ -54,10 +54,31 @@ module Spec
 
           options = ::Spec::Runner::Options.new(@err, @out)
           ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
-          options.reporter.should_receive(:dump)
           options.add_example_group(example_group)
 
-          Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          expect {
+            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          }.to raise_error(SystemExit)
+        end
+
+        it "should exit if Interrupt exception occurrs during an after(:each)" do
+          example_group = Class.new(::Spec::Example::ExampleGroup) do
+            describe("example_group")
+            it "no error" do
+            end
+
+            after do
+              raise Interrupt, "I'm interrupting"
+            end
+          end
+
+          options = ::Spec::Runner::Options.new(@err, @out)
+          ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
+          options.add_example_group(example_group)
+
+          expect {
+            Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
+          }.to raise_error(SystemExit)
         end
 
         it "should heckle when options have heckle_runner" do
@@ -107,7 +128,7 @@ module Spec
 
           ::Spec::Runner::Options.should_receive(:new).with(@err, @out).and_return(options)
           options.reporter.should_receive(:add_example_group).with(Spec::Example::ExampleGroupProxy.new(example_group))
-        
+
           Spec::Runner::CommandLine.run(OptionParser.parse([], @err, @out))
         end
 

data/spec/spec/runner/drb_command_line_spec.rb

@@ -101,6 +101,45 @@ module Spec
           end
         end
 
+        context "#port" do
+          before do
+            @options = stub("options", :drb_port => nil)
+          end
+          
+          context "with no additional configuration" do
+            it "defaults to 8989" do
+              Spec::Runner::DrbCommandLine.port(@options).should == 8989
+            end
+          end
+          
+          context "with RSPEC_DRB environment variable set" do
+            def with_RSPEC_DRB_set_to(val)
+              original = ENV['RSPEC_DRB']
+              begin
+                ENV['RSPEC_DRB'] = val
+                yield
+              ensure
+                ENV['RSPEC_DRB'] = original
+              end
+            end
+            
+            it "uses RSPEC_DRB value" do
+              with_RSPEC_DRB_set_to('9000') do
+                Spec::Runner::DrbCommandLine.port(@options).should == 9000
+              end
+            end
+
+            context "and config variable set" do
+              it "uses configured value" do
+                @options.stub(:drb_port => '5000')
+                with_RSPEC_DRB_set_to('9000') do
+                  Spec::Runner::DrbCommandLine.port(@options).should == 5000
+                end
+              end
+            end
+
+          end
+        end
       end
     end
   end

data/spec/spec/runner/formatter/nested_text_formatter_spec.rb

@@ -9,8 +9,6 @@ module Spec
           attr_reader :io, :options, :formatter, :example_group
           before(:each) do
             @io = StringIO.new
-            options.stub!(:dry_run).and_return(false)
-            options.stub!(:colour).and_return(false)
             @formatter = NestedTextFormatter.new(options, io)
             @example_group = Class.new(::Spec::Example::ExampleGroupDouble).describe("ExampleGroup")
             @example_group.example("example") {}
@@ -21,12 +19,12 @@ module Spec
               formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(example_group))
             end
 
-            before do
+            before(:each) do
               example_group_started
             end
 
             describe "#dump_summary" do
-              it "should produce standard summary without pending when pending has a 0 count" do
+              it "produces standard summary without pending when pending has a 0 count" do
                 formatter.dump_summary(3, 2, 1, 0)
                 io.string.should == <<-OUT
 ExampleGroup
@@ -37,7 +35,7 @@ Finished in 3 seconds
 OUT
               end
 
-              it "should produce standard summary" do
+              it "produces standard summary" do
                 formatter.dump_summary(3, 2, 1, 4)
                 io.string.should == <<-OUT
 ExampleGroup
@@ -50,10 +48,11 @@ OUT
             end
 
             describe "#example_group_started" do
+
               describe "when ExampleGroup has a nested description" do
-                
+
                 describe "when ExampleGroup has no parents with nested description" do
-                  it "should push ExampleGroup name" do
+                  it "pushes ExampleGroup name" do
                     io.string.should eql("ExampleGroup\n")
                   end
                 end
@@ -69,7 +68,7 @@ OUT
                       formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(child_example_group))
                     end
 
-                    it "should push ExampleGroup name with two spaces of indentation" do
+                    it "pushes ExampleGroup name with two spaces of indentation" do
                       io.string.should == <<-OUT
 ExampleGroup
   Child ExampleGroup
@@ -102,10 +101,9 @@ OUT
                   describe "and parent ExampleGroups have not been printed" do
                     before do
                       formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grand_child_example_group))
-                      
                     end
 
-                    it "should print the entire nested ExampleGroup heirarchy" do
+                    it "prints the entire nested ExampleGroup heirarchy" do
                       io.string.should == <<-OUT
 ExampleGroup
   Child ExampleGroup
@@ -170,6 +168,32 @@ OUT
                   io.string.should == ""
                 end
               end
+
+              describe "with parallel groups" do
+                def make_group(name, parent=::Spec::Example::ExampleGroupDouble)
+                  Class.new(parent).describe(name)
+                end
+
+                it "excludes duplicated group" do
+                  parent_1 = make_group("ExampleGroup") 
+                  child_1 = make_group("Child ExampleGroup", parent_1) 
+                  grandchild_1 = make_group("GrandChild ExampleGroup", child_1) 
+
+                  parent_2 = make_group("ExampleGroup") 
+                  child_2 = make_group("Child ExampleGroup 2", parent_2) 
+                  grandchild_2 = make_group("GrandChild ExampleGroup", child_2) 
+
+                  formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grandchild_1))
+                  formatter.example_group_started(Spec::Example::ExampleGroupProxy.new(grandchild_2))
+                  io.string.should == <<-OUTPUT
+ExampleGroup
+  Child ExampleGroup
+    GrandChild ExampleGroup
+  Child ExampleGroup 2
+    GrandChild ExampleGroup
+OUTPUT
+                end
+              end
             end
 
             describe "#example_failed" do
@@ -302,4 +326,4 @@ OUT
       end
     end
   end
-end
+end

data/spec/spec/runner/option_parser_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 require 'spec/runner/resources/custom_example_group_runner'
-require 'fakefs/safe'
 require 'fakefs/spec_helpers'
 
 describe "OptionParser" do  
@@ -15,10 +14,8 @@ describe "OptionParser" do
     @parser.options
   end
   
-  # FIXME - this entire file should run w/ fakefs
   describe "with fakefs" do
-    extend FakeFS::SpecHelpers
-    use_fakefs
+    include FakeFS::SpecHelpers
 
     it "should not use colour by default" do
       options = parse([])
@@ -63,6 +60,15 @@ describe "OptionParser" do
     options = parse(["--drb", "-u"])
     options.debug.should be_false
   end
+
+  it "should accept port option" do
+    options = parse(["--port", "9000"])
+    options.drb_port.should == 9000
+  end
+
+  it 'should require argument to port option' do
+    lambda { parse(["--port"]) }.should raise_error(OptionParser::MissingArgument)
+  end
   
   it "should accept dry run option" do
     options = parse(["--dry-run"])
@@ -518,8 +524,8 @@ describe "OptionParser" do
   end
   
   describe "implicitly loading spec/spec.opts" do
-    extend FakeFS::SpecHelpers
-    use_fakefs
+    include FakeFS::SpecHelpers
+
     it "uses spec/spec.opts if present" do
       File.open('spec/spec.opts', 'w') { |f| f.write "--colour" }
       options = parse(['ignore.rb'])

data/spec/spec/runner/options_spec.rb

@@ -266,6 +266,13 @@ module Spec
         end
       end
 
+      describe "#drb_port" do
+        it "returns a number" do
+          @options.drb_port = "400"
+          @options.drb_port.should == 400
+        end
+      end
+
       describe "#number_of_examples" do
         context "when --example is parsed" do
           it "provides the number of examples parsed instead of the total number of examples collected" do

data/spec/spec/runner/quiet_backtrace_tweaker_spec.rb

@@ -9,12 +9,12 @@ module Spec
       end
 
       it "gracefully handles nil backtrace" do
-        lambda do
+        expect do
           @tweaker.tweak_backtrace(@error)
-        end.should_not raise_error
+        end.to_not raise_error
       end
 
-      it "gracefully handle backtraces with newlines" do
+      it "gracefully handles backtraces with newlines" do
         @error.set_backtrace(["we like\nbin/spec:\nnewlines"])
         @tweaker.tweak_backtrace(@error)
         @error.backtrace.should include("we like\nnewlines")
@@ -47,6 +47,24 @@ module Spec
         @error.backtrace.should be_empty
       end
 
+      it "preserves lines in spec" do
+        @error.set_backtrace(["spec/foo/bar_spec.rb"])
+        @tweaker.tweak_backtrace(@error)
+        @error.backtrace.should == ["spec/foo/bar_spec.rb"]
+      end
+
+      it "preserves lines in ./spec" do
+        @error.set_backtrace(["./spec/foo/bar_spec.rb"])
+        @tweaker.tweak_backtrace(@error)
+        @error.backtrace.should == ["./spec/foo/bar_spec.rb"]
+      end
+
+      it "preserves lines in /path/to/project/spec" do
+        @error.set_backtrace(["/path/to/project/spec/foo/bar_spec.rb"])
+        @tweaker.tweak_backtrace(@error)
+        @error.backtrace.should == ["/path/to/project/spec/foo/bar_spec.rb"]
+      end
+
       it "removes lines in mock_frameworks/rspec" do
         element = "mock_frameworks/rspec"
         @error.set_backtrace([element])
@@ -54,7 +72,7 @@ module Spec
         @error.backtrace.should be_empty, "Should have removed line with '#{element}'"
       end
 
-      it "removes custom patterns" do
+      it "removes custom patterns in regexp form" do
         element = "/vendor/lib/custom_pattern/"
         @tweaker.ignore_patterns /custom_pattern/
         @error.set_backtrace([element])
@@ -62,7 +80,7 @@ module Spec
         @error.backtrace.should be_empty, "Should have removed line with '#{element}'"
       end
 
-      it "removes custom patterns added as a string" do
+      it "removes custom patterns in string form" do
         element = "/vendor/lib/custom_pattern/"
         @tweaker.ignore_patterns "custom_pattern"
         @error.set_backtrace([element])

data/spec/spec_helper.rb

@@ -1,3 +1,4 @@
+$: << '.' # for ruby 1.9
 require 'stringio'
 
 $_spec_spec = true # Prevents Kernel.exit in various places
@@ -109,4 +110,4 @@ end
 
 Spec::Runner.configure do |config|
   config.extend(Macros)
-end
+end