rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

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

@@ -39,7 +39,28 @@ module RSpec::Matchers::BuiltIn
 
     end
 
-    describe "#==" do
+    describe "#failure_message" do
+      context "when the parameter to .new is omitted" do
+        it "describes what was expected" do
+          matcher_class = Class.new(BaseMatcher) do
+            def name=(name)
+              @name = name
+            end
+
+            def match(expected, actual)
+              false
+            end
+          end
+
+          matcher = matcher_class.new
+          matcher.name = "be something"
+          matcher.matches?("foo")
+          expect(matcher.failure_message).to eq('expected "foo" to be something')
+        end
+      end
+    end
+
+    describe "#===" do
       it "responds the same way as matches?" do
         matcher = Class.new(BaseMatcher) do
           def initialize(expected)
@@ -52,10 +73,10 @@ module RSpec::Matchers::BuiltIn
         end
 
         expect(matcher.new(3).matches?(3)).to be_truthy
-        expect(matcher.new(3)).to eq(3)
+        expect(matcher.new(3)).to be === 3
 
         expect(matcher.new(3).matches?(4)).to be_falsey
-        expect(matcher.new(3)).not_to eq(4)
+        expect(matcher.new(3)).not_to be === 4
       end
     end
   end

data/spec/rspec/matchers/built_in/be_between_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+module RSpec::Matchers::BuiltIn
+  describe BeBetween do
+    class SizeMatters
+      include Comparable
+      attr :str
+      def <=>(other)
+        str.size <=> other.str.size
+      end
+      def initialize(str)
+        @str = str
+      end
+      def inspect
+        @str
+      end
+    end
+
+    shared_examples_for "be_between" do |mode|
+      it "passes if target is between min and max" do
+        expect(5).to matcher(1, 10)
+      end
+
+      it "fails if target is not between min and max" do
+        expect {
+          # It does not go to 11
+          expect(11).to matcher(1, 10)
+        }.to fail_with("expected 11 to be between 1 and 10 (#{mode})")
+      end
+
+      it "works with strings" do
+        expect("baz").to matcher("bar", "foo")
+
+        expect {
+          expect("foo").to matcher("bar", "baz")
+        }.to fail_with("expected \"foo\" to be between \"bar\" and \"baz\" (#{mode})")
+      end
+
+      it "works with other Comparable objects" do
+        expect(SizeMatters.new("--")).to matcher(SizeMatters.new("-"), SizeMatters.new("---"))
+
+        expect {
+          expect(SizeMatters.new("---")).to matcher(SizeMatters.new("-"), SizeMatters.new("--"))
+        }.to fail_with("expected --- to be between - and -- (#{mode})")
+      end
+    end
+
+    shared_examples_for "not_to be_between" do |mode|
+      it "passes if target is not between min and max" do
+        expect(11).not_to matcher(1, 10)
+      end
+
+      it "fails if target is between min and max" do
+        expect {
+          expect(5).not_to matcher(1, 10)
+        }.to fail_with("expected 5 not to be between 1 and 10 (#{mode})")
+      end
+    end
+
+    shared_examples_for "composing with other matchers" do |mode|
+      it "passes when the matchers both match" do
+        expect([nil, 3]).to include(matcher(2, 4), a_nil_value)
+      end
+
+      it "works with mixed types" do
+        expect(["baz", Math::PI]).to include(matcher(3.1, 3.2), matcher("bar", "foo"))
+
+        expect {
+          expect(["baz", 2.14]).to include(matcher(3.1, 3.2), matcher("bar", "foo") )
+        }.to fail_with("expected [\"baz\", 2.14] to include (a value between 3.1 and 3.2 (#{mode})) and (a value between \"bar\" and \"foo\" (#{mode}))")
+      end
+
+      it "provides a description" do
+        description = include(matcher(2, 4), an_instance_of(Float)).description
+        expect(description).to eq("include (a value between 2 and 4 (#{mode})) and (an instance of Float)")
+      end
+
+      it "fails with a clear error message when the matchers do not match" do
+        expect {
+          expect([nil, 1]).to include(matcher(2, 4), a_nil_value)
+        }.to fail_with("expected [nil, 1] to include (a value between 2 and 4 (#{mode})) and (a nil value)")
+      end
+    end
+
+    it_behaves_like "an RSpec matcher", :valid_value => (10), :invalid_value => (11) do
+      let(:matcher) { be_between(1, 10) }
+    end
+
+    describe "expect(...).to be_between(min, max) (inclusive)" do
+      it_behaves_like "be_between", :inclusive do
+        def matcher(min, max)
+          be_between(min, max)
+        end
+      end
+
+      it "is inclusive" do
+        expect(1).to be_between(1, 10)
+        expect(10).to be_between(1, 10)
+      end
+
+      it "indicates it was not comparable if it does not respond to `<=` and `>=`" do
+        expect {
+          expect(nil).to be_between(0, 10)
+        }.to fail_with("expected nil to be between 0 and 10 (inclusive), but it does not respond to `<=` and `>=`")
+      end
+    end
+
+    describe "expect(...).to be_between(min, max) (exclusive)" do
+      it_behaves_like "be_between", :exclusive do
+        def matcher(min, max)
+          be_between(min, max).exclusive
+        end
+      end
+
+      it "indicates it was not comparable if it does not respond to `<` and `>`" do
+        expect {
+          expect(nil).to be_between(0, 10).exclusive
+        }.to fail_with("expected nil to be between 0 and 10 (exclusive), but it does not respond to `<` and `>`")
+      end
+
+      it "is exclusive" do
+        expect { expect(1).to be_between(1, 10).exclusive }.to fail
+        expect { expect(10).to be_between(1, 10).exclusive }.to fail
+      end
+    end
+
+    describe "expect(...).not_to be_between(min, max) (inclusive)" do
+      it_behaves_like "not_to be_between", :inclusive do
+        def matcher(min, max)
+          be_between(min, max)
+        end
+      end
+    end
+
+    describe "expect(...).not_to be_between(min, max) (exclusive)" do
+      it_behaves_like "not_to be_between", :exclusive do
+        def matcher(min, max)
+          be_between(min, max).exclusive
+        end
+      end
+    end
+
+    describe "composing with other matchers (inclusive)" do
+      it_behaves_like "composing with other matchers", :inclusive do
+        def matcher(min, max)
+          a_value_between(min, max)
+        end
+      end
+    end
+
+    describe "composing with other matchers (exclusive)" do
+      it_behaves_like "composing with other matchers", :exclusive do
+        def matcher(min, max)
+          a_value_between(min, max).exclusive
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,23 @@ describe "expect(...).to be_predicate" do
     expect(actual).to be_happy
   end
 
+  it 'allows composable aliases to be defined' do
+    RSpec::Matchers.alias_matcher :a_user_who_is_happy, :be_happy
+    actual = double("actual", :happy? => true)
+    expect(actual).to a_user_who_is_happy
+    expect(a_user_who_is_happy.description).to eq("a user who is happy")
+
+    RSpec::Matchers.alias_matcher :a_user_who_is_an_admin, :be_an_admin
+    actual = double("actual", :admin? => true)
+    expect(actual).to a_user_who_is_an_admin
+    expect(a_user_who_is_an_admin.description).to eq("a user who is an admin")
+
+    RSpec::Matchers.alias_matcher :an_animal_that_is_a_canine, :be_a_canine
+    actual = double("actual", :canine? => true)
+    expect(actual).to an_animal_that_is_a_canine
+    expect(an_animal_that_is_a_canine.description).to eq("an animal that is a canine")
+  end
+
   it "passes when actual returns true for :predicates? (present tense)" do
     actual = double("actual", :exists? => true, :exist? => true)
     expect(actual).to be_exist
@@ -43,7 +60,7 @@ describe "expect(...).to be_predicate" do
 
   it "fails on error other than NameError" do
     actual = double("actual")
-    actual.should_receive(:foo?).and_raise("aaaah")
+    expect(actual).to receive(:foo?).and_raise("aaaah")
     expect {
       expect(actual).to be_foo
     }.to raise_error(/aaaah/)
@@ -51,7 +68,7 @@ describe "expect(...).to be_predicate" do
 
   it "fails on error other than NameError (with the present tense predicate)" do
     actual = Object.new
-    actual.should_receive(:foos?).and_raise("aaaah")
+    expect(actual).to receive(:foos?).and_raise("aaaah")
     expect {
       expect(actual).to be_foo
     }.to raise_error(/aaaah/)
@@ -92,13 +109,13 @@ end
 describe "expect(...).to be_predicate(*args)" do
   it "passes when actual returns true for :predicate?(*args)" do
     actual = double("actual")
-    actual.should_receive(:older_than?).with(3).and_return(true)
+    expect(actual).to receive(:older_than?).with(3).and_return(true)
     expect(actual).to be_older_than(3)
   end
 
   it "fails when actual returns false for :predicate?(*args)" do
     actual = double("actual")
-    actual.should_receive(:older_than?).with(3).and_return(false)
+    expect(actual).to receive(:older_than?).with(3).and_return(false)
     expect {
       expect(actual).to be_older_than(3)
     }.to fail_with("expected older_than?(3) to return true, got false")
@@ -114,13 +131,13 @@ end
 describe "expect(...).not_to be_predicate(*args)" do
   it "passes when actual returns false for :predicate?(*args)" do
     actual = double("actual")
-    actual.should_receive(:older_than?).with(3).and_return(false)
+    expect(actual).to receive(:older_than?).with(3).and_return(false)
     expect(actual).not_to be_older_than(3)
   end
 
   it "fails when actual returns true for :predicate?(*args)" do
     actual = double("actual")
-    actual.should_receive(:older_than?).with(3).and_return(true)
+    expect(actual).to receive(:older_than?).with(3).and_return(true)
     expect {
       expect(actual).not_to be_older_than(3)
     }.to fail_with("expected older_than?(3) to return false, got true")
@@ -137,16 +154,16 @@ describe "expect(...).to be_predicate(&block)" do
   it "passes when actual returns true for :predicate?(&block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:happy?).and_yield
-    delegate.should_receive(:check_happy).and_return(true)
+    expect(actual).to receive(:happy?).and_yield
+    expect(delegate).to receive(:check_happy).and_return(true)
     expect(actual).to be_happy { delegate.check_happy }
   end
 
   it "fails when actual returns false for :predicate?(&block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:happy?).and_yield
-    delegate.should_receive(:check_happy).and_return(false)
+    expect(actual).to receive(:happy?).and_yield
+    expect(delegate).to receive(:check_happy).and_return(false)
     expect {
       expect(actual).to be_happy { delegate.check_happy }
     }.to fail_with("expected happy? to return true, got false")
@@ -164,16 +181,16 @@ describe "expect(...).not_to be_predicate(&block)" do
   it "passes when actual returns false for :predicate?(&block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:happy?).and_yield
-    delegate.should_receive(:check_happy).and_return(false)
+    expect(actual).to receive(:happy?).and_yield
+    expect(delegate).to receive(:check_happy).and_return(false)
     expect(actual).not_to be_happy { delegate.check_happy }
   end
 
   it "fails when actual returns true for :predicate?(&block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:happy?).and_yield
-    delegate.should_receive(:check_happy).and_return(true)
+    expect(actual).to receive(:happy?).and_yield
+    expect(delegate).to receive(:check_happy).and_return(true)
     expect {
       expect(actual).not_to be_happy { delegate.check_happy }
     }.to fail_with("expected happy? to return false, got true")
@@ -191,16 +208,16 @@ describe "expect(...).to be_predicate(*args, &block)" do
   it "passes when actual returns true for :predicate?(*args, &block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:older_than?).with(3).and_yield(3)
-    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    expect(actual).to receive(:older_than?).with(3).and_yield(3)
+    expect(delegate).to receive(:check_older_than).with(3).and_return(true)
     expect(actual).to be_older_than(3) { |age| delegate.check_older_than(age) }
   end
 
   it "fails when actual returns false for :predicate?(*args, &block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:older_than?).with(3).and_yield(3)
-    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    expect(actual).to receive(:older_than?).with(3).and_yield(3)
+    expect(delegate).to receive(:check_older_than).with(3).and_return(false)
     expect {
       expect(actual).to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to fail_with("expected older_than?(3) to return true, got false")
@@ -218,16 +235,16 @@ describe "expect(...).not_to be_predicate(*args, &block)" do
   it "passes when actual returns false for :predicate?(*args, &block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:older_than?).with(3).and_yield(3)
-    delegate.should_receive(:check_older_than).with(3).and_return(false)
+    expect(actual).to receive(:older_than?).with(3).and_yield(3)
+    expect(delegate).to receive(:check_older_than).with(3).and_return(false)
     expect(actual).not_to be_older_than(3) { |age| delegate.check_older_than(age) }
   end
 
   it "fails when actual returns true for :predicate?(*args, &block)" do
     actual = double("actual")
     delegate = double("delegate")
-    actual.should_receive(:older_than?).with(3).and_yield(3)
-    delegate.should_receive(:check_older_than).with(3).and_return(true)
+    expect(actual).to receive(:older_than?).with(3).and_yield(3)
+    expect(delegate).to receive(:check_older_than).with(3).and_return(true)
     expect {
       expect(actual).not_to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to fail_with("expected older_than?(3) to return false, got true")
@@ -327,6 +344,11 @@ describe "expect(...).to be <" do
   it "describes itself" do
     expect(be.<(4).description).to eq "be < 4"
   end
+
+  it 'does not lie and say that it is equal to a number' do
+    matcher = (be < 3)
+    expect(5 == matcher).to be false
+  end
 end
 
 describe "expect(...).to be <=" do
@@ -427,19 +449,41 @@ describe "expect(...).to be ===" do
   end
 end
 
-describe "expect(...).not_to with operators" do
-  it "coaches user to stop using operators with expect().not_to" do
+describe "expect(...).not_to with comparison operators" do
+  it "coaches user to stop using operators with expect().not_to with numerical comparison operators" do
     expect {
       expect(5).not_to be < 6
-    }.to raise_error(/`expect\(actual\).not_to be < 6` not only FAILED,\nit is a bit confusing./m)
+    }.to fail_with("`expect(5).not_to be < 6` not only FAILED, it is a bit confusing.")
+
+    expect {
+      expect(5).not_to be <= 6
+    }.to fail_with("`expect(5).not_to be <= 6` not only FAILED, it is a bit confusing.")
+
+    expect {
+      expect(6).not_to be > 5
+    }.to fail_with("`expect(6).not_to be > 5` not only FAILED, it is a bit confusing.")
+
+    expect {
+      expect(6).not_to be >= 5
+    }.to fail_with("`expect(6).not_to be >= 5` not only FAILED, it is a bit confusing.")
+  end
+
+  it "coaches users to stop using negation with string comparison operators" do
+    expect {
+      expect("foo").not_to be > "bar"
+    }.to fail_with('`expect("foo").not_to be > "bar"` not only FAILED, it is a bit confusing.')
   end
 end
 
-describe "should_not with operators", :uses_only_should do
-  it "coaches user to stop using operators with should_not" do
-    lambda {
-      5.should_not be < 6
-    }.should raise_error(/`actual.should_not be < 6` not only FAILED,\nit is a bit confusing./m)
+describe "expect(...).not_to with equality operators" do
+  it "raises normal error with expect().not_to with equality operators" do
+    expect {
+      expect(6).not_to be == 6
+    }.to fail_with("`expect(6).not_to be == 6`")
+
+    expect {
+      expect(String).not_to be === "Hello"
+    }.to fail_with('`expect(String).not_to be === "Hello"`')
   end
 end
 
@@ -482,7 +526,7 @@ end
 describe "expect(...).to be(value)" do
   it "delegates to equal" do
     matcher = equal(5)
-    self.should_receive(:equal).with(5).and_return(matcher)
+    expect(self).to receive(:equal).with(5).and_return(matcher)
     expect(5).to be(5)
   end
 end
@@ -490,7 +534,7 @@ end
 describe "expect(...).not_to be(value)" do
   it "delegates to equal" do
     matcher = equal(4)
-    self.should_receive(:equal).with(4).and_return(matcher)
+    expect(self).to receive(:equal).with(4).and_return(matcher)
     expect(5).not_to be(4)
   end
 end

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

@@ -63,10 +63,10 @@ module RSpec
         }.to raise_error(ArgumentError, /must set an expected value using #of/)
       end
 
-      it "raises an error if the actual does not respond to :-" do
+      it "fails if the actual is not numeric" do
         expect {
           expect(nil).to be_within(0.1).of(0)
-        }.to raise_error(ArgumentError, /The actual value \(nil\) must respond to `-`/)
+        }.to fail_with("expected nil to be within 0.1 of 0, but it could not be treated as a numeric value")
       end
     end
 
@@ -132,6 +132,10 @@ module RSpec
           expect(5.5).not_to be_within(0.5).of(5.0)
         }.to fail_with("expected 5.5 not to be within 0.5 of 5.0")
       end
+
+      it "passes if the actual is not numeric" do
+        expect(nil).not_to be_within(0.1).of(0)
+      end
     end
   end
 end