rspec-expectations 2.13.0 → 2.99.0

data/spec/rspec/matchers/be_spec.rb

@@ -2,24 +2,24 @@ require 'spec_helper'
 
 describe "expect(...).to be_predicate" do
   it "passes when actual returns true for :predicate?" do
-    actual = stub("actual", :happy? => true)
+    actual = double("actual", :happy? => true)
     expect(actual).to be_happy
   end
 
   it "passes when actual returns true for :predicates? (present tense)" do
-    actual = stub("actual", :exists? => true, :exist? => true)
+    actual = double("actual", :exists? => true, :exist? => true)
     expect(actual).to be_exist
   end
 
   it "fails when actual returns false for :predicate?" do
-    actual = stub("actual", :happy? => false)
+    actual = double("actual", :happy? => false)
     expect {
       expect(actual).to be_happy
     }.to fail_with("expected happy? to return true, got false")
   end
 
   it "fails when actual returns false for :predicate?" do
-    actual = stub("actual", :happy? => nil)
+    actual = double("actual", :happy? => nil)
     expect {
       expect(actual).to be_happy
     }.to fail_with("expected happy? to return true, got nil")
@@ -31,8 +31,24 @@ describe "expect(...).to be_predicate" do
     }.to raise_error(NameError, /happy\?/)
   end
 
+  it 'warns of deprecation when :predicate? is private' do
+    privately_happy = Class.new do
+      private
+        def happy?
+          true
+        end
+    end
+    allow(RSpec).to receive(:deprecate)
+    expect(RSpec).to receive(:deprecate).with(
+      "matching with be_happy on private method happy?",
+      :replacement => "`expect(object.send(:happy?)).to be_true` or change the method's visibility to public",
+      :call_site => RSpec::Mocks::ArgumentMatchers::RegexpMatcher.new(/#{__FILE__}:#{__LINE__ + 2}/)
+    )
+    expect(privately_happy.new).to be_happy
+  end
+
   it "fails on error other than NameError" do
-    actual = stub("actual")
+    actual = double("actual")
     actual.should_receive(:foo?).and_raise("aaaah")
     expect {
       expect(actual).to be_foo
@@ -46,21 +62,47 @@ describe "expect(...).to be_predicate" do
       expect(actual).to be_foo
     }.to raise_error(/aaaah/)
   end
+
+  it "does not support operator chaining like a basic `be` matcher does" do
+    matcher = be_happy
+    value = double(:happy? => false)
+    expect(matcher == value).to be false
+  end
+
+  it 'warns of deprecation when actual does not respond to :predicate?' do
+    oddly_happy_class = Class.new do
+      def method_missing(method)
+        return true if method == :happy?
+      end
+    end
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /Matching with be_happy on an object that doesn't respond to `happy\?`/)
+    expect(oddly_happy_class.new).to be_happy
+  end
+
+  it 'does not warn of deprecation when actual responds to present tense predicate' do
+    present_happy_class = Class.new do
+      def exists?
+        true
+      end
+    end
+    expect_no_deprecation
+    expect(present_happy_class.new).to be_exist
+  end
 end
 
 describe "expect(...).not_to be_predicate" do
   it "passes when actual returns false for :sym?" do
-    actual = stub("actual", :happy? => false)
+    actual = double("actual", :happy? => false)
     expect(actual).not_to be_happy
   end
 
   it "passes when actual returns nil for :sym?" do
-    actual = stub("actual", :happy? => nil)
+    actual = double("actual", :happy? => nil)
     expect(actual).not_to be_happy
   end
 
   it "fails when actual returns true for :sym?" do
-    actual = stub("actual", :happy? => true)
+    actual = double("actual", :happy? => true)
     expect {
       expect(actual).not_to be_happy
     }.to fail_with("expected happy? to return false, got true")
@@ -75,13 +117,13 @@ end
 
 describe "expect(...).to be_predicate(*args)" do
   it "passes when actual returns true for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_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 = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(false)
     expect {
       expect(actual).to be_older_than(3)
@@ -97,13 +139,13 @@ end
 
 describe "expect(...).not_to be_predicate(*args)" do
   it "passes when actual returns false for :predicate?(*args)" do
-    actual = mock("actual")
+    actual = double("actual")
     actual.should_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 = mock("actual")
+    actual = double("actual")
     actual.should_receive(:older_than?).with(3).and_return(true)
     expect {
       expect(actual).not_to be_older_than(3)
@@ -119,16 +161,16 @@ end
 
 describe "expect(...).to be_predicate(&block)" do
   it "passes when actual returns true for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_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 = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(false)
     expect {
@@ -137,7 +179,7 @@ describe "expect(...).to be_predicate(&block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_happy => true)
+    delegate = double("delegate", :check_happy => true)
     expect {
       expect(Object.new).to be_happy { delegate.check_happy }
     }.to raise_error(NameError)
@@ -146,16 +188,16 @@ end
 
 describe "expect(...).not_to be_predicate(&block)" do
   it "passes when actual returns false for :predicate?(&block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_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 = mock("actual")
-    delegate = mock("delegate")
+    actual = double("actual")
+    delegate = double("delegate")
     actual.should_receive(:happy?).and_yield
     delegate.should_receive(:check_happy).and_return(true)
     expect {
@@ -164,7 +206,7 @@ describe "expect(...).not_to be_predicate(&block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_happy => true)
+    delegate = double("delegate", :check_happy => true)
     expect {
       expect(Object.new).not_to be_happy { delegate.check_happy }
     }.to raise_error(NameError)
@@ -173,16 +215,16 @@ end
 
 describe "expect(...).to be_predicate(*args, &block)" do
   it "passes when actual returns true for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    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 be_older_than(3) { |age| delegate.check_older_than(age) }
   end
 
   it "fails when actual returns false for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    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 {
@@ -191,7 +233,7 @@ describe "expect(...).to be_predicate(*args, &block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_older_than => true)
+    delegate = double("delegate", :check_older_than => true)
     expect {
       expect(Object.new).to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to raise_error(NameError)
@@ -200,16 +242,16 @@ end
 
 describe "expect(...).not_to be_predicate(*args, &block)" do
   it "passes when actual returns false for :predicate?(*args, &block)" do
-    actual = mock("actual")
-    delegate = mock("delegate")
+    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).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 = mock("actual")
-    delegate = mock("delegate")
+    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 {
@@ -218,42 +260,101 @@ describe "expect(...).not_to be_predicate(*args, &block)" do
   end
 
   it "fails when actual does not respond to :predicate?" do
-    delegate = mock("delegate", :check_older_than => true)
+    delegate = double("delegate", :check_older_than => true)
     expect {
       expect(Object.new).not_to be_older_than(3) { |age| delegate.check_older_than(age) }
     }.to raise_error(NameError)
   end
 end
 
-describe "expect(...).to be_true" do
+describe "expect(...).to be_truthy" do
   it "passes when actual equal?(true)" do
-    expect(true).to be_true
+    expect(true).to be_truthy
   end
 
   it "passes when actual is 1" do
-    expect(1).to be_true
+    expect(1).to be_truthy
   end
 
   it "fails when actual equal?(false)" do
     expect {
-      expect(false).to be_true
-    }.to fail_with("expected: true value\n     got: false")
+      expect(false).to be_truthy
+    }.to fail_with("expected: truthy value\n     got: false")
   end
 end
 
 describe "expect(...).to be_false" do
-  it "passes when actual equal?(false)" do
+  it "is deprecated" do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_false/)
+    expect(false).to be_false
+  end
+
+  it "has the correct call site in the deprecation message" do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+    expect(false).to be_false
+  end
+
+  it "still passes" do
+    allow(RSpec).to receive(:deprecate)
     expect(false).to be_false
   end
 
+  it "still fails" do
+    allow(RSpec).to receive(:deprecate)
+    expect {
+      expect(true).to be_false
+    }.to fail_with(/expected: falsey value/)
+  end
+end
+
+describe "expect(...).to be_true" do
+  it "is deprecated" do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /be_true/)
+    expect(true).to be_true
+  end
+
+  it "still passes" do
+    allow(RSpec).to receive(:deprecate)
+    expect(true).to be_true
+  end
+
+  it "still fails" do
+    allow(RSpec).to receive(:deprecate)
+    expect {
+      expect(false).to be_true
+    }.to fail_with(/expected: truthy value/)
+  end
+end
+
+describe "expect(...).to be_falsey" do
+  it "passes when actual equal?(false)" do
+    expect(false).to be_falsey
+  end
+
   it "passes when actual equal?(nil)" do
-    expect(nil).to be_false
+    expect(nil).to be_falsey
   end
 
   it "fails when actual equal?(true)" do
     expect {
-      expect(true).to be_false
-    }.to fail_with("expected: false value\n     got: true")
+      expect(true).to be_falsey
+    }.to fail_with("expected: falsey value\n     got: true")
+  end
+end
+
+describe "expect(...).to be_falsy" do
+  it "passes when actual equal?(false)" do
+    expect(false).to be_falsy
+  end
+
+  it "passes when actual equal?(nil)" do
+    expect(nil).to be_falsy
+  end
+
+  it "fails when actual equal?(true)" do
+    expect {
+      expect(true).to be_falsy
+    }.to fail_with("expected: falsey value\n     got: true")
   end
 end
 
@@ -465,10 +566,10 @@ end
 
 describe "'expect(...).to be' with operator" do
   it "includes 'be' in the description" do
-    expect((be > 6).description).to match /be > 6/
-    expect((be >= 6).description).to match /be >= 6/
-    expect((be <= 6).description).to match /be <= 6/
-    expect((be < 6).description).to match /be < 6/
+    expect((be > 6).description).to match(/be > 6/)
+    expect((be >= 6).description).to match(/be >= 6/)
+    expect((be <= 6).description).to match(/be <= 6/)
+    expect((be < 6).description).to match(/be < 6/)
   end
 end
 

data/spec/rspec/matchers/be_within_spec.rb

@@ -27,6 +27,14 @@ module RSpec
         expect(5.5).to be_within(0.5).of(5.0)
       end
 
+      it "passes with integer arguments that are near each other" do
+        expect(1.0001).to be_within(5).percent_of(1)
+      end
+
+      it "passes with negative arguments" do
+        expect(-1.0001).to be_within(5).percent_of(-1)
+      end
+
       it "fails when actual < (expected - delta)" do
         expect {
           expect(4.49).to be_within(0.5).of(5.0)

data/spec/rspec/matchers/change_spec.rb

@@ -28,6 +28,20 @@ describe "expect { ... }.to change(actual, message)" do
     end
   end
 
+  it "can specify the change of a variable's class" do
+    val = nil
+
+    expect {
+      val = 42
+    }.to change { val.class }.from(NilClass).to(Fixnum)
+
+    expect {
+      expect {
+        val = "string"
+      }.to change { val.class }.from(Fixnum).to(NilClass)
+    }.to fail_with(/but is now String/)
+  end
+
   context "with boolean values" do
     before(:each) do
       @instance = SomethingExpected.new
@@ -72,6 +86,17 @@ describe "expect { ... }.to change(actual, message)" do
       expect {@instance.some_value << 1}.to change(@instance, :some_value)
     end
 
+    it "fails when a predicate on the actual fails" do
+      expect do
+        expect {@instance.some_value << 1}.to change { @instance.some_value }.to be_empty
+      end.to fail_with(/result should have been changed to/)
+    end
+
+    it "passes when a predicate on the actual passes" do
+      @instance.some_value = [1]
+      expect {@instance.some_value.pop}.to change { @instance.some_value }.to be_empty
+    end
+
     it "fails when actual is not modified by the block" do
       expect do
         expect {}.to change(@instance, :some_value)
@@ -156,19 +181,20 @@ describe "expect { ... }.not_to change(actual, message)" do
   end
 
   it "passes when actual is not modified by the block" do
-    expect { }.to_not change(@instance, :some_value)
+    expect { }.not_to change(@instance, :some_value)
   end
 
   it "fails when actual is not modified by the block" do
     expect do
-      expect {@instance.some_value = 6}.to_not change(@instance, :some_value)
+      expect {@instance.some_value = 6}.not_to change(@instance, :some_value)
     end.to fail_with("some_value should not have changed, but did change from 5 to 6")
   end
 end
 
 describe "expect { ... }.to change { block }" do
   o = SomethingExpected.new
-  it_behaves_like "an RSpec matcher", :valid_value => lambda { o.some_value = 5 },
+  o.some_value = 1
+  it_behaves_like "an RSpec matcher", :valid_value => lambda { o.some_value += 1 },
                                       :invalid_value => lambda { } do
     let(:matcher) { change { o.some_value } }
   end
@@ -206,22 +232,96 @@ describe "expect { ... }.not_to change { block }" do
   end
 
   it "passes when actual is modified by the block" do
-    expect {}.to_not change{ @instance.some_value }
+    expect {}.not_to change{ @instance.some_value }
   end
 
   it "fails when actual is not modified by the block" do
     expect do
-      expect {@instance.some_value = 6}.to_not change { @instance.some_value }
+      expect {@instance.some_value = 6}.not_to change { @instance.some_value }
     end.to fail_with("result should not have changed, but did change from 5 to 6")
   end
 
   it "warns if passed a block using do/end instead of {}" do
     expect do
-      expect {}.to_not change do; end
+      expect {}.not_to change do; end
     end.to raise_error(SyntaxError, /block passed to should or should_not/)
   end
 end
 
+describe "expect { ... }.not_to change { }.from" do
+  context 'when the value starts at the from value' do
+    it 'passes when the value does not change' do
+      k = 5
+      expect { }.not_to change { k }.from(5)
+    end
+
+    it 'fails when the value does change' do
+      expect {
+        k = 5
+        expect { k += 1 }.not_to change { k }.from(5)
+      }.to fail_with(/but did change from 5 to 6/)
+    end
+
+    it 'does not issue a deprecation warning' do
+      expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+      k = 5
+      expect { }.not_to change { k }.from(5)
+    end
+  end
+
+  context 'when the value starts at a different value' do
+    before { allow_deprecation }
+
+    it 'passes when the value does not change' do
+      k = 6
+      expect { }.not_to change { k }.from(5)
+    end
+
+    it 'passes when the value does change' do
+      k = 6
+      expect { k += 1 }.not_to change { k }.from(5)
+    end
+
+    it 'issues a deprecation warning' do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /#{Regexp.escape("expect { }.not_to change { }.from()")}/)
+      k = 6
+      expect { }.not_to change { k }.from(5)
+    end
+  end
+end
+
+describe "expect { ... }.not_to change { }.to" do
+  it 'issues a deprecation warning' do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /#{Regexp.escape("expect { }.not_to change { }.to()")}/)
+    expect {
+    }.not_to change { }.to(3)
+  end
+end
+
+describe "expect { ... }.not_to change { }.by" do
+  it 'issues a deprecation warning' do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /#{Regexp.escape("expect { }.not_to change { }.by()")}/)
+    expect {
+    }.not_to change { }.by(3)
+  end
+end
+
+describe "expect { ... }.not_to change { }.by_at_least" do
+  it 'issues a deprecation warning' do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /#{Regexp.escape("expect { }.not_to change { }.by_at_least()")}/)
+    expect {
+    }.not_to change { }.by_at_least(3)
+  end
+end
+
+describe "expect { ... }.not_to change { }.by_at_most" do
+  it 'issues a deprecation warning' do
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /#{Regexp.escape("expect { }.not_to change { }.by_at_most()")}/)
+    expect {
+    }.not_to change { }.by_at_most(3)
+  end
+end
+
 describe "expect { ... }.to change(actual, message).by(expected)" do
   before(:each) do
     @instance = SomethingExpected.new
@@ -537,6 +637,6 @@ describe RSpec::Matchers::BuiltIn::Change do
 
     expect {
       expect { @instance.some_value = "cat" }.to change(@instance, :some_value)
-    }.to_not raise_error
+    }.not_to raise_error
   end
 end

data/spec/rspec/matchers/description_generation_spec.rb

@@ -25,14 +25,14 @@ describe "Matchers should be able to generate their own descriptions" do
     expect(RSpec::Matchers.generated_description).to eq "should not be empty"
   end
 
-  it "expect(...).to be true" do
-    expect(true).to be_true
-    expect(RSpec::Matchers.generated_description).to eq "should be true"
+  it "expect(...).to be truthy" do
+    expect(true).to be_truthy
+    expect(RSpec::Matchers.generated_description).to eq "should be truthy"
   end
 
-  it "expect(...).to be false" do
-    expect(false).to be_false
-    expect(RSpec::Matchers.generated_description).to eq "should be false"
+  it "expect(...).to be falsey" do
+    expect(false).to be_falsey
+    expect(RSpec::Matchers.generated_description).to eq "should be falsey"
   end
 
   it "expect(...).to be nil" do
@@ -92,29 +92,47 @@ describe "Matchers should be able to generate their own descriptions" do
     expect(RSpec::Matchers.generated_description).to eq 'should have taste for "wine", "cheese"'
   end
 
-  it "expect(...).to have n items" do
-    expect(team).to have(3).players
-    expect(RSpec::Matchers.generated_description).to eq "should have 3 players"
-  end
+  context "the deprecated collection cardinality matchers" do
+    before { allow_deprecation }
 
-  it "expect(...).to have at least n items" do
-    expect(team).to have_at_least(2).players
-    expect(RSpec::Matchers.generated_description).to eq "should have at least 2 players"
-  end
+    it "expect(...).to have n items" do
+      expect(team).to have(3).players
+      expect(RSpec::Matchers.generated_description).to eq "should have 3 players"
+    end
 
-  it "expect(...).to have at most n items" do
-    expect(team).to have_at_most(4).players
-    expect(RSpec::Matchers.generated_description).to eq "should have at most 4 players"
+    it "expect(...).to have at least n items" do
+      expect(team).to have_at_least(2).players
+      expect(RSpec::Matchers.generated_description).to eq "should have at least 2 players"
+    end
+
+    it "expect(...).to have at most n items" do
+      expect(team).to have_at_most(4).players
+      expect(RSpec::Matchers.generated_description).to eq "should have at most 4 players"
+    end
   end
 
-  it "expect(...).to include" do
+  it "expect(...).to include(x)" do
     expect([1,2,3]).to include(3)
     expect(RSpec::Matchers.generated_description).to eq "should include 3"
   end
 
+  it "expect(...).to include(x) when x responds to description but is not a matcher" do
+    obj = double(:description => "description", :inspect => "inspect")
+    expect([obj]).to include(obj)
+    expect(RSpec::Matchers.generated_description).to eq "should include inspect"
+  end
+
+  it "expect(...).to include(x) when x responds to description and is a matcher" do
+    matcher = double(:description                => "description",
+                     :matches?                   => true,
+                     :failure_message_for_should => "")
+    expect([matcher]).to include(matcher)
+    expect(RSpec::Matchers.generated_description).to eq "should include description"
+  end
+
   it "expect(array).not_to match_array [1,2,3]" do
     expect([1,2,3]).to match_array [1,2,3]
-    expect(RSpec::Matchers.generated_description).to eq "should contain exactly 1, 2 and 3"
+    expect(RSpec::Matchers.generated_description).to eq "should contain exactly 1, 2, and 3"
   end
 
   it "expect(...).to match" do
@@ -171,6 +189,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/differentiate_block_method_types_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module RSpec
+  module Matchers
+    describe DifferentiateBlockMethodTypes do
+      let(:differentiator) do
+        DifferentiateBlockMethodTypes.new do
+          def some_instance_method_1; end
+          def self.some_singleton_method_1; end
+          define_method(:some_instance_method_2) { }
+
+          if RUBY_VERSION.to_f > 1.8
+            define_singleton_method(:some_singleton_method_2) { }
+          else
+            def self.some_singleton_method_2; end
+          end
+        end
+      end
+
+      it 'differentiates singleton method defs from instance method defs' do
+        expect(differentiator.instance_methods).to eq([:some_instance_method_1, :some_instance_method_2])
+        expect(differentiator.singleton_methods).to eq([:some_singleton_method_1, :some_singleton_method_2])
+      end
+
+      it 'passes the given args through to the block' do
+        expect { |b|
+          DifferentiateBlockMethodTypes.new(1, 2, &b)
+        }.to yield_with_args(1, 2)
+      end
+
+      it 'ignores unrecognized DSL methods called in the block' do
+        expect {
+          DifferentiateBlockMethodTypes.new { foo.bar; some_dsl { nested } }
+        }.not_to raise_error
+      end
+    end
+  end
+end
+