rspec-expectations 2.13.0 → 2.14.0.rc1

data/spec/rspec/matchers/description_generation_spec.rb

@@ -171,6 +171,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

data/spec/rspec/matchers/raise_error_spec.rb

@@ -10,6 +10,25 @@ describe "expect { ... }.to raise_error" do
     expect {raise}.to raise_error
   end
 
+  it "passes if an error instance is expected" do
+    s = StandardError.new
+    expect {raise s}.to raise_error(s)
+  end
+
+  it "fails if a different error instance is thrown from the one that is expected" do
+    s = StandardError.new :bees
+    to_raise = StandardError.new(:faces)
+    expect do
+      expect {raise to_raise}.to raise_error(s)
+    end.to fail_with(Regexp.new("expected #{s.inspect}, got #{to_raise.inspect} with backtrace"))
+  end
+
+  it "passes if an error class is expected and an instance of that class is thrown" do
+    s = StandardError.new :bees
+
+    expect { raise s }.to raise_error(StandardError)
+  end
+
   it "fails if nothing is raised" do
     expect {
       expect {}.to raise_error
@@ -41,36 +60,53 @@ describe "expect { ... }.to raise_error {|err| ... }" do
   end
 end
 
-describe "expect { ... }.to_not raise_error" do
-  it "passes if nothing is raised" do
-    expect {}.to_not raise_error
-  end
+describe "expect { ... }.not_to raise_error" do
 
-  it "fails if anything is raised" do
-    expect {
-      expect { raise RuntimeError, "example message" }.to_not raise_error
-    }.to fail_with(/expected no Exception, got #<RuntimeError: example message>/)
+  context "with a specific error class" do
+    it "is deprecated" do
+      RSpec.should_receive :deprecate
+      expect {"bees"}.not_to raise_error(RuntimeError)
+    end
   end
 
-  it 'includes the backtrace of the error that was raised in the error message' do
-    expect {
-      expect { raise "boom" }.not_to raise_error
-    }.to raise_error { |e|
-      backtrace_line = "#{File.basename(__FILE__)}:#{__LINE__ - 2}"
-      expect(e.message).to include("with backtrace", backtrace_line)
-    }
-  end
+  context "with no specific error class" do
+    it "is not deprecated" do
+      run = nil
+      allow(RSpec).to receive(:deprecate) { run = true }
+      expect {"bees"}.not_to raise_error
+      expect(run).to be_nil
+    end
 
-  it 'formats the backtrace using the configured backtrace formatter' do
-    RSpec::Matchers.configuration.backtrace_formatter.
-                    stub(:format_backtrace).
-                    and_return("formatted-backtrace")
+    it "passes if nothing is raised" do
+      expect {}.not_to raise_error
+    end
 
-    expect {
-      expect { raise "boom" }.not_to raise_error
-    }.to raise_error { |e|
-      expect(e.message).to include("with backtrace", "formatted-backtrace")
-    }
+    it "fails if anything is raised" do
+      expect {
+        expect { raise RuntimeError, "example message" }.not_to raise_error
+      }.to fail_with(/expected no Exception, got #<RuntimeError: example message>/)
+    end
+
+    it 'includes the backtrace of the error that was raised in the error message' do
+      expect {
+        expect { raise "boom" }.not_to raise_error
+      }.to raise_error { |e|
+        backtrace_line = "#{File.basename(__FILE__)}:#{__LINE__ - 2}"
+        expect(e.message).to include("with backtrace", backtrace_line)
+      }
+    end
+
+    it 'formats the backtrace using the configured backtrace formatter' do
+      RSpec::Matchers.configuration.backtrace_formatter.
+        stub(:format_backtrace).
+        and_return("formatted-backtrace")
+
+      expect {
+        expect { raise "boom" }.not_to raise_error
+      }.to raise_error { |e|
+        expect(e.message).to include("with backtrace", "formatted-backtrace")
+      }
+    end
   end
 end
 
@@ -109,24 +145,33 @@ describe "expect { ... }.to raise_error(message)" do
   end
 end
 
-describe "expect { ... }.to_not raise_error(message)" do
+describe "expect { ... }.not_to raise_error(message)" do
+  before do
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate).with(/not_to raise_error\(message\)/, :replacement =>"`expect { }.not_to raise_error()`")
+    expect {raise 'blarg'}.not_to raise_error('blah')
+  end
+
   it "passes if RuntimeError error is raised with the different message" do
-    expect {raise 'blarg'}.to_not raise_error('blah')
+    expect {raise 'blarg'}.not_to raise_error('blah')
   end
 
   it "passes if any other error is raised with the wrong message" do
-    expect {raise NameError.new('blarg')}.to_not raise_error('blah')
+    expect {raise NameError.new('blarg')}.not_to raise_error('blah')
   end
 
   it "fails if RuntimeError is raised with message" do
     expect do
-      expect {raise 'blah'}.to_not raise_error('blah')
+      expect {raise 'blah'}.not_to raise_error('blah')
     end.to fail_with(/expected no Exception with "blah", got #<RuntimeError: blah>/)
   end
 
   it "fails if any other error is raised with message" do
     expect do
-      expect {raise NameError.new('blah')}.to_not raise_error('blah')
+      expect {raise NameError.new('blah')}.not_to raise_error('blah')
     end.to fail_with(/expected no Exception with "blah", got #<NameError: blah>/)
   end
 end
@@ -155,18 +200,27 @@ describe "expect { ... }.to raise_error(NamedError)" do
   end
 end
 
-describe "expect { ... }.to_not raise_error(NamedError)" do
+describe "expect { ... }.not_to raise_error(NamedError)" do
+  before do
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate).with(/not_to raise_error\(SpecificErrorClass\)/, :replacement => "`expect { }.not_to raise_error()`")
+    expect { }.not_to raise_error(NameError)
+  end
+
   it "passes if nothing is raised" do
-    expect { }.to_not raise_error(NameError)
+    expect { }.not_to raise_error(NameError)
   end
 
   it "passes if another error is raised" do
-    expect { raise }.to_not raise_error(NameError)
+    expect { raise }.not_to raise_error(NameError)
   end
 
   it "fails if named error is raised" do
     expect {
-      expect { 1 + 'b' }.to_not raise_error(TypeError)
+      expect { 1 + 'b' }.not_to raise_error(TypeError)
     }.to fail_with(/expected no TypeError, got #<TypeError: String can't be/)
   end
 end
@@ -195,6 +249,88 @@ describe "expect { ... }.to raise_error(NamedError, error_message) with String"
   end
 end
 
+describe "expect { ... }.not_to raise_error(NamedError, error_message) with String" do
+  before do
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate).with(/not_to raise_error\(SpecificErrorClass, message\)/, :replacement =>"`expect { }.not_to raise_error()`")
+    expect {}.not_to raise_error(RuntimeError, "example message")
+  end
+
+  it "passes if nothing is raised" do
+    expect {}.not_to raise_error(RuntimeError, "example message")
+  end
+
+  it "passes if a different error is raised" do
+    expect { raise }.not_to raise_error(NameError, "example message")
+  end
+
+  it "passes if same error is raised with different message" do
+    expect { raise RuntimeError.new("not the example message") }.not_to raise_error(RuntimeError, "example message")
+  end
+
+  it "fails if named error is raised with same message" do
+    expect {
+      expect { raise "example message" }.not_to raise_error(RuntimeError, "example message")
+    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
+  end
+end
+
+describe "expect { ... }.to raise_error(NamedError, error_message) with Regexp" do
+  it "passes if named error is raised with matching message" do
+    expect { raise "example message" }.to raise_error(RuntimeError, /ample mess/)
+  end
+
+  it "fails if nothing is raised" do
+    expect {
+      expect {}.to raise_error(RuntimeError, /ample mess/)
+    }.to fail_with(/expected RuntimeError with message matching \/ample mess\/ but nothing was raised/)
+  end
+
+  it "fails if incorrect error is raised" do
+    expect {
+      expect { raise RuntimeError, "example message" }.to raise_error(NameError, /ample mess/)
+    }.to fail_with(/expected NameError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
+  end
+
+  it "fails if correct error is raised with incorrect message" do
+    expect {
+      expect { raise RuntimeError.new("not the example message") }.to raise_error(RuntimeError, /less than ample mess/)
+    }.to fail_with(/expected RuntimeError with message matching \/less than ample mess\/, got #<RuntimeError: not the example message>/)
+  end
+end
+
+describe "expect { ... }.not_to raise_error(NamedError, error_message) with Regexp" do
+  before do
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate)
+    expect {}.not_to raise_error(RuntimeError, /ample mess/)
+  end
+
+  it "passes if nothing is raised" do
+    expect {}.not_to raise_error(RuntimeError, /ample mess/)
+  end
+
+  it "passes if a different error is raised" do
+    expect { raise }.not_to raise_error(NameError, /ample mess/)
+  end
+
+  it "passes if same error is raised with non-matching message" do
+    expect { raise RuntimeError.new("non matching message") }.not_to raise_error(RuntimeError, /ample mess/)
+  end
+
+  it "fails if named error is raised with matching message" do
+    expect {
+      expect { raise "example message" }.not_to raise_error(RuntimeError, /ample mess/)
+    }.to fail_with(/expected no RuntimeError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
+  end
+end
+
 describe "expect { ... }.to raise_error(NamedError, error_message) { |err| ... }" do
   it "yields exception if named error is raised with same message" do
     ran = false
@@ -268,11 +404,20 @@ describe "expect { ... }.to raise_error(NamedError, error_message) { |err| ... }
   end
 end
 
-describe "expect { ... }.to_not raise_error(NamedError, error_message) { |err| ... }" do
+describe "expect { ... }.not_to raise_error(NamedError, error_message) { |err| ... }" do
+  before do
+    allow(RSpec).to receive(:deprecate)
+  end
+
+  it "is deprecated" do
+    expect(RSpec).to receive(:deprecate)
+    expect {}.not_to raise_error(RuntimeError, "example message") { |err| }
+  end
+
   it "passes if nothing is raised" do
     ran = false
 
-    expect {}.to_not raise_error(RuntimeError, "example message") { |err|
+    expect {}.not_to raise_error(RuntimeError, "example message") { |err|
       ran = true
     }
 
@@ -282,7 +427,7 @@ describe "expect { ... }.to_not raise_error(NamedError, error_message) { |err| .
   it "passes if a different error is raised" do
     ran = false
 
-    expect { raise }.to_not raise_error(NameError, "example message") { |err|
+    expect { raise }.not_to raise_error(NameError, "example message") { |err|
       ran = true
     }
 
@@ -294,7 +439,7 @@ describe "expect { ... }.to_not raise_error(NamedError, error_message) { |err| .
 
     expect {
       raise RuntimeError.new("not the example message")
-    }.to_not raise_error(RuntimeError, "example message") { |err|
+    }.not_to raise_error(RuntimeError, "example message") { |err|
       ran = true
     }
 
@@ -307,7 +452,7 @@ describe "expect { ... }.to_not raise_error(NamedError, error_message) { |err| .
     expect {
       expect {
         raise "example message"
-      }.to_not raise_error(RuntimeError, "example message") { |err|
+      }.not_to raise_error(RuntimeError, "example message") { |err|
         ran = true
       }
     }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
@@ -330,66 +475,11 @@ describe "expect { ... }.to_not raise_error(NamedError, error_message) { |err| .
   end
 end
 
-describe "expect { ... }.to_not raise_error(NamedError, error_message) with String" do
-  it "passes if nothing is raised" do
-    expect {}.to_not raise_error(RuntimeError, "example message")
-  end
-
-  it "passes if a different error is raised" do
-    expect { raise }.to_not raise_error(NameError, "example message")
-  end
-
-  it "passes if same error is raised with different message" do
-    expect { raise RuntimeError.new("not the example message") }.to_not raise_error(RuntimeError, "example message")
-  end
-
-  it "fails if named error is raised with same message" do
-    expect {
-      expect { raise "example message" }.to_not raise_error(RuntimeError, "example message")
-    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
-  end
-end
-
-describe "expect { ... }.to raise_error(NamedError, error_message) with Regexp" do
-  it "passes if named error is raised with matching message" do
-    expect { raise "example message" }.to raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "fails if nothing is raised" do
-    expect {
-      expect {}.to raise_error(RuntimeError, /ample mess/)
-    }.to fail_with(/expected RuntimeError with message matching \/ample mess\/ but nothing was raised/)
-  end
-
-  it "fails if incorrect error is raised" do
-    expect {
-      expect { raise RuntimeError, "example message" }.to raise_error(NameError, /ample mess/)
-    }.to fail_with(/expected NameError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
-  end
-
-  it "fails if correct error is raised with incorrect message" do
-    expect {
-      expect { raise RuntimeError.new("not the example message") }.to raise_error(RuntimeError, /less than ample mess/)
-    }.to fail_with(/expected RuntimeError with message matching \/less than ample mess\/, got #<RuntimeError: not the example message>/)
-  end
-end
-
-describe "expect { ... }.to_not raise_error(NamedError, error_message) with Regexp" do
-  it "passes if nothing is raised" do
-    expect {}.to_not raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "passes if a different error is raised" do
-    expect { raise }.to_not raise_error(NameError, /ample mess/)
-  end
-
-  it "passes if same error is raised with non-matching message" do
-    expect { raise RuntimeError.new("non matching message") }.to_not raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "fails if named error is raised with matching message" do
+describe "misuse of raise_error, with (), not {}" do
+  it "fails with warning" do
+    ::Kernel.should_receive(:warn).with(/`raise_error` was called with non-proc object 1\.7/)
     expect {
-      expect { raise "example message" }.to_not raise_error(RuntimeError, /ample mess/)
-    }.to fail_with(/expected no RuntimeError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
+      expect(Math.sqrt(3)).to raise_error
+    }.to fail_with(/nothing was raised/)
   end
 end