rspec-expectations 2.13.0 → 2.14.0

data/spec/rspec/matchers/configuration_spec.rb

@@ -22,7 +22,12 @@ module RSpec
         end
 
         before do
-          RSpec.configuration.stub(:backtrace_clean_patterns) { [/clean-me/] }
+          @old_patterns = RSpec.configuration.backtrace_exclusion_patterns
+          RSpec.configuration.backtrace_exclusion_patterns = [/clean-me/]
+        end
+
+        after do
+          RSpec.configuration.backtrace_exclusion_patterns = @old_patterns
         end
 
         it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
@@ -36,7 +41,7 @@ module RSpec
         end
 
         it "can be set to another backtrace formatter" do
-          config.backtrace_formatter = stub(:format_backtrace => ['a'])
+          config.backtrace_formatter = double(:format_backtrace => ['a'])
           expect(formatted_backtrace).to eq(['a'])
         end
       end
@@ -60,134 +65,97 @@ module RSpec
       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
-            orig_syntax = RSpec::Matchers.configuration.syntax
-            yield
-          ensure
-            configure_syntax(orig_syntax)
-          end
-        else
-          include InSubProcess
-          alias sandboxed in_sub_process
+        before do
+          @orig_syntax = RSpec::Matchers.configuration.syntax
+        end
+
+        after do
+          configure_syntax(@orig_syntax)
         end
 
         it 'can limit the syntax to :should' do
-          sandboxed do
-            configure_syntax :should
-            configured_syntax.should eq([:should])
+          configure_syntax :should
+          configured_syntax.should eq([:should])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            lambda { expect(6).to eq(6) }.should raise_error(NameError)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          lambda { expect(6).to eq(6) }.should raise_error(NameError)
         end
 
         it 'is a no-op when configured to :should twice' do
-          sandboxed do
-            configure_syntax :should
-
-            Expectations::Syntax.default_should_host.
-                                 stub(:method_added).
-                                 and_raise("no methods should be added here")
-
-            configure_syntax :should
-          end
+          configure_syntax :should
+          Expectations::Syntax.default_should_host.should_not_receive(:method_added)
+          configure_syntax :should
+          RSpec::Mocks.verify # because configure_syntax is called again in an after hook
         end
 
         it 'can limit the syntax to :expect' do
-          sandboxed do
-            configure_syntax :expect
-            expect(configured_syntax).to eq([:expect])
+          configure_syntax :expect
+          expect(configured_syntax).to eq([: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
+          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
 
         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")
+          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
 
-            configure_syntax :expect
-            configure_syntax :expect
-          end
+          configure_syntax :expect
+          configure_syntax :expect
         end
 
         it 'can re-enable the :should syntax' do
-          sandboxed do
-            configure_syntax :expect
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          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)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         end
 
         it 'can re-enable the :expect syntax' do
-          sandboxed do
-            configure_syntax :should
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          configure_syntax :should
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            expect(3).to eq(3)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         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
+          configure_syntax :should
+          et.new(Proc.new {}).should be_an(et)
+          et.new(Proc.new {}).should_not be_a(Proc)
         end
 
         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)
-          end
+          configure_syntax :expect
+          expect(expect(3)).not_to respond_to(:should)
+          expect(expect(3)).not_to respond_to(:should_not)
         end
 
         context 'when both :expect and :should are enabled' do
-          before { RSpec.stub(:warn) }
+          before { allow(RSpec).to receive(:deprecate) }
 
           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
+            configure_syntax [:should, :expect]
+            expect { raise "boom" }.should raise_error("boom")
+            expect { }.should_not raise_error
           end
 
           it 'prints a deprecation notice when `expect {}.should` is used' do
-            sandboxed do
-              configure_syntax [:should, :expect]
+            configure_syntax [:should, :expect]
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
-              expect { raise "boom" }.should raise_error("boom")
+            expect(RSpec).to receive(:deprecate)
+            expect { raise "boom" }.should raise_error("boom")
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
-              expect { }.should_not raise_error
-            end
+            expect(RSpec).to receive(:deprecate)
+            expect { }.should_not raise_error
           end
         end
       end

data/spec/rspec/matchers/description_generation_spec.rb

@@ -107,11 +107,25 @@ describe "Matchers should be able to generate their own descriptions" do
     expect(RSpec::Matchers.generated_description).to eq "should have at most 4 players"
   end
 
-  it "expect(...).to include" do
+  it "expect(...).to include(x)" do
     expect([1,2,3]).to include(3)
     expect(RSpec::Matchers.generated_description).to eq "should include 3"
   end
 
+  it "expect(...).to include(x) when x responds to description but is not a matcher" do
+    obj = double(:description => "description", :inspect => "inspect")
+    expect([obj]).to include(obj)
+    expect(RSpec::Matchers.generated_description).to eq "should include inspect"
+  end
+
+  it "expect(...).to include(x) when x responds to description and is a matcher" do
+    matcher = double(:description                => "description",
+                     :matches?                   => true,
+                     :failure_message_for_should => "")
+    expect([matcher]).to include(matcher)
+    expect(RSpec::Matchers.generated_description).to eq "should include description"
+  end
+
   it "expect(array).not_to match_array [1,2,3]" do
     expect([1,2,3]).to match_array [1,2,3]
     expect(RSpec::Matchers.generated_description).to eq "should contain exactly 1, 2 and 3"
@@ -171,6 +185,6 @@ describe "a Matcher with no description" do
 
   it "provides a helpful message when used in a string-less example block" do
     expect(5).to matcher
-    expect(RSpec::Matchers.generated_description).to match /When you call.*description method/m
+    expect(RSpec::Matchers.generated_description).to match(/When you call.*description method/m)
   end
 end

data/spec/rspec/matchers/exist_spec.rb

@@ -8,7 +8,7 @@ describe "exist matcher" do
   end
 
   context "when the object does not respond to #exist? or #exists?" do
-    subject { mock }
+    subject { double }
 
     [:to, :not_to].each do |expect_method|
       describe "expect(...).#{expect_method} exist" do
@@ -25,12 +25,12 @@ describe "exist matcher" do
     context "when the object responds to ##{predicate}" do
       describe "expect(...).to exist" do
         it "passes if #{predicate}" do
-          expect(mock(predicate => true)).to exist
+          expect(double(predicate => true)).to exist
         end
 
         it "fails if not #{predicate}" do
           expect {
-            expect(mock(predicate => false)).to exist
+            expect(double(predicate => false)).to exist
           }.to fail_with(/expected .* to exist/)
         end
 
@@ -51,12 +51,12 @@ describe "exist matcher" do
 
       describe "expect(...).not_to exist" do
         it "passes if not #{predicate}" do
-          expect(mock(predicate => false)).not_to exist
+          expect(double(predicate => false)).not_to exist
         end
 
         it "fails if #{predicate}" do
           expect {
-            expect(mock(predicate => true)).not_to exist
+            expect(double(predicate => true)).not_to exist
           }.to fail_with(/expected .* not to exist/)
         end
       end
@@ -65,7 +65,7 @@ describe "exist matcher" do
 
   context "when the object responds to #exist? and #exists?" do
     context "when they both return falsey values" do
-      subject { mock(:exist? => false, :exists? => nil) }
+      subject { double(:exist? => false, :exists? => nil) }
 
       describe "expect(...).not_to exist" do
         it "passes" do
@@ -83,7 +83,7 @@ describe "exist matcher" do
     end
 
     context "when they both return truthy values" do
-      subject { mock(:exist? => true, :exists? => "something true") }
+      subject { double(:exist? => true, :exists? => "something true") }
 
       describe "expect(...).not_to exist" do
         it "fails" do
@@ -101,7 +101,7 @@ describe "exist matcher" do
     end
 
     context "when they return values with different truthiness" do
-      subject { mock(:exist? => true, :exists? => false) }
+      subject { double(:exist? => true, :exists? => false) }
 
       [:to, :not_to].each do |expect_method|
         describe "expect(...).#{expect_method} exist" do
@@ -116,7 +116,7 @@ describe "exist matcher" do
   end
 
   it 'passes any provided arguments to the call to #exist?' do
-    object = mock
+    object = double
     object.should_receive(:exist?).with(:foo, :bar) { true }
 
     expect(object).to exist(:foo, :bar)

data/spec/rspec/matchers/has_spec.rb

@@ -117,6 +117,6 @@ describe "has" do
     def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
     expect {
       expect(o).to have_key(:a)
-    }.to_not raise_error
+    }.not_to raise_error
   end
 end

data/spec/rspec/matchers/have_spec.rb

@@ -326,13 +326,13 @@ EOF
 
   describe "have(n).items(args, block)" do
     it "passes args to target" do
-      target = mock("target")
+      target = double("target")
       target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
       expect(target).to have(3).items("arg1","arg2")
     end
 
     it "passes block to target" do
-      target = mock("target")
+      target = double("target")
       block = lambda { 5 }
       target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
       expect(target).to have(3).items("arg1","arg2", block)
@@ -402,6 +402,16 @@ EOF
     end
   end
 
+  if RUBY_VERSION >= '2.0'
+    describe RSpec::Matchers::BuiltIn::Have, "for an Enumerator whose size is nil but count is supplied" do
+      let(:enumerator) { %w[a b c d].to_enum(:each) }
+
+      it 'works fine' do
+        expect(enumerator).to have(4).items
+      end
+    end
+  end
+
   describe RSpec::Matchers::BuiltIn::Have do
     it "has method_missing as private" do
       expect(described_class.private_instance_methods).to include_method(:method_missing)

data/spec/rspec/matchers/include_matcher_integration_spec.rb

@@ -22,8 +22,8 @@ module RSpec
       end
 
       it "works with be_[some predicate]" do
-        expect([stub("actual", :happy? => true)]).to include( be_happy )
-        expect([stub("actual", :happy? => false)]).not_to include( be_happy )
+        expect([double("actual", :happy? => true)]).to include( be_happy )
+        expect([double("actual", :happy? => false)]).not_to include( be_happy )
       end
     end
   end

data/spec/rspec/matchers/include_spec.rb

@@ -137,7 +137,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(expected)" do
+  describe "expect(...).not_to include(expected)" do
     context "for a string target" do
       it "passes if target does not include expected" do
         expect("abc").not_to include("d")
@@ -188,7 +188,7 @@ describe "#include matcher" do
 
   end
 
-  describe "expect(...).to_not include(with, multiple, args)" do
+  describe "expect(...).not_to include(with, multiple, args)" do
     context "for a string target" do
       it "passes if the target does not include any of the expected" do
         expect("abc").not_to include("d", "e", "f")
@@ -280,7 +280,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(:key => value)" do
+  describe "expect(...).not_to include(:key => value)" do
     context 'for a hash target' do
       it "fails if target includes the key/value pair" do
         expect {
@@ -364,7 +364,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(:key1 => value1, :key2 => value2)" do
+  describe "expect(...).not_to include(:key1 => value1, :key2 => value2)" do
     context 'for a hash target' do
       it "fails if target includes the key/value pairs" do
         expect {

data/spec/rspec/matchers/match_array_spec.rb

@@ -156,7 +156,7 @@ MESSAGE
   end
 end
 
-describe "expect(...).to_not match_array [:with, :multiple, :args]" do
+describe "expect(...).not_to match_array [:with, :multiple, :args]" do
   it "is not supported" do
     expect {
       expect([1,2,3]).not_to match_array [1,2,3]

data/spec/rspec/matchers/match_spec.rb

@@ -32,7 +32,7 @@ describe "expect(...).to match(expected)" do
   end
 end
 
-describe "expect(...).to_not match(expected)" do
+describe "expect(...).not_to match(expected)" do
   it "passes when target (String) matches does not match (Regexp)" do
     expect("string").not_to match(/rings/)
   end