rspec-expectations 2.11.3 → 2.12.0

data/spec/rspec/expectations/syntax_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    module Syntax
+      describe "the should and should_not expectations" do
+        let(:warner) { ::Kernel }
+
+        describe "#should" do
+          it "prints a warning when the message object isn't a String" do
+            warner.should_receive(:warn).with /ignoring.*message/
+            3.should eq(3), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            warner.should_not_receive(:warn)
+            3.should eq(3), "a string"
+          end
+        end
+
+        describe "#should_not" do
+          it "prints a warning when the message object isn't a String" do
+            warner.should_receive(:warn).with /ignoring.*message/
+            3.should_not eq(4), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            warner.should_not_receive(:warn)
+            3.should_not eq(4), "a string"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rspec/matchers/be_instance_of_spec.rb

@@ -25,10 +25,27 @@ module RSpec
           matcher.matches?(Numeric)
           matcher.description.should == "be an instance of Fixnum"
         end
+
+        context "when expected provides an expanded inspect, e.g. AR::Base" do
+          let(:user_klass) do
+            Class.new do
+              def self.inspect
+                "User(id: integer, name: string)"
+              end
+            end
+          end
+
+          before { stub_const("User", user_klass) }
+
+          it "provides a description including only the class name" do
+            matcher = be_an_instance_of(User)
+            matcher.description.should == "be an instance of User"
+          end
+        end
       end
-      
+
       describe "actual.should_not #{method}(expected)" do
-        
+
         it "fails with failure message for should_not if actual is instance of expected class" do
           lambda { "foo".should_not send(method, String) }.should fail_with(%Q{expected "foo" not to be an instance of String})
         end

data/spec/rspec/matchers/be_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe "should be_predicate" do  
+describe "should be_predicate" do
   it "passes when actual returns true for :predicate?" do
     actual = stub("actual", :happy? => true)
     actual.should be_happy
@@ -17,20 +17,20 @@ describe "should be_predicate" do
       actual.should be_happy
     }.should fail_with("expected happy? to return true, got false")
   end
-  
+
   it "fails when actual returns false for :predicate?" do
     actual = stub("actual", :happy? => nil)
     lambda {
       actual.should be_happy
     }.should fail_with("expected happy? to return true, got nil")
   end
-  
+
   it "fails when actual does not respond to :predicate?" do
     lambda {
       Object.new.should be_happy
     }.should raise_error(NameError, /happy\?/)
   end
-  
+
   it "fails on error other than NameError" do
     actual = stub("actual")
     actual.should_receive(:foo?).and_raise("aaaah")
@@ -38,7 +38,7 @@ describe "should be_predicate" do
       actual.should be_foo
     }.should raise_error(/aaaah/)
   end
-  
+
   it "fails on error other than NameError (with the present tense predicate)" do
     actual = Object.new
     actual.should_receive(:foos?).and_raise("aaaah")
@@ -53,12 +53,12 @@ describe "should_not be_predicate" do
     actual = stub("actual", :happy? => false)
     actual.should_not be_happy
   end
-  
+
   it "passes when actual returns nil for :sym?" do
     actual = stub("actual", :happy? => nil)
     actual.should_not be_happy
   end
-  
+
   it "fails when actual returns true for :sym?" do
     actual = stub("actual", :happy? => true)
     lambda {
@@ -87,7 +87,7 @@ describe "should be_predicate(*args)" do
       actual.should be_older_than(3)
     }.should fail_with("expected older_than?(3) to return true, got false")
   end
-  
+
   it "fails when actual does not respond to :predicate?" do
     lambda {
       Object.new.should be_older_than(3)
@@ -101,7 +101,7 @@ describe "should_not be_predicate(*args)" do
     actual.should_receive(:older_than?).with(3).and_return(false)
     actual.should_not be_older_than(3)
   end
-  
+
   it "fails when actual returns true for :predicate?(*args)" do
     actual = mock("actual")
     actual.should_receive(:older_than?).with(3).and_return(true)
@@ -444,7 +444,7 @@ describe "be_an_instance_of" do
   it "passes when direct class matches" do
     5.should be_an_instance_of(Fixnum)
   end
-  
+
   it "fails when class is higher up hierarchy" do
     5.should_not be_an_instance_of(Numeric)
   end

data/spec/rspec/matchers/configuration_spec.rb

@@ -3,11 +3,43 @@ require 'delegate'
 
 module RSpec
   module Matchers
-    describe ".configuration" do
+    describe "RSpec::Matchers.configuration" do
       it 'returns a memoized configuration instance' do
         RSpec::Matchers.configuration.should be_a(RSpec::Matchers::Configuration)
         RSpec::Matchers.configuration.should be(RSpec::Matchers.configuration)
       end
+    end
+
+    describe Configuration do
+      let(:config) { Configuration.new }
+
+      describe "#backtrace_formatter" do
+        let(:original_backtrace) { %w[ clean-me/a.rb other/file.rb clean-me/b.rb ] }
+        let(:cleaned_backtrace)  { %w[ other/file.rb ] }
+
+        let(:formatted_backtrace) do
+          config.backtrace_formatter.format_backtrace(original_backtrace)
+        end
+
+        before do
+          RSpec.configuration.stub(:backtrace_clean_patterns) { [/clean-me/] }
+        end
+
+        it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
+          expect(config.backtrace_formatter).to be(RSpec::Core::BacktraceFormatter)
+          expect(formatted_backtrace).to eq(cleaned_backtrace)
+        end
+
+        it "defaults to a null formatter when rspec-core is not loaded" do
+          hide_const("RSpec::Core::BacktraceFormatter")
+          expect(formatted_backtrace).to eq(original_backtrace)
+        end
+
+        it "can be set to another backtrace formatter" do
+          config.backtrace_formatter = stub(:format_backtrace => ['a'])
+          expect(formatted_backtrace).to eq(['a'])
+        end
+      end
 
       context 'on an interpreter that does not provide BasicObject', :unless => defined?(::BasicObject) do
         before { RSpec::Expectations::Syntax.disable_should(Delegator) }
@@ -22,175 +54,175 @@ module RSpec
 
         it 'provides a means to manually add it Delegator' do
           instance.should_not respond_to(:delegated?) # because #should is being delegated...
-          RSpec::Matchers.configuration.add_should_and_should_not_to Delegator
+          config.add_should_and_should_not_to Delegator
           instance.should respond_to(:delegated?) # now it should work!
         end
       end
-    end
-
-    shared_examples_for "configuring the expectation syntax" do
-      # We want a sandboxed method that ensures that we wind up with
-      # both syntaxes properly enabled when the example ends.
-      #
-      # On platforms that fork, using a sub process is the easiest,
-      # most robust way to achieve that.
-      #
-      # On jRuby we just re-enable both syntaxes at the end of the example;
-      # however, this is a generally inferior approach because it depends on
-      # the code-under-test working properly; if it doesn't work properly,
-      # it could leave things in a "broken" state where tons of other examples fail.
-      if RUBY_PLATFORM == "java"
-        def sandboxed
-          yield
-        ensure
-          configure_syntax([:should, :expect])
-        end
-      else
-        include InSubProcess
-        alias sandboxed in_sub_process
-      end
-
-      it 'is configured to :should and :expect by default' do
-        configured_syntax.should eq([:should, :expect])
 
-        3.should eq(3)
-        3.should_not eq(4)
-        expect(3).to eq(3)
-      end
+      shared_examples_for "configuring the expectation syntax" do
+        # We want a sandboxed method that ensures that we wind up with
+        # both syntaxes properly enabled when the example ends.
+        #
+        # On platforms that fork, using a sub process is the easiest,
+        # most robust way to achieve that.
+        #
+        # On jRuby we just re-enable both syntaxes at the end of the example;
+        # however, this is a generally inferior approach because it depends on
+        # the code-under-test working properly; if it doesn't work properly,
+        # it could leave things in a "broken" state where tons of other examples fail.
+        if RUBY_PLATFORM == "java"
+          def sandboxed
+            yield
+          ensure
+            configure_syntax([:should, :expect])
+          end
+        else
+          include InSubProcess
+          alias sandboxed in_sub_process
+        end
 
-      it 'can limit the syntax to :should' do
-        sandboxed do
-          configure_syntax :should
-          configured_syntax.should eq([:should])
+        it 'is configured to :should and :expect by default' do
+          configured_syntax.should eq([:should, :expect])
 
           3.should eq(3)
           3.should_not eq(4)
-          lambda { expect(6).to eq(6) }.should raise_error(NameError)
+          expect(3).to eq(3)
         end
-      end
 
-      it 'is a no-op when configured to :should twice' do
-        sandboxed do
-          ::Kernel.stub(:method_added).and_raise("no methods should be added here")
+        it 'can limit the syntax to :should' do
+          sandboxed do
+            configure_syntax :should
+            configured_syntax.should eq([:should])
 
-          configure_syntax :should
-          configure_syntax :should
+            3.should eq(3)
+            3.should_not eq(4)
+            lambda { expect(6).to eq(6) }.should raise_error(NameError)
+          end
         end
-      end
 
-      it 'can limit the syntax to :expect' do
-        sandboxed do
-          configure_syntax :expect
-          expect(configured_syntax).to eq([:expect])
+        it 'is a no-op when configured to :should twice' do
+          sandboxed do
+            ::Kernel.stub(:method_added).and_raise("no methods should be added here")
 
-          expect(3).to eq(3)
-          expect { 3.should eq(3) }.to raise_error(NameError)
-          expect { 3.should_not eq(3) }.to raise_error(NameError)
+            configure_syntax :should
+            configure_syntax :should
+          end
         end
-      end
 
-      it 'is a no-op when configured to :expect twice' do
-        sandboxed do
-          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
+        it 'can limit the syntax to :expect' do
+          sandboxed do
+            configure_syntax :expect
+            expect(configured_syntax).to eq([:expect])
 
-          configure_syntax :expect
-          configure_syntax :expect
+            expect(3).to eq(3)
+            expect { 3.should eq(3) }.to raise_error(NameError)
+            expect { 3.should_not eq(3) }.to raise_error(NameError)
+          end
         end
-      end
 
-      it 'can re-enable the :should syntax' do
-        sandboxed do
-          configure_syntax :expect
-          configure_syntax [:should, :expect]
-          configured_syntax.should eq([:should, :expect])
+        it 'is a no-op when configured to :expect twice' do
+          sandboxed do
+            RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
 
-          3.should eq(3)
-          3.should_not eq(4)
-          expect(3).to eq(3)
+            configure_syntax :expect
+            configure_syntax :expect
+          end
         end
-      end
 
-      it 'can re-enable the :expect syntax' do
-        sandboxed do
-          configure_syntax :should
-          configure_syntax [:should, :expect]
-          configured_syntax.should eq([:should, :expect])
+        it 'can re-enable the :should syntax' do
+          sandboxed do
+            configure_syntax :expect
+            configure_syntax [:should, :expect]
+            configured_syntax.should eq([:should, :expect])
 
-          3.should eq(3)
-          3.should_not eq(4)
-          expect(3).to eq(3)
+            3.should eq(3)
+            3.should_not eq(4)
+            expect(3).to eq(3)
+          end
         end
-      end
-
-      it 'does not add the deprecated #should to ExpectationTarget when only :should is enabled' do
-        et = Expectations::ExpectationTarget
 
-        sandboxed do
-          configure_syntax :should
-          et.new(Proc.new {}).should be_an(et)
-          et.new(Proc.new {}).should_not be_a(Proc)
-        end
-      end
+        it 'can re-enable the :expect syntax' do
+          sandboxed do
+            configure_syntax :should
+            configure_syntax [:should, :expect]
+            configured_syntax.should eq([:should, :expect])
 
-      it 'does not add the deprecated #should to ExpectationTarget when only :expect is enabled' do
-        sandboxed do
-          configure_syntax :expect
-          expect(expect(3)).not_to respond_to(:should)
-          expect(expect(3)).not_to respond_to(:should_not)
+            3.should eq(3)
+            3.should_not eq(4)
+            expect(3).to eq(3)
+          end
         end
-      end
 
-      context 'when both :expect and :should are enabled' do
-        before { RSpec.stub(:warn) }
+        it 'does not add the deprecated #should to ExpectationTarget when only :should is enabled' do
+          et = Expectations::ExpectationTarget
 
-        it 'allows `expect {}.should` to be used' do
           sandboxed do
-            configure_syntax [:should, :expect]
-            expect { raise "boom" }.should raise_error("boom")
-            expect { }.should_not raise_error
+            configure_syntax :should
+            et.new(Proc.new {}).should be_an(et)
+            et.new(Proc.new {}).should_not be_a(Proc)
           end
         end
 
-        it 'prints a deprecation notice when `expect {}.should` is used' do
+        it 'does not add the deprecated #should to ExpectationTarget when only :expect is enabled' do
           sandboxed do
-            configure_syntax [:should, :expect]
+            configure_syntax :expect
+            expect(expect(3)).not_to respond_to(:should)
+            expect(expect(3)).not_to respond_to(:should_not)
+          end
+        end
+
+        context 'when both :expect and :should are enabled' do
+          before { RSpec.stub(:warn) }
+
+          it 'allows `expect {}.should` to be used' do
+            sandboxed do
+              configure_syntax [:should, :expect]
+              expect { raise "boom" }.should raise_error("boom")
+              expect { }.should_not raise_error
+            end
+          end
+
+          it 'prints a deprecation notice when `expect {}.should` is used' do
+            sandboxed do
+              configure_syntax [:should, :expect]
 
-            RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
-            expect { raise "boom" }.should raise_error("boom")
+              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
+              expect { raise "boom" }.should raise_error("boom")
 
-            RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
-            expect { }.should_not raise_error
+              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
+              expect { }.should_not raise_error
+            end
           end
         end
       end
-    end
 
-    describe "configuring rspec-expectations directly" do
-      it_behaves_like "configuring the expectation syntax" do
-        def configure_syntax(syntax)
-          RSpec::Matchers.configuration.syntax = syntax
-        end
+      describe "configuring rspec-expectations directly" do
+        it_behaves_like "configuring the expectation syntax" do
+          def configure_syntax(syntax)
+            RSpec::Matchers.configuration.syntax = syntax
+          end
 
-        def configured_syntax
-          RSpec::Matchers.configuration.syntax
+          def configured_syntax
+            RSpec::Matchers.configuration.syntax
+          end
         end
       end
-    end
 
-    describe "configuring using the rspec-core config API" do
-      it_behaves_like "configuring the expectation syntax" do
-        def configure_syntax(syntax)
-          RSpec.configure do |rspec|
-            rspec.expect_with :rspec do |c|
-              c.syntax = syntax
+      describe "configuring using the rspec-core config API" do
+        it_behaves_like "configuring the expectation syntax" do
+          def configure_syntax(syntax)
+            RSpec.configure do |rspec|
+              rspec.expect_with :rspec do |c|
+                c.syntax = syntax
+              end
             end
           end
-        end
 
-        def configured_syntax
-          RSpec.configure do |rspec|
-            rspec.expect_with :rspec do |c|
-              return c.syntax
+          def configured_syntax
+            RSpec.configure do |rspec|
+              rspec.expect_with :rspec do |c|
+                return c.syntax
+              end
             end
           end
         end