rspec-expectations 2.12.1 → 2.13.0

data/spec/rspec/matchers/eq_spec.rb

@@ -8,15 +8,15 @@ module RSpec
       end
 
       it "is diffable" do
-        eq(1).should be_diffable
+        expect(eq(1)).to be_diffable
       end
 
       it "matches when actual == expected" do
-        1.should eq(1)
+        expect(1).to eq(1)
       end
-      
+
       it "does not match when actual != expected" do
-        1.should_not eq(2)
+        expect(1).not_to eq(2)
       end
 
       it "compares by sending == to actual (not expected)" do
@@ -27,26 +27,32 @@ module RSpec
           end
         end.new
 
-        actual.should eq :anything # to trigger the matches? method
-        called.should be_true
+        expect(actual).to eq :anything # to trigger the matches? method
+        expect(called).to be_true
       end
 
       it "describes itself" do
         matcher = eq(1)
         matcher.matches?(1)
-        matcher.description.should eq "eq 1"
+        expect(matcher.description).to eq "eq 1"
       end
-      
+
       it "provides message, expected and actual on #failure_message" do
         matcher = eq("1")
         matcher.matches?(1)
-        matcher.failure_message_for_should.should eq "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
+        expect(matcher.failure_message_for_should).to eq "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
       end
-      
+
       it "provides message, expected and actual on #negative_failure_message" do
         matcher = eq(1)
         matcher.matches?(1)
-        matcher.failure_message_for_should_not.should eq "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
+        expect(matcher.failure_message_for_should_not).to eq "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
+      end
+
+      it 'fails properly when the actual is an array of multiline strings' do
+        expect {
+          expect(["a\nb", "c\nd"]).to eq([])
+        }.to fail_matching("expected: []")
       end
     end
   end

data/spec/rspec/matchers/eql_spec.rb

@@ -8,33 +8,33 @@ module RSpec
       end
 
       it "is diffable" do
-        eql(1).should be_diffable
+        expect(eql(1)).to be_diffable
       end
 
       it "matches when actual.eql?(expected)" do
-        1.should eql(1)
+        expect(1).to eql(1)
       end
-      
+
       it "does not match when !actual.eql?(expected)" do
-        1.should_not eql(2)
+        expect(1).not_to eql(2)
       end
-      
+
       it "describes itself" do
         matcher = eql(1)
         matcher.matches?(1)
-        matcher.description.should == "eql 1"
+        expect(matcher.description).to eq "eql 1"
       end
-      
+
       it "provides message, expected and actual on #failure_message" do
         matcher = eql("1")
         matcher.matches?(1)
-        matcher.failure_message_for_should.should == "\nexpected: \"1\"\n     got: 1\n\n(compared using eql?)\n"
+        expect(matcher.failure_message_for_should).to eq "\nexpected: \"1\"\n     got: 1\n\n(compared using eql?)\n"
       end
-      
+
       it "provides message, expected and actual on #negative_failure_message" do
         matcher = eql(1)
         matcher.matches?(1)
-        matcher.failure_message_for_should_not.should == "\nexpected: value != 1\n     got: 1\n\n(compared using eql?)\n"
+        expect(matcher.failure_message_for_should_not).to eq "\nexpected: value != 1\n     got: 1\n\n(compared using eql?)\n"
       end
     end
   end

data/spec/rspec/matchers/equal_spec.rb

@@ -11,42 +11,60 @@ module RSpec
       end
 
       it "matches when actual.equal?(expected)" do
-        1.should equal(1)
+        expect(1).to equal(1)
       end
 
       it "does not match when !actual.equal?(expected)" do
-        "1".should_not equal("1")
+        expect("1").not_to equal("1")
       end
 
       it "describes itself" do
         matcher = equal(1)
         matcher.matches?(1)
-        matcher.description.should == "equal 1"
+        expect(matcher.description).to eq "equal 1"
       end
 
-      it "provides message on #failure_message" do
+      it "suggests the `eq` matcher on failure" do
         expected, actual = "1", "1"
-        matcher = equal(expected)
-        matcher.matches?(actual)
+        expect {
+          expect(actual).to equal(expected)
+        }.to fail_with <<-MESSAGE
+
+expected #{inspect_object(expected)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+`expect(actual).to eq(expected)` if you don't care about
+object identity in this example.
+
+MESSAGE
+      end
 
-        matcher.failure_message_for_should.should == <<-MESSAGE
+      context "when using only `should`", :uses_only_should do
+        it "suggests the `eq` matcher on failure" do
+          expected, actual = "1", "1"
+          lambda {
+            actual.should equal(expected)
+          }.should fail_with <<-MESSAGE
 
 expected #{inspect_object(expected)}
      got #{inspect_object(actual)}
 
 Compared using equal?, which compares object identity,
 but expected and actual are not the same object. Use
-'actual.should eq(expected)' if you don't care about
+`actual.should eq(expected)` if you don't care about
 object identity in this example.
 
 MESSAGE
+        end
       end
 
       it "provides message on #negative_failure_message" do
         expected = actual = "1"
         matcher = equal(expected)
         matcher.matches?(actual)
-        matcher.failure_message_for_should_not.should == <<-MESSAGE
+        expect(matcher.failure_message_for_should_not).to eq <<-MESSAGE
 
 expected not #{inspect_object(expected)}
          got #{inspect_object(actual)}

data/spec/rspec/matchers/exist_spec.rb

@@ -10,11 +10,11 @@ describe "exist matcher" do
   context "when the object does not respond to #exist? or #exists?" do
     subject { mock }
 
-    [:should, :should_not].each do |should_method|
-      describe "#{should_method} exist" do
+    [:to, :not_to].each do |expect_method|
+      describe "expect(...).#{expect_method} exist" do
         it "raises an error" do
           expect {
-            subject.send(should_method, exist)
+            expect(subject).send(expect_method, exist)
           }.to raise_error(NoMethodError)
         end
       end
@@ -23,26 +23,40 @@ describe "exist matcher" do
 
   [:exist?, :exists?].each do |predicate|
     context "when the object responds to ##{predicate}" do
-      describe "should exist" do
+      describe "expect(...).to exist" do
         it "passes if #{predicate}" do
-          mock(predicate => true).should exist
+          expect(mock(predicate => true)).to exist
         end
 
         it "fails if not #{predicate}" do
           expect {
-            mock(predicate => false).should exist
+            expect(mock(predicate => false)).to exist
           }.to fail_with(/expected .* to exist/)
         end
+
+        it 'works when the object overrides `send`' do
+          klass = Struct.new(:message) do
+            def send
+              :message_sent
+            end
+
+            define_method predicate do
+              true
+            end
+          end
+
+          expect(klass.new("msg")).to exist
+        end
       end
 
-      describe "should not exist" do
+      describe "expect(...).not_to exist" do
         it "passes if not #{predicate}" do
-          mock(predicate => false).should_not exist
+          expect(mock(predicate => false)).not_to exist
         end
 
         it "fails if #{predicate}" do
           expect {
-            mock(predicate => true).should_not exist
+            expect(mock(predicate => true)).not_to exist
           }.to fail_with(/expected .* not to exist/)
         end
       end
@@ -53,16 +67,16 @@ describe "exist matcher" do
     context "when they both return falsey values" do
       subject { mock(:exist? => false, :exists? => nil) }
 
-      describe "should_not exist" do
+      describe "expect(...).not_to exist" do
         it "passes" do
-          subject.should_not exist
+          expect(subject).not_to exist
         end
       end
 
-      describe "should exist" do
+      describe "expect(...).to exist" do
         it "fails" do
           expect {
-            subject.should exist
+            expect(subject).to exist
           }.to fail_with(/expected .* to exist/)
         end
       end
@@ -71,17 +85,17 @@ describe "exist matcher" do
     context "when they both return truthy values" do
       subject { mock(:exist? => true, :exists? => "something true") }
 
-      describe "should_not exist" do
+      describe "expect(...).not_to exist" do
         it "fails" do
           expect {
-            subject.should_not exist
+            expect(subject).not_to exist
           }.to fail_with(/expected .* not to exist/)
         end
       end
 
-      describe "should exist" do
+      describe "expect(...).to exist" do
         it "passes" do
-          subject.should exist
+          expect(subject).to exist
         end
       end
     end
@@ -89,11 +103,11 @@ describe "exist matcher" do
     context "when they return values with different truthiness" do
       subject { mock(:exist? => true, :exists? => false) }
 
-      [:should, :should_not].each do |should_method|
-        describe "#{should_method} exist" do
+      [:to, :not_to].each do |expect_method|
+        describe "expect(...).#{expect_method} exist" do
           it "raises an error" do
             expect {
-              subject.send(should_method, exist)
+              expect(subject).send(expect_method, exist)
             }.to raise_error(/#exist\? and #exists\? returned different values/)
           end
         end
@@ -105,6 +119,6 @@ describe "exist matcher" do
     object = mock
     object.should_receive(:exist?).with(:foo, :bar) { true }
 
-    object.should exist(:foo, :bar)
+    expect(object).to exist(:foo, :bar)
   end
 end

data/spec/rspec/matchers/has_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 
-describe "should have_sym(*args)" do
+describe "expect(...).to have_sym(*args)" do
   it_behaves_like "an RSpec matcher", :valid_value => { :a => 1 },
                                       :invalid_value => {} do
     let(:matcher) { have_key(:a) }
   end
 
   it "passes if #has_sym?(*args) returns true" do
-    {:a => "A"}.should have_key(:a)
+    expect({:a => "A"}).to have_key(:a)
   end
 
   it "fails if #has_sym?(*args) returns false" do
-    lambda {
-      {:b => "B"}.should have_key(:a)
-    }.should fail_with("expected #has_key?(:a) to return true, got false")
+    expect {
+      expect({:b => "B"}).to have_key(:a)
+    }.to fail_with("expected #has_key?(:a) to return true, got false")
   end
 
   it 'does not include any args in the failure message if no args were given to the matcher' do
     o = Object.new
     def o.has_some_stuff?; false; end
     expect {
-      o.should have_some_stuff
+      expect(o).to have_some_stuff
     }.to fail_with("expected #has_some_stuff? to return true, got false")
   end
 
@@ -28,7 +28,7 @@ describe "should have_sym(*args)" do
     o = Object.new
     def o.has_some_stuff?(*_); false; end
     expect {
-      o.should have_some_stuff(:a, 7, "foo")
+      expect(o).to have_some_stuff(:a, 7, "foo")
     }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return true, got false')
   end
 
@@ -37,15 +37,15 @@ describe "should have_sym(*args)" do
       def has_foo?
       end
     end
-    lambda {
-      klass.new.should have_foo
-    }.should fail_with(/expected #has_foo.* to return true, got false/)
+    expect {
+      expect(klass.new).to have_foo
+    }.to fail_with(/expected #has_foo.* to return true, got false/)
   end
 
   it "fails if target does not respond to #has_sym?" do
-    lambda {
-      Object.new.should have_key(:a)
-    }.should raise_error(NoMethodError)
+    expect {
+      expect(Object.new).to have_key(:a)
+    }.to raise_error(NoMethodError)
   end
 
   it "reraises an exception thrown in #has_sym?(*args)" do
@@ -53,13 +53,15 @@ describe "should have_sym(*args)" do
     def o.has_sym?(*args)
       raise "Funky exception"
     end
-    lambda { o.should have_sym(:foo) }.should raise_error("Funky exception")
+    expect {
+      expect(o).to have_sym(:foo)
+    }.to raise_error("Funky exception")
   end
 end
 
-describe "should_not have_sym(*args)" do
+describe "expect(...).not_to have_sym(*args)" do
   it "passes if #has_sym?(*args) returns false" do
-    {:a => "A"}.should_not have_key(:b)
+    expect({:a => "A"}).not_to have_key(:b)
   end
 
   it "passes if #has_sym?(*args) returns nil" do
@@ -67,19 +69,19 @@ describe "should_not have_sym(*args)" do
       def has_foo?
       end
     end
-    klass.new.should_not have_foo
+    expect(klass.new).not_to have_foo
   end
 
   it "fails if #has_sym?(*args) returns true" do
-    lambda {
-      {:a => "A"}.should_not have_key(:a)
-    }.should fail_with("expected #has_key?(:a) to return false, got true")
+    expect {
+      expect({:a => "A"}).not_to have_key(:a)
+    }.to fail_with("expected #has_key?(:a) to return false, got true")
   end
 
   it "fails if target does not respond to #has_sym?" do
-    lambda {
-      Object.new.should have_key(:a)
-    }.should raise_error(NoMethodError)
+    expect {
+      expect(Object.new).to have_key(:a)
+    }.to raise_error(NoMethodError)
   end
 
   it "reraises an exception thrown in #has_sym?(*args)" do
@@ -87,14 +89,16 @@ describe "should_not have_sym(*args)" do
     def o.has_sym?(*args)
       raise "Funky exception"
     end
-    lambda { o.should_not have_sym(:foo) }.should raise_error("Funky exception")
+    expect {
+      expect(o).not_to have_sym(:foo)
+    }.to raise_error("Funky exception")
   end
 
   it 'does not include any args in the failure message if no args were given to the matcher' do
     o = Object.new
     def o.has_some_stuff?; true; end
     expect {
-      o.should_not have_some_stuff
+      expect(o).not_to have_some_stuff
     }.to fail_with("expected #has_some_stuff? to return false, got true")
   end
 
@@ -102,7 +106,7 @@ describe "should_not have_sym(*args)" do
     o = Object.new
     def o.has_some_stuff?(*_); true; end
     expect {
-      o.should_not have_some_stuff(:a, 7, "foo")
+      expect(o).not_to have_some_stuff(:a, 7, "foo")
     }.to fail_with('expected #has_some_stuff?(:a, 7, "foo") to return false, got true')
   end
 end
@@ -111,8 +115,8 @@ describe "has" do
   it "works when the target implements #send" do
     o = {:a => "A"}
     def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
-    lambda {
-      o.should have_key(:a)
-    }.should_not raise_error
+    expect {
+      expect(o).to have_key(:a)
+    }.to_not raise_error
   end
 end

data/spec/rspec/matchers/have_spec.rb

@@ -22,64 +22,64 @@ describe "have matcher" do
     owner
   end
 
-  describe "should have(n).items" do
+  describe "expect(...).to have(n).items" do
     it_behaves_like "an RSpec matcher", :valid_value => [1, 2], :invalid_value => [1] do
       let(:matcher) { have(2).items }
     end
 
     it "passes if target has a collection of items with n members" do
       owner = create_collection_owner_with(3)
-      owner.should have(3).items_in_collection_with_length_method
-      owner.should have(3).items_in_collection_with_size_method
-      owner.should have(3).items_in_collection_with_count_method
+      expect(owner).to have(3).items_in_collection_with_length_method
+      expect(owner).to have(3).items_in_collection_with_size_method
+      expect(owner).to have(3).items_in_collection_with_count_method
     end
 
     it "converts :no to 0" do
       owner = create_collection_owner_with(0)
-      owner.should have(:no).items_in_collection_with_length_method
-      owner.should have(:no).items_in_collection_with_size_method
-      owner.should have(:no).items_in_collection_with_count_method
+      expect(owner).to have(:no).items_in_collection_with_length_method
+      expect(owner).to have(:no).items_in_collection_with_size_method
+      expect(owner).to have(:no).items_in_collection_with_count_method
     end
 
     it "converts a String argument to Integer" do
       owner = create_collection_owner_with(3)
-      owner.should have('3').items_in_collection_with_length_method
-      owner.should have('3').items_in_collection_with_size_method
-      owner.should have('3').items_in_collection_with_count_method
+      expect(owner).to have('3').items_in_collection_with_length_method
+      expect(owner).to have('3').items_in_collection_with_size_method
+      expect(owner).to have('3').items_in_collection_with_count_method
     end
 
     it "fails if target has a collection of items with < n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have(4).items_in_collection_with_length_method
-      }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have(4).items_in_collection_with_size_method
-      }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have(4).items_in_collection_with_count_method
-      }.should fail_with("expected 4 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have(4).items_in_collection_with_length_method
+      }.to fail_with("expected 4 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have(4).items_in_collection_with_size_method
+      }.to fail_with("expected 4 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have(4).items_in_collection_with_count_method
+      }.to fail_with("expected 4 items_in_collection_with_count_method, got 3")
     end
 
     it "fails if target has a collection of items with > n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have(2).items_in_collection_with_length_method
-      }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have(2).items_in_collection_with_size_method
-      }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have(2).items_in_collection_with_count_method
-      }.should fail_with("expected 2 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have(2).items_in_collection_with_length_method
+      }.to fail_with("expected 2 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have(2).items_in_collection_with_size_method
+      }.to fail_with("expected 2 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have(2).items_in_collection_with_count_method
+      }.to fail_with("expected 2 items_in_collection_with_count_method, got 3")
     end
   end
 
-  describe 'should have(1).item when ActiveSupport::Inflector is defined' do
+  describe 'expect(...).to have(1).item when ActiveSupport::Inflector is defined' do
 
     it 'pluralizes the collection name' do
       owner = create_collection_owner_with(1)
-      owner.should have(1).item
+      expect(owner).to have(1).item
     end
 
     context "when ActiveSupport::Inflector is partially loaded without its inflectors" do
@@ -87,134 +87,136 @@ describe "have matcher" do
       it "does not pluralize the collection name" do
         stub_const("ActiveSupport::Inflector", Module.new)
         owner = create_collection_owner_with(1)
-        expect { owner.should have(1).item }.to raise_error(NoMethodError)
+        expect {
+          expect(owner).to have(1).item
+        }.to raise_error(NoMethodError)
       end
 
     end
   end
 
-  describe 'should have(1).item when Inflector is defined' do
+  describe 'expect(...).to have(1).item when Inflector is defined' do
     before { stub_const("Inflector", inflector) }
 
     it 'pluralizes the collection name' do
       owner = create_collection_owner_with(1)
-      owner.should have(1).item
+      expect(owner).to have(1).item
     end
   end
 
-  describe "should have(n).items where result responds to items but returns something other than a collection" do
+  describe "expect(...).to have(n).items where result responds to items but returns something other than a collection" do
     it "provides a meaningful error" do
       owner = Class.new do
         def items
           Object.new
         end
       end.new
-      lambda do
-        owner.should have(3).items
-      end.should raise_error("expected items to be a collection but it does not respond to #length, #size or #count")
+      expect do
+        expect(owner).to have(3).items
+      end.to raise_error("expected items to be a collection but it does not respond to #length, #size or #count")
     end
   end
 
-  describe "should_not have(n).items" do
+  describe "expect(...).not_to have(n).items" do
 
     it "passes if target has a collection of items with < n members" do
       owner = create_collection_owner_with(3)
-      owner.should_not have(4).items_in_collection_with_length_method
-      owner.should_not have(4).items_in_collection_with_size_method
-      owner.should_not have(4).items_in_collection_with_count_method
+      expect(owner).not_to have(4).items_in_collection_with_length_method
+      expect(owner).not_to have(4).items_in_collection_with_size_method
+      expect(owner).not_to have(4).items_in_collection_with_count_method
     end
 
     it "passes if target has a collection of items with > n members" do
       owner = create_collection_owner_with(3)
-      owner.should_not have(2).items_in_collection_with_length_method
-      owner.should_not have(2).items_in_collection_with_size_method
-      owner.should_not have(2).items_in_collection_with_count_method
+      expect(owner).not_to have(2).items_in_collection_with_length_method
+      expect(owner).not_to have(2).items_in_collection_with_size_method
+      expect(owner).not_to have(2).items_in_collection_with_count_method
     end
 
     it "fails if target has a collection of items with n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should_not have(3).items_in_collection_with_length_method
-      }.should fail_with("expected target not to have 3 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should_not have(3).items_in_collection_with_size_method
-        }.should fail_with("expected target not to have 3 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should_not have(3).items_in_collection_with_count_method
-        }.should fail_with("expected target not to have 3 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).not_to have(3).items_in_collection_with_length_method
+      }.to fail_with("expected target not to have 3 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).not_to have(3).items_in_collection_with_size_method
+      }.to fail_with("expected target not to have 3 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).not_to have(3).items_in_collection_with_count_method
+      }.to fail_with("expected target not to have 3 items_in_collection_with_count_method, got 3")
     end
   end
 
-  describe "should have_exactly(n).items" do
+  describe "expect(...).to have_exactly(n).items" do
 
     it "passes if target has a collection of items with n members" do
       owner = create_collection_owner_with(3)
-      owner.should have_exactly(3).items_in_collection_with_length_method
-      owner.should have_exactly(3).items_in_collection_with_size_method
-      owner.should have_exactly(3).items_in_collection_with_count_method
+      expect(owner).to have_exactly(3).items_in_collection_with_length_method
+      expect(owner).to have_exactly(3).items_in_collection_with_size_method
+      expect(owner).to have_exactly(3).items_in_collection_with_count_method
     end
 
     it "converts :no to 0" do
       owner = create_collection_owner_with(0)
-      owner.should have_exactly(:no).items_in_collection_with_length_method
-      owner.should have_exactly(:no).items_in_collection_with_size_method
-      owner.should have_exactly(:no).items_in_collection_with_count_method
+      expect(owner).to have_exactly(:no).items_in_collection_with_length_method
+      expect(owner).to have_exactly(:no).items_in_collection_with_size_method
+      expect(owner).to have_exactly(:no).items_in_collection_with_count_method
     end
 
     it "fails if target has a collection of items with < n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have_exactly(4).items_in_collection_with_length_method
-      }.should fail_with("expected 4 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have_exactly(4).items_in_collection_with_size_method
-      }.should fail_with("expected 4 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have_exactly(4).items_in_collection_with_count_method
-      }.should fail_with("expected 4 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have_exactly(4).items_in_collection_with_length_method
+      }.to fail_with("expected 4 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have_exactly(4).items_in_collection_with_size_method
+      }.to fail_with("expected 4 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have_exactly(4).items_in_collection_with_count_method
+      }.to fail_with("expected 4 items_in_collection_with_count_method, got 3")
     end
 
     it "fails if target has a collection of items with > n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have_exactly(2).items_in_collection_with_length_method
-      }.should fail_with("expected 2 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have_exactly(2).items_in_collection_with_size_method
-      }.should fail_with("expected 2 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have_exactly(2).items_in_collection_with_count_method
-      }.should fail_with("expected 2 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have_exactly(2).items_in_collection_with_length_method
+      }.to fail_with("expected 2 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have_exactly(2).items_in_collection_with_size_method
+      }.to fail_with("expected 2 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have_exactly(2).items_in_collection_with_count_method
+      }.to fail_with("expected 2 items_in_collection_with_count_method, got 3")
     end
   end
 
-  describe "should have_at_least(n).items" do
+  describe "expect(...).to have_at_least(n).items" do
 
     it "passes if target has a collection of items with n members" do
       owner = create_collection_owner_with(3)
-      owner.should have_at_least(3).items_in_collection_with_length_method
-      owner.should have_at_least(3).items_in_collection_with_size_method
-      owner.should have_at_least(3).items_in_collection_with_count_method
+      expect(owner).to have_at_least(3).items_in_collection_with_length_method
+      expect(owner).to have_at_least(3).items_in_collection_with_size_method
+      expect(owner).to have_at_least(3).items_in_collection_with_count_method
     end
 
     it "passes if target has a collection of items with > n members" do
       owner = create_collection_owner_with(3)
-      owner.should have_at_least(2).items_in_collection_with_length_method
-      owner.should have_at_least(2).items_in_collection_with_size_method
-      owner.should have_at_least(2).items_in_collection_with_count_method
+      expect(owner).to have_at_least(2).items_in_collection_with_length_method
+      expect(owner).to have_at_least(2).items_in_collection_with_size_method
+      expect(owner).to have_at_least(2).items_in_collection_with_count_method
     end
 
     it "fails if target has a collection of items with < n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have_at_least(4).items_in_collection_with_length_method
-      }.should fail_with("expected at least 4 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have_at_least(4).items_in_collection_with_size_method
-      }.should fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have_at_least(4).items_in_collection_with_count_method
-      }.should fail_with("expected at least 4 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have_at_least(4).items_in_collection_with_length_method
+      }.to fail_with("expected at least 4 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have_at_least(4).items_in_collection_with_size_method
+      }.to fail_with("expected at least 4 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have_at_least(4).items_in_collection_with_count_method
+      }.to fail_with("expected at least 4 items_in_collection_with_count_method, got 3")
     end
 
     it "provides educational negative failure messages" do
@@ -230,57 +232,57 @@ describe "have matcher" do
       count_matcher.matches?(owner)
 
       #then
-      length_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(length_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(3).items_in_collection_with_length_method
+  expect(actual).not_to have_at_least(3).items_in_collection_with_length_method
 We recommend that you use this instead:
-  should have_at_most(2).items_in_collection_with_length_method
+  expect(actual).to have_at_most(2).items_in_collection_with_length_method
 EOF
 
-      size_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(size_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(3).items_in_collection_with_size_method
+  expect(actual).not_to have_at_least(3).items_in_collection_with_size_method
 We recommend that you use this instead:
-  should have_at_most(2).items_in_collection_with_size_method
+  expect(actual).to have_at_most(2).items_in_collection_with_size_method
 EOF
-      count_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(count_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_least(3).items_in_collection_with_count_method
+  expect(actual).not_to have_at_least(3).items_in_collection_with_count_method
 We recommend that you use this instead:
-  should have_at_most(2).items_in_collection_with_count_method
+  expect(actual).to have_at_most(2).items_in_collection_with_count_method
 EOF
     end
   end
 
-  describe "should have_at_most(n).items" do
+  describe "expect(...).to have_at_most(n).items" do
     it "passes if target has a collection of items with n members" do
       owner = create_collection_owner_with(3)
-      owner.should have_at_most(3).items_in_collection_with_length_method
-      owner.should have_at_most(3).items_in_collection_with_size_method
-      owner.should have_at_most(3).items_in_collection_with_count_method
+      expect(owner).to have_at_most(3).items_in_collection_with_length_method
+      expect(owner).to have_at_most(3).items_in_collection_with_size_method
+      expect(owner).to have_at_most(3).items_in_collection_with_count_method
     end
 
     it "fails if target has a collection of items with > n members" do
       owner = create_collection_owner_with(3)
-      lambda {
-        owner.should have_at_most(2).items_in_collection_with_length_method
-      }.should fail_with("expected at most 2 items_in_collection_with_length_method, got 3")
-      lambda {
-        owner.should have_at_most(2).items_in_collection_with_size_method
-      }.should fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
-      lambda {
-        owner.should have_at_most(2).items_in_collection_with_count_method
-      }.should fail_with("expected at most 2 items_in_collection_with_count_method, got 3")
+      expect {
+        expect(owner).to have_at_most(2).items_in_collection_with_length_method
+      }.to fail_with("expected at most 2 items_in_collection_with_length_method, got 3")
+      expect {
+        expect(owner).to have_at_most(2).items_in_collection_with_size_method
+      }.to fail_with("expected at most 2 items_in_collection_with_size_method, got 3")
+      expect {
+        expect(owner).to have_at_most(2).items_in_collection_with_count_method
+      }.to fail_with("expected at most 2 items_in_collection_with_count_method, got 3")
     end
 
     it "passes if target has a collection of items with < n members" do
       owner = create_collection_owner_with(3)
-      owner.should have_at_most(4).items_in_collection_with_length_method
-      owner.should have_at_most(4).items_in_collection_with_size_method
-      owner.should have_at_most(4).items_in_collection_with_count_method
+      expect(owner).to have_at_most(4).items_in_collection_with_length_method
+      expect(owner).to have_at_most(4).items_in_collection_with_size_method
+      expect(owner).to have_at_most(4).items_in_collection_with_count_method
     end
 
     it "provides educational negative failure messages" do
@@ -296,28 +298,28 @@ EOF
       count_matcher.matches?(owner)
 
       #then
-      length_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(length_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(3).items_in_collection_with_length_method
+  expect(actual).not_to have_at_most(3).items_in_collection_with_length_method
 We recommend that you use this instead:
-  should have_at_least(4).items_in_collection_with_length_method
+  expect(actual).to have_at_least(4).items_in_collection_with_length_method
 EOF
 
-      size_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(size_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(3).items_in_collection_with_size_method
+  expect(actual).not_to have_at_most(3).items_in_collection_with_size_method
 We recommend that you use this instead:
-  should have_at_least(4).items_in_collection_with_size_method
+  expect(actual).to have_at_least(4).items_in_collection_with_size_method
 EOF
 
-      count_matcher.failure_message_for_should_not.should eq <<-EOF
+      expect(count_matcher.failure_message_for_should_not).to eq <<-EOF
 Isn't life confusing enough?
 Instead of having to figure out the meaning of this:
-  should_not have_at_most(3).items_in_collection_with_count_method
+  expect(actual).not_to have_at_most(3).items_in_collection_with_count_method
 We recommend that you use this instead:
-  should have_at_least(4).items_in_collection_with_count_method
+  expect(actual).to have_at_least(4).items_in_collection_with_count_method
 EOF
     end
   end
@@ -326,40 +328,48 @@ EOF
     it "passes args to target" do
       target = mock("target")
       target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
-      target.should have(3).items("arg1","arg2")
+      expect(target).to have(3).items("arg1","arg2")
     end
 
     it "passes block to target" do
       target = mock("target")
       block = lambda { 5 }
       target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
-      target.should have(3).items("arg1","arg2", block)
+      expect(target).to have(3).items("arg1","arg2", block)
     end
   end
 
   describe "have(n).items where target IS a collection" do
     it "references the number of items IN the collection" do
-      [1,2,3].should have(3).items
+      expect([1,2,3]).to have(3).items
     end
 
     it "fails when the number of items IN the collection is not as expected" do
-      lambda { [1,2,3].should have(7).items }.should fail_with("expected 7 items, got 3")
+      expect {
+        expect([1,2,3]).to have(7).items
+      }.to fail_with("expected 7 items, got 3")
     end
   end
 
   describe "have(n).characters where target IS a String" do
     it "passes if the length is correct" do
-      "this string".should have(11).characters
+      expect("this string").to have(11).characters
     end
 
     it "fails if the length is incorrect" do
-      lambda { "this string".should have(12).characters }.should fail_with("expected 12 characters, got 11")
+      expect {
+        expect("this string").to have(12).characters
+      }.to fail_with("expected 12 characters, got 11")
     end
   end
 
   describe "have(n).things on an object which is not a collection nor contains one" do
     it "fails" do
-      lambda { Object.new.should have(2).things }.should raise_error(NoMethodError) {|e| e.name.should eq :things }
+      expect {
+        expect(Object.new).to have(2).things
+      }.to raise_error(NoMethodError) { |e|
+        expect(e.name).to eq :things
+      }
     end
   end
 
@@ -367,35 +377,39 @@ EOF
     before(:each) do
       @collection = Object.new
       def @collection.floozles; [1,2] end
+      def @collection.send; :sent; end
     end
 
     it "works in the straightforward case" do
-      lambda {
-        @collection.should have(2).floozles
-      }.should_not raise_error
+      expect(@collection).to have(2).floozles
     end
 
     it "works when doing automatic pluralization" do
-      lambda {
-        @collection.should have_at_least(1).floozle
-      }.should_not raise_error
+      expect(@collection).to have_at_least(1).floozle
     end
 
     it "blows up when the owner doesn't respond to that method" do
-      lambda {
-        @collection.should have(99).problems
-      }.should raise_error(NoMethodError, /problems/)
+      expect {
+        expect(@collection).to have(99).problems
+      }.to raise_error(NoMethodError, /problems/)
+    end
+
+    it 'works when #send is defined directly on an array' do
+      array = [1, 2]
+      def array.send; :sent; end
+
+      expect(array).to have(2).items
     end
   end
 
   describe RSpec::Matchers::BuiltIn::Have do
     it "has method_missing as private" do
-      described_class.private_instance_methods.should include_method(:method_missing)
+      expect(described_class.private_instance_methods).to include_method(:method_missing)
     end
 
     it "does not respond_to? method_missing (because it's private)" do
       formatter = described_class.new(0, StringIO.new)
-      formatter.should_not respond_to(:method_missing)
+      expect(formatter).not_to respond_to(:method_missing)
     end
 
     describe "respond_to?" do
@@ -406,25 +420,25 @@ EOF
       end
 
       it "is true for a method which Have defines" do
-        @have.should respond_to(@a_method_which_have_defines)
+        expect(@have).to respond_to(@a_method_which_have_defines)
       end
 
       it "is true for a method that it's superclass (Object) defines" do
-        @have.should respond_to(@a_method_which_object_defines)
+        expect(@have).to respond_to(@a_method_which_object_defines)
       end
 
       it "is false for a method which neither Object nor nor Have defines" do
-        @have.should_not respond_to(:foo_bar_baz)
+        expect(@have).not_to respond_to(:foo_bar_baz)
       end
 
       it "is false if the owner doesn't respond to the method" do
         have = described_class.new(99)
-        have.should_not respond_to(:problems)
+        expect(have).not_to respond_to(:problems)
       end
 
       it "is true if the owner responds to the method" do
         have = described_class.new(:a_symbol)
-        have.should respond_to(:to_sym)
+        expect(have).to respond_to(:to_sym)
       end
     end
   end