newbamboo-rspec 1.1.12

data/spec/spec/example/example_matcher_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+module Spec
+  module Example
+    describe ExampleMatcher, "#matches?" do
+      def match_description(description)
+        simple_matcher do |actual, matcher|
+          matcher.failure_message = "expected matcher.matches?(#{description.inspect}) to return true, got false"
+          matcher.negative_failure_message = "expected matcher.matches?(#{description.inspect}) to return false, got true"
+          actual.matches?(description)
+        end
+      end
+      
+      it "should match correct example_group and example" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_description("example_group example")
+      end
+      
+      it "should not match wrong example" do
+        matcher = ExampleMatcher.new("example_group", "other example")
+        matcher.should_not match_description("example_group example")
+      end
+      
+      it "should not match wrong example_group" do
+        matcher = ExampleMatcher.new("other example_group", "example")
+        matcher.should_not match_description("example_group example")
+      end
+      
+      it "should match example only" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_description("example")
+      end
+
+      it "should match example_group only" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_description("example_group")
+      end
+
+      it "should match example_group ending with before(:all)" do
+        matcher = ExampleMatcher.new("example_group", "example")
+        matcher.should match_description("example_group before(:all)")
+      end
+      
+      it "should escape regexp chars" do
+        matcher = ExampleMatcher.new("(con|text)", "[example]")
+        matcher.should_not match_description("con p")
+      end
+      
+      it "should match when example_group is modularized" do
+        matcher = ExampleMatcher.new("MyModule::MyClass", "example")
+        matcher.should match_description("MyClass example")
+      end      
+    end
+
+    describe ExampleMatcher, "#matches? normal case" do
+      it "matches when passed in example matches" do
+        matcher = ExampleMatcher.new("Foo", "bar")
+        matcher.matches?(["no match", "Foo bar"]).should == true
+      end
+
+      it "does not match when no passed in examples match" do
+        matcher = ExampleMatcher.new("Foo", "bar")
+        matcher.matches?(["no match1", "no match2"]).should == false
+      end
+    end
+
+    describe ExampleMatcher, "#matches? where description has '::' in it" do
+      it "matches when passed in example matches" do
+        matcher = ExampleMatcher.new("Foo::Bar", "baz")
+        matcher.matches?(["no match", "Foo::Bar baz"]).should == true
+      end
+
+      it "does not match when no passed in examples match" do
+        matcher = ExampleMatcher.new("Foo::Bar", "baz")
+        matcher.matches?(["no match1", "no match2"]).should == false
+      end
+    end
+  end
+end

data/spec/spec/example/example_methods_spec.rb

@@ -0,0 +1,204 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe ExampleMethods do
+      module ModuleThatIsReopened; end
+
+      module ExampleMethods
+        include ModuleThatIsReopened
+      end
+
+      module ModuleThatIsReopened
+        def module_that_is_reopened_method; end
+      end
+
+      describe "with an included module that is reopened" do
+        it "should have repoened methods" do
+          method(:module_that_is_reopened_method).should_not be_nil
+        end
+      end
+
+      describe "eval_block" do
+        before(:each) do
+          @example_group = ExampleGroup.dup
+        end
+    
+        describe "with a given description" do
+          it "should provide the given description" do
+            @example = @example_group.it("given description") { 2.should == 2 }
+            @example.eval_block
+            @example.description.should == "given description"
+          end
+        end
+
+        describe "with no given description" do
+          it "should provide the generated description" do
+            @example = @example_group.it { 2.should == 2 }
+            @example.eval_block
+            @example.description.should == "should == 2"
+          end
+        end
+    
+        describe "with no implementation" do
+          it "should raise an NotYetImplementedError" do
+            lambda {
+              @example = @example_group.it
+              @example.eval_block
+            }.should raise_error(Spec::Example::NotYetImplementedError, "Not Yet Implemented")
+          end
+      
+          def extract_error(&blk)
+            begin
+              blk.call
+            rescue Exception => e
+              return e
+            end
+        
+            nil
+          end
+      
+          it "should use the proper file and line number for the NotYetImplementedError" do
+            file = __FILE__
+            line_number = __LINE__ + 3
+        
+            error = extract_error do
+              @example = @example_group.example
+              @example.eval_block
+            end
+        
+            error.pending_caller.should =~ /#{file}:#{line_number}/
+          end
+        end
+      end
+
+      describe "#backtrace" do        
+        it "returns the backtrace from where the example was defined" do
+          example = ExampleGroup.dup.new "name"
+          example.backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-1}")
+        end
+      end
+      
+      describe "#implementation_backtrace (deprecated)" do
+        before(:each) do
+          Kernel.stub!(:warn)
+        end
+
+        it "sends a deprecation warning" do
+          Kernel.should_receive(:warn).with(/#implementation_backtrace.*deprecated.*#backtrace instead/m)
+          example = ExampleGroup.dup.new "name"
+          example.implementation_backtrace
+        end
+        
+        it "returns the backtrace from where the example was defined" do
+          example = ExampleGroup.dup.new "name"
+          example.implementation_backtrace.join("\n").should include("#{__FILE__}:#{__LINE__-1}")
+        end
+      end
+
+      describe "#full_description" do
+        it "should return the full description of the ExampleGroup and Example" do
+          example_group = Class.new(ExampleGroupDouble).describe("An ExampleGroup")
+          example = example_group.new "should do something"
+          example.full_description.should == "An ExampleGroup should do something"
+        end
+      end
+      
+      describe "#subject" do
+        before(:each) do
+          @example_group = ExampleGroupDouble
+        end
+
+        it "should return an instance of the described class" do
+          group = Class.new(ExampleGroupDouble).describe(Array)
+          example = group.new
+          example.subject.should == []
+        end
+    
+        it "should return nil for a module (as opposed to a class)" do
+          group = Class.new(ExampleGroupDouble).describe(Enumerable)
+          example = group.new
+          example.subject.should be_nil
+        end
+    
+        it "should return nil for a string" do
+          group = Class.new(ExampleGroupDouble).describe('foo')
+          example = group.new
+          example.subject.should be_nil
+        end
+      end
+
+      class Thing
+        attr_reader :arg
+        def initialize(arg=nil)
+          @arg = arg || :default
+        end
+        def ==(other)
+          @arg == other.arg
+        end
+        def eql?(other)
+          @arg == other.arg
+        end
+      end
+
+      describe "#should" do
+        before(:each) do
+          @example_group = Class.new(ExampleGroupDouble)
+          @options = ::Spec::Runner::Options.new(StringIO.new, StringIO.new)
+        end
+        
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(Thing)
+            @example_group.example { should == Thing.new(:default) }
+            @example_group.example { should eql(Thing.new(:default)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(Thing)
+            @example_group.subject { Thing.new(:other) }
+            @example_group.example { should == Thing.new(:other) }
+            @example_group.example { should eql(Thing.new(:other)) }
+            @example_group.run(@options).should be_true
+          end
+        end
+      end
+
+      describe "#should_not" do
+        before(:each) do
+          @example_group = ExampleGroup.dup
+        end
+
+        context "in an ExampleGroup with an implicit subject" do
+          it "delegates matcher to the implied subject" do
+            @example_group.describe(Thing)
+            @example_group.example { should_not == Thing.new(:other) }
+            @example_group.example { should_not eql(Thing.new(:other)) }
+            @example_group.run(::Spec::Runner::Options.new(StringIO.new, StringIO.new)).should be_true
+          end
+        end
+        
+        context "in an ExampleGroup using an explicit subject" do
+          it "delegates matcher to the declared subject" do
+            @example_group.describe(Thing)
+            @example_group.subject { Thing.new(:other) }
+            @example_group.example { should_not == Thing.new(:default) }
+            @example_group.example { should_not eql(Thing.new(:default)) }
+            @example_group.run(::Spec::Runner::Options.new(StringIO.new, StringIO.new)).should be_true
+          end
+        end
+      end
+    end
+
+    describe "#options" do
+      it "should expose the options hash" do
+        example = ExampleGroup.dup.new "name", :this => 'that' do; end
+        example.options[:this].should == 'that'
+      end
+    end
+
+  end
+end

data/spec/spec/example/helper_method_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+# This was added to prove that http://rspec.lighthouseapp.com/projects/5645/tickets/211
+# was fixed in ruby 1.9.1
+
+module HelperMethodExample
+  describe "a helper method" do
+    def helper_method
+      "received call"
+    end
+  
+    it "is available to examples in the same group" do
+      helper_method.should == "received call"
+    end
+    
+    describe "from a nested group" do
+      it "is available to examples in a nested group" do
+        helper_method.should == "received call"
+      end
+    end
+    
+  end
+end
+

data/spec/spec/example/nested_example_group_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    describe 'Nested Example Groups' do
+      parent = self
+      
+      def count
+        @count ||= 0
+        @count = @count + 1
+        @count
+      end
+
+      before(:all) do
+        count.should == 1
+      end
+
+      before(:all) do
+        count.should == 2
+      end
+
+      before(:each) do
+        count.should == 3
+      end
+
+      before(:each) do
+        count.should == 4
+      end
+
+      it "should run before(:all), before(:each), example, after(:each), after(:all) in order" do
+        count.should == 5
+      end
+
+      after(:each) do
+        count.should == 7
+      end
+
+      after(:each) do
+        count.should == 6
+      end
+
+      after(:all) do
+        count.should == 9
+      end
+
+      after(:all) do
+        count.should == 8
+      end
+
+      describe 'nested example group' do
+        self.superclass.should == parent
+        
+        it "should run all before and after callbacks" do
+          count.should == 5
+        end
+      end
+    end
+
+    describe "Nested Example Groups" do
+      describe "description options", :other_options => "other options" do
+        it "should have a spec_path" do
+          self.class.description_options[:spec_path].should match(/#{__FILE__}/)
+        end
+
+        it "should pass other options" do
+          self.class.description_options[:other_options].should == "other options"
+        end
+      end
+    end
+  end
+end

data/spec/spec/example/pending_module_spec.rb

@@ -0,0 +1,139 @@
+module Spec
+  module Example
+    describe Pending do
+      
+      it 'should raise an ExamplePendingError if no block is supplied' do
+        lambda {
+          pending "TODO"
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected' do
+        lambda {
+          pending "TODO" do
+            raise "oops"
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise an ExamplePendingError if a supplied block fails as expected with a mock' do
+        lambda {
+          pending "TODO" do
+            m = mock('thing')
+            m.should_receive(:foo)
+            m.rspec_verify
+          end
+        }.should raise_error(ExamplePendingError, /TODO/)
+      end
+      
+      it 'should raise a PendingExampleFixedError if a supplied block starts working' do
+        lambda {
+          pending "TODO" do
+            # success!
+          end
+        }.should raise_error(PendingExampleFixedError, /TODO/)
+      end
+      
+      it "should have the correct file and line number for pending given with a block which fails" do
+        file = __FILE__
+        line_number = __LINE__ + 2
+        begin
+          pending do
+            raise
+          end
+        rescue => error
+          error.pending_caller.should == "#{file}:#{line_number}"
+        end
+      end
+      
+      it "should have the correct file and line number for pending given with no block" do
+        file = __FILE__
+        line_number = __LINE__ + 2
+        begin
+          pending("TODO")
+        rescue => error
+          error.pending_caller.should == "#{file}:#{line_number}"
+        end
+      end
+    end
+    
+    describe ExamplePendingError do
+      it "should have the caller (from two calls from initialization)" do
+        two_calls_ago = caller[0]
+        ExamplePendingError.new("a message").pending_caller.should == two_calls_ago
+      end
+      
+      it "should keep the trace information from initialization" do
+        two_calls_ago = caller[0]
+        obj = ExamplePendingError.new("a message")
+        obj.pending_caller
+        def another_caller(obj)
+          obj.pending_caller
+        end
+        
+        another_caller(obj).should == two_calls_ago
+      end
+      
+      it "should have the message provided" do
+        ExamplePendingError.new("a message").message.should == "a message"
+      end
+
+      it "should use a 'ExamplePendingError' as it's default message" do
+        ExamplePendingError.new.message.should == "Spec::Example::ExamplePendingError"
+      end
+    end
+    
+    describe NotYetImplementedError do
+      def rspec_root
+        File.expand_path(__FILE__.gsub("/spec/spec/example/pending_module_spec.rb", "/lib"))
+      end
+      
+      it "should have the root rspec path" do
+        NotYetImplementedError::RSPEC_ROOT_LIB.should == rspec_root
+      end
+      
+      it "should always have the error 'Not Yet Implemented'" do
+        NotYetImplementedError.new([]).message.should == "Not Yet Implemented"
+      end
+      
+      describe "pending_caller" do
+        it "should select an element out of the backtrace" do
+          error = NotYetImplementedError.new(["foo/bar.rb:18"])
+          
+          error.pending_caller.should == "foo/bar.rb:18"
+        end
+        
+        it "should actually report the element from the backtrace" do
+          error = NotYetImplementedError.new(["bar.rb:18"])
+          
+          error.pending_caller.should == "bar.rb:18"
+        end
+        
+        it "should not use an element with the rspec root path" do
+          error = NotYetImplementedError.new(["#{rspec_root}:8"])
+          
+          error.pending_caller.should be_nil
+        end
+        
+        it "should select the first line in the backtrace which isn't in the rspec root" do
+          error = NotYetImplementedError.new([
+            "#{rspec_root}/foo.rb:2",
+            "#{rspec_root}/foo/bar.rb:18",
+            "path1.rb:22",
+            "path2.rb:33"
+          ])
+          
+          error.pending_caller.should == "path1.rb:22"
+        end
+        
+        it "should cache the caller" do
+          backtrace = mock('backtrace')
+          backtrace.should_receive(:detect).once
+          
+          error = NotYetImplementedError.new(backtrace)
+          error.pending_caller.should == error.pending_caller
+        end
+      end
+    end
+  end
+end

data/spec/spec/example/predicate_matcher_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+module Spec
+  module Example
+    class Fish
+      def can_swim?(distance_in_yards)
+        distance_in_yards < 1000
+      end
+    end
+    
+    describe "predicate_matcher[method_on_object] = matcher_method" do
+      predicate_matchers[:swim] = :can_swim?
+      it "should match matcher_method if method_on_object returns true" do
+        swim(100).matches?(Fish.new).should be_true
+      end
+      it "should not match matcher_method if method_on_object returns false" do
+        swim(10000).matches?(Fish.new).should be_false
+      end
+    end
+  end
+end