rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/matchers/{start_with_end_with_spec.rb → built_in/start_and_end_with_spec.rb}

@@ -35,23 +35,47 @@ describe "expect(...).to start_with" do
     it "fails if it the first elements of the array do not match" do
       expect {
         expect([0, 1, 2]).to start_with 1, 2
-      }.to fail_with("expected [0, 1, 2] to start with [1, 2]")
+      }.to fail_with("expected [0, 1, 2] to start with 1 and 2")
     end
   end
 
   context "with an object that does not respond to :[]" do
-    it "raises an ArgumentError" do
+    it "fails with a useful message" do
+      actual = Object.new
       expect {
-        expect(Object.new).to start_with 0
-      }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+        expect(actual).to start_with 0
+      }.to fail_with("expected #{actual.inspect} to start with 0, but it cannot be indexed using #[]")
     end
   end
 
   context "with a hash" do
-    it "raises an ArgumentError if trying to match more than one element" do
+    it "fails with a useful error if trying to match more than one element" do
+      actual   = { :a => 'b', :b => 'b', :c => 'c' }
+      expected = { :a => 'b', :b => 'b' }
       expect{
-        expect({:a => 'b', :b => 'b', :c => 'c'}).to start_with({:a => 'b', :b => 'b'})
-      }.to raise_error(ArgumentError, /does not have ordered elements/)
+        expect(actual).to start_with(expected)
+      }.to fail_with("expected #{actual.inspect} to start with #{expected.inspect}, but it does not have ordered elements")
+    end
+  end
+
+  describe "composing with other matchers" do
+    it 'passes if the start of an array matches two given matchers' do
+      expect([1.01, "food", 3]).to start_with(a_value_within(0.2).of(1), a_string_matching(/foo/))
+    end
+
+    it 'passes if the start of an array matches one given matcher' do
+      expect([1.01, "food", 3]).to start_with(a_value_within(0.2).of(1))
+    end
+
+    it 'provides a description' do
+      description = start_with(a_value_within(0.1).of(1), a_string_matching(/abc/)).description
+      expect(description).to eq("start with a value within 0.1 of 1 and a string matching /abc/")
+    end
+
+    it 'fails with a clear error message when the matchers do not match' do
+      expect {
+        expect([2.01, "food", 3]).to start_with(a_value_within(0.2).of(1), a_string_matching(/foo/))
+      }.to fail_with('expected [2.01, "food", 3] to start with a value within 0.2 of 1 and a string matching /foo/')
     end
   end
 end
@@ -87,9 +111,19 @@ describe "expect(...).not_to start_with" do
     it "fails if it the first elements of the array match" do
       expect {
         expect([0, 1, 2]).not_to start_with 0, 1
-      }.to fail_with("expected [0, 1, 2] not to start with [0, 1]")
+      }.to fail_with("expected [0, 1, 2] not to start with 0 and 1")
     end
   end
+
+  it 'can pass when composed with another matcher' do
+    expect(["a"]).not_to start_with(a_string_matching(/bar/))
+  end
+
+  it 'can fail when composed with another matcher' do
+    expect {
+      expect(["a"]).not_to start_with(a_string_matching(/a/))
+    }.to fail_with('expected ["a"] not to start with a string matching /a/')
+  end
 end
 
 describe "expect(...).to end_with" do
@@ -127,26 +161,49 @@ describe "expect(...).to end_with" do
     it "fails if it the last elements of the array do not match" do
       expect {
         expect([0, 1, 2]).to end_with [0, 1]
-      }.to fail_with("expected [0, 1, 2] to end with [0, 1]")
+      }.to fail_with("expected [0, 1, 2] to end with 0 and 1")
     end
   end
 
   context "with an object that does not respond to :[]" do
-    it "raises an error if expected value can't be indexed'" do
+    it "fails with a useful message" do
+      actual = Object.new
       expect {
-        expect(Object.new).to end_with 0
-      }.to raise_error(ArgumentError, /does not respond to :\[\]/)
+        expect(actual).to end_with 0
+      }.to fail_with("expected #{actual.inspect} to end with 0, but it cannot be indexed using #[]")
     end
   end
 
   context "with a hash" do
     it "raises an ArgumentError if trying to match more than one element" do
+      actual   = { :a => 'b', :b => 'b', :c => 'c' }
+      expected = { :a => 'b', :b => 'b' }
       expect{
-        expect({:a => 'b', :b => 'b', :c => 'c'}).to end_with({:a => 'b', :b =>'b'})
-      }.to raise_error(ArgumentError, /does not have ordered elements/)
+        expect(actual).to end_with(expected)
+      }.to fail_with("expected #{actual.inspect} to end with #{expected.inspect}, but it does not have ordered elements")
     end
   end
 
+  describe "composing with other matchers" do
+    it 'passes if the end of an array matches two given matchers' do
+      expect([3, "food", 1.1]).to end_with(a_string_matching(/foo/), a_value_within(0.2).of(1))
+    end
+
+    it 'passes if the end of an array matches one given matcher' do
+      expect([3, "food", 1.1]).to end_with(a_value_within(0.2).of(1))
+    end
+
+    it 'provides a description' do
+      description = end_with(a_value_within(0.1).of(1), a_string_matching(/abc/)).description
+      expect(description).to eq("end with a value within 0.1 of 1 and a string matching /abc/")
+    end
+
+    it 'fails with a clear error message when the matchers do not match' do
+      expect {
+        expect([2.01, 3, "food"]).to end_with(a_value_within(0.2).of(1), a_string_matching(/foo/))
+      }.to fail_with('expected [2.01, 3, "food"] to end with a value within 0.2 of 1 and a string matching /foo/')
+    end
+  end
 end
 
 describe "expect(...).not_to end_with" do
@@ -180,7 +237,17 @@ describe "expect(...).not_to end_with" do
     it "fails if it the last elements of the array match" do
       expect {
         expect([0, 1, 2]).not_to end_with [1, 2]
-      }.to fail_with("expected [0, 1, 2] not to end with [1, 2]")
+      }.to fail_with("expected [0, 1, 2] not to end with 1 and 2")
     end
   end
+
+  it 'can pass when composed with another matcher' do
+    expect(["a"]).not_to end_with(a_string_matching(/bar/))
+  end
+
+  it 'can fail when composed with another matcher' do
+    expect {
+      expect(["a"]).not_to end_with(a_string_matching(/a/))
+    }.to fail_with('expected ["a"] not to end with a string matching /a/')
+  end
 end

data/spec/rspec/matchers/{throw_symbol_spec.rb → built_in/throw_symbol_spec.rb}

@@ -21,11 +21,11 @@ module RSpec::Matchers::BuiltIn
       end
       it "provides a failure message" do
         @matcher.matches?(lambda{})
-        expect(@matcher.failure_message_for_should).to eq "expected a Symbol to be thrown, got nothing"
+        expect(@matcher.failure_message).to eq "expected a Symbol to be thrown, got nothing"
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym})
-        expect(@matcher.failure_message_for_should_not).to eq "expected no Symbol to be thrown, got :sym"
+        expect(@matcher.failure_message_when_negated).to eq "expected no Symbol to be thrown, got :sym"
       end
     end
 
@@ -46,15 +46,15 @@ module RSpec::Matchers::BuiltIn
       end
       it "provides a failure message when no Symbol is thrown" do
         @matcher.matches?(lambda{})
-        expect(@matcher.failure_message_for_should).to eq "expected :sym to be thrown, got nothing"
+        expect(@matcher.failure_message).to eq "expected :sym to be thrown, got nothing"
       end
       it "provides a failure message when wrong Symbol is thrown" do
         @matcher.matches?(lambda{ throw :other_sym })
-        expect(@matcher.failure_message_for_should).to eq "expected :sym to be thrown, got :other_sym"
+        expect(@matcher.failure_message).to eq "expected :sym to be thrown, got :other_sym"
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym })
-        expect(@matcher.failure_message_for_should_not).to eq "expected :sym not to be thrown, got :sym"
+        expect(@matcher.failure_message_when_negated).to eq "expected :sym not to be thrown, got :sym"
       end
       it "only matches NameErrors raised by uncaught throws" do
         expect {
@@ -83,23 +83,23 @@ module RSpec::Matchers::BuiltIn
       end
       it "provides a failure message when no Symbol is thrown" do
         @matcher.matches?(lambda{})
-        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got nothing]
+        expect(@matcher.failure_message).to eq %q[expected :sym with "a" to be thrown, got nothing]
       end
       it "provides a failure message when wrong Symbol is thrown" do
         @matcher.matches?(lambda{ throw :other_sym })
-        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :other_sym]
+        expect(@matcher.failure_message).to eq %q[expected :sym with "a" to be thrown, got :other_sym]
       end
       it "provides a failure message when wrong arg is thrown" do
         @matcher.matches?(lambda{ throw :sym, "b" })
-        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :sym with "b"]
+        expect(@matcher.failure_message).to eq %q[expected :sym with "a" to be thrown, got :sym with "b"]
       end
       it "provides a failure message when no arg is thrown" do
         @matcher.matches?(lambda{ throw :sym })
-        expect(@matcher.failure_message_for_should).to eq %q[expected :sym with "a" to be thrown, got :sym with no argument]
+        expect(@matcher.failure_message).to eq %q[expected :sym with "a" to be thrown, got :sym with no argument]
       end
       it "provides a negative failure message" do
         @matcher.matches?(lambda{ throw :sym })
-        expect(@matcher.failure_message_for_should_not).to eq %q[expected :sym with "a" not to be thrown, got :sym with no argument]
+        expect(@matcher.failure_message_when_negated).to eq %q[expected :sym with "a" not to be thrown, got :sym with no argument]
       end
       it "only matches NameErrors raised by uncaught throws" do
         expect {
@@ -112,5 +112,24 @@ module RSpec::Matchers::BuiltIn
         }.to raise_error(/Boom/)
       end
     end
+
+    describe "composing with other matchers" do
+      it 'passes when the matcher matches the thrown arg' do
+        expect {
+          throw :foo, "bar"
+        }.to throw_symbol(:foo, a_string_matching(/bar/))
+      end
+
+      it 'fails when the matcher does not match the thrown arg' do
+        expect {
+          expect { throw :foo, "bar" }.to throw_symbol(:foo, a_string_matching(/foo/))
+        }.to fail_with('expected :foo with a string matching /foo/ to be thrown, got :foo with "bar"')
+      end
+
+      it 'provides a description' do
+        description = throw_symbol(:foo, a_string_matching(/bar/)).description
+        expect(description).to eq("throw :foo with a string matching /bar/")
+      end
+    end
   end
 end

data/spec/rspec/matchers/{yield_spec.rb → built_in/yield_spec.rb}

@@ -362,6 +362,31 @@ describe "yield_with_args matcher" do
     end
   end
 
+  describe "expect {...}.to yield_with_args(matcher, matcher)" do
+    it 'passes when the matchers match the args' do
+      expect { |b|
+        _yield_with_args(1.1, "food", &b)
+      }.to yield_with_args(a_value_within(0.2).of(1), a_string_matching(/foo/))
+    end
+
+    it 'provides a description' do
+      description = yield_with_args(a_value_within(0.2).of(1), a_string_matching(/foo/)).description
+      expect(description).to eq("yield with args(a value within 0.2 of 1, a string matching /foo/)")
+    end
+
+    it 'fails with a useful error message when the matchers do not match the args' do
+      expect {
+        expect { |b|
+          _yield_with_args(2.1, "food", &b)
+        }.to yield_with_args(a_value_within(0.2).of(1), a_string_matching(/foo/))
+      }.to fail_with(dedent <<-EOS)
+        |expected given block to yield with arguments, but yielded with unexpected arguments
+        |expected: [(a value within 0.2 of 1), (a string matching /foo/)]
+        |     got: [2.1, "food"]
+      EOS
+    end
+  end
+
   describe "expect {...}.not_to yield_with_args(3, 17)" do
     it 'passes if the block yields with different arguments' do
       expect { |b| _yield_with_args("a", "b", &b) }.not_to yield_with_args("a", "c")
@@ -374,6 +399,26 @@ describe "yield_with_args matcher" do
     end
   end
 
+  describe "expect {...}.not_to yield_with_args(matcher, matcher)" do
+    it 'passes when the matchers do not match the args' do
+      expect { |b|
+        _yield_with_args(2.1, "food", &b)
+      }.not_to yield_with_args(a_value_within(0.2).of(1), a_string_matching(/foo/))
+    end
+
+    it 'fails with a useful error message when the matchers do not match the args' do
+      expect {
+        expect { |b|
+          _yield_with_args(1.1, "food", &b)
+        }.not_to yield_with_args(a_value_within(0.2).of(1), a_string_matching(/foo/))
+      }.to fail_with(dedent <<-EOS)
+        |expected given block not to yield with arguments, but yielded with expected arguments
+        |expected not: [(a value within 0.2 of 1), (a string matching /foo/)]
+        |         got: [1.1, "food"]
+      EOS
+    end
+  end
+
   describe "expect {...}.to yield_with_args( false )" do
     it 'passes if the block yields with the given arguments' do
       expect { |b| _yield_with_args(false, &b) }.to yield_with_args(false)
@@ -486,6 +531,31 @@ describe "yield_successive_args matcher" do
     end
   end
 
+  describe "expect {...}.to yield_successive_args(matcher, matcher)" do
+    it 'passes when the successively yielded args match the matchers' do
+      expect { |b|
+        %w[ food barn ].each(&b)
+      }.to yield_successive_args(a_string_matching(/foo/), a_string_matching(/bar/))
+    end
+
+    it 'fails when the successively yielded args do not match the matchers' do
+      expect {
+        expect { |b|
+          %w[ barn food ].each(&b)
+        }.to yield_successive_args(a_string_matching(/foo/), a_string_matching(/bar/))
+      }.to fail_with(dedent <<-EOS)
+        |expected given block to yield successively with arguments, but yielded with unexpected arguments
+        |expected: [(a string matching /foo/), (a string matching /bar/)]
+        |     got: ["barn", "food"]
+      EOS
+    end
+
+    it 'provides a description' do
+      description = yield_successive_args(a_string_matching(/foo/), a_string_matching(/bar/)).description
+      expect(description).to eq("yield successive args(a string matching /foo/, a string matching /bar/)")
+    end
+  end
+
   describe "expect {...}.not_to yield_successive_args(1, 2, 3)" do
     it 'passes when the block does not yield' do
       expect { |b| _dont_yield(&b) }.not_to yield_successive_args(1, 2, 3)
@@ -518,6 +588,26 @@ describe "yield_successive_args matcher" do
     end
   end
 
+  describe "expect {...}.not_to yield_successive_args(matcher, matcher)" do
+    it 'passes when the successively yielded args match the matchers' do
+      expect { |b|
+        %w[ barn food ].each(&b)
+      }.not_to yield_successive_args(a_string_matching(/foo/), a_string_matching(/bar/))
+    end
+
+    it 'fails when the successively yielded args do not match the matchers' do
+      expect {
+        expect { |b|
+          %w[ food barn ].each(&b)
+        }.not_to yield_successive_args(a_string_matching(/foo/), a_string_matching(/bar/))
+      }.to fail_with(dedent <<-EOS)
+        |expected given block not to yield successively with arguments, but yielded with expected arguments
+        |expected not: [(a string matching /foo/), (a string matching /bar/)]
+        |         got: ["food", "barn"]
+      EOS
+    end
+  end
+
   describe "expect {...}.to yield_successive_args(String, Fixnum)" do
     it "passes if the block successively yields objects of the given types" do
       expect { |b| ["string", 15].each(&b) }.to yield_successive_args(String, Fixnum)

data/spec/rspec/matchers/configuration_spec.rb

@@ -87,9 +87,11 @@ module RSpec
 
         it 'is a no-op when configured to :should twice' do
           configure_syntax :should
-          Expectations::Syntax.default_should_host.should_not_receive(:method_added)
+          method_added_count = 0
+          allow(Expectations::Syntax.default_should_host).to receive(:method_added) { method_added_count += 1 }
           configure_syntax :should
-          RSpec::Mocks.verify # because configure_syntax is called again in an after hook
+
+          method_added_count.should eq(0)
         end
 
         it 'can limit the syntax to :expect' do
@@ -102,7 +104,7 @@ module RSpec
         end
 
         it 'is a no-op when configured to :expect twice' do
-          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
+          allow(RSpec::Matchers).to receive(:method_added).and_raise("no methods should be added here")
 
           configure_syntax :expect
           configure_syntax :expect
@@ -128,7 +130,7 @@ module RSpec
 
           it "does not warn when only the should syntax is explicitly configured" do
             configure_syntax(:should)
-            RSpec.should_not_receive(:deprecate)
+            RSpec.should_not receive(:deprecate)
             3.should eq(3)
           end
 
@@ -158,40 +160,6 @@ module RSpec
           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
-
-          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
-          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 { allow(RSpec).to receive(:deprecate) }
-
-          it 'allows `expect {}.should` to be used' do
-            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
-            configure_syntax [:should, :expect]
-
-            expect(RSpec).to receive(:deprecate)
-            expect { raise "boom" }.should raise_error("boom")
-
-            expect(RSpec).to receive(:deprecate)
-            expect { }.should_not raise_error
-          end
-        end
       end
 
       def configure_default_syntax
@@ -237,7 +205,7 @@ module RSpec
         # config setting, which makes it hard to get at the original
         # default value. in spec_helper.rb we store the default value
         # in $default_expectation_syntax so we can use it here.
-        expect($default_expectation_syntax).to match_array([:expect, :should])
+        expect($default_expectation_syntax).to contain_exactly(:expect, :should)
       end
     end
   end

data/spec/rspec/matchers/description_generation_spec.rb

@@ -45,9 +45,25 @@ describe "Matchers should be able to generate their own descriptions" do
     expect(RSpec::Matchers.generated_description).to eq "should be > 3"
   end
 
+  it "expect(...).to be between min and max" do
+    expect(10).to be_between(0, 10)
+    expect(RSpec::Matchers.generated_description).to eq "should be between 0 and 10 (inclusive)"
+  end
+
+  it "expect(...).to be exclusively between min and max" do
+    expect(9).to be_between(0, 10).exclusive
+    expect(RSpec::Matchers.generated_description).to eq "should be between 0 and 10 (exclusive)"
+  end
+
   it "expect(...).to be predicate arg1, arg2 and arg3" do
-    expect(5.0).to be_between(0,10)
-    expect(RSpec::Matchers.generated_description).to eq "should be between 0 and 10"
+    class Parent; end
+    class Child < Parent
+      def child_of?(*parents)
+        parents.all? { |parent| self.is_a?(parent) }
+      end
+    end
+    expect(Child.new).to be_a_child_of(Parent, Object)
+    expect(RSpec::Matchers.generated_description).to eq "should be a child of Parent and Object"
   end
 
   it "expect(...).to equal" do
@@ -106,13 +122,13 @@ describe "Matchers should be able to generate their own descriptions" do
   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 => "")
+                     :failure_message => "")
     expect([matcher]).to include(matcher)
-    expect(RSpec::Matchers.generated_description).to eq "should include description"
+    expect(RSpec::Matchers.generated_description).to eq "should include (description)"
   end
 
-  it "expect(array).to match_array [1,2,3]" do
-    expect([1,2,3]).to match_array [1,2,3]
+  it "expect(array).to contain_exactly(1, 2, 3)" do
+    expect([1,2,3]).to contain_exactly(1, 2, 3)
     expect(RSpec::Matchers.generated_description).to eq "should contain exactly 1, 2 and 3"
   end