rspec-expectations 2.14.5 → 2.99.0

data/spec/rspec/expectations/syntax_spec.rb

@@ -91,8 +91,8 @@ module RSpec
 
         context "when only :expect is enabled" do
           before do
-            expect(Syntax.should_enabled?).to be_false
-            expect(Syntax.expect_enabled?).to be_true
+            expect(Syntax.should_enabled?).to be_falsey
+            expect(Syntax.expect_enabled?).to be_truthy
           end
 
           it 'generates a positive expression using the expect syntax' do
@@ -106,8 +106,8 @@ module RSpec
 
         context "when both :should and :expect are enabled", :uses_should do
           before do
-            expect(Syntax.should_enabled?).to be_true
-            expect(Syntax.expect_enabled?).to be_true
+            expect(Syntax.should_enabled?).to be_truthy
+            expect(Syntax.expect_enabled?).to be_truthy
           end
 
           it 'generates a positive expression using the expect syntax' do
@@ -121,8 +121,8 @@ module RSpec
 
         context "when only :should is enabled", :uses_only_should do
           before do
-            Syntax.should_enabled?.should be_true
-            Syntax.expect_enabled?.should be_false
+            Syntax.should_enabled?.should be_truthy
+            Syntax.expect_enabled?.should be_falsey
           end
 
           it 'generates a positive expression using the expect syntax' do

data/spec/rspec/expectations_spec.rb

@@ -1,5 +1,26 @@
+require 'spec_helper'
+
 module RSpec
   describe Expectations do
+    def file_contents_for(lib, filename)
+      # http://rubular.com/r/HYpUMftlG2
+      path = $LOAD_PATH.find { |p| p.match(/\/rspec-#{lib}(-[a-f0-9]+)?\/lib/) }
+      file = File.join(path, filename)
+      File.read(file)
+    end
+
+    it 'has an up-to-date caller_filter file' do
+      expectations = file_contents_for("expectations", "rspec/expectations/caller_filter.rb")
+      core         = file_contents_for("core",         "rspec/core/caller_filter.rb")
+
+      expect(expectations).to eq(core)
+    end
+
+    it 'prints a deprecation warning when the root file is loaded' do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /rspec-expectations/)
+      load "rspec-expectations.rb"
+    end
+
     describe '.method_handle_for(object, method_name)' do
 
       class UntamperedClass
@@ -36,7 +57,7 @@ module RSpec
         expect(Expectations.method_handle_for(object, :foo).call).to eq :bar
       end
 
-      it 'fetches method definitions for basic objects', :if => RUBY_VERSION.to_i >= 2 do
+      it 'fetches method definitions for basic objects', :if => (RUBY_VERSION.to_i >= 2 && RUBY_ENGINE != 'rbx') do
         object = BasicClass.new
         expect(Expectations.method_handle_for(object, :foo).call).to eq :bar
       end

data/spec/rspec/matchers/base_matcher_spec.rb

@@ -8,21 +8,21 @@ module RSpec::Matchers::BuiltIn
       end
 
       it "returns true if there are no errors" do
-        expect(matcher.match_unless_raises {}).to be_true
+        expect(matcher.match_unless_raises {}).to be_truthy
       end
 
       it "returns false if there is an error" do
-        expect(matcher.match_unless_raises { raise }).to be_false
+        expect(matcher.match_unless_raises { raise }).to be_falsey
       end
 
       it "returns false if the only submitted error is raised" do
-        expect(matcher.match_unless_raises(RuntimeError){ raise "foo" }).to be_false
+        expect(matcher.match_unless_raises(RuntimeError){ raise "foo" }).to be_falsey
       end
 
       it "returns false if any of several errors submitted is raised" do
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise "foo" }).to be_false
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise ArgumentError.new('') }).to be_false
-        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise NameError.new('') }).to be_false
+        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise "foo" }).to be_falsey
+        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise ArgumentError.new('') }).to be_falsey
+        expect(matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise NameError.new('') }).to be_falsey
       end
 
       it "re-raises any error other than one of those specified" do
@@ -60,24 +60,18 @@ module RSpec::Matchers::BuiltIn
       end
     end
 
-    describe "#==" do
-      it "responds the same way as matches?" do
-        matcher = Class.new(BaseMatcher) do
-          def initialize(expected)
-            @expected = expected
-          end
-
-          def matches?(actual)
-            (@actual = actual) == @expected
-          end
+    it_behaves_like "an RSpec matcher", :valid_value => 3, :invalid_value => 4 do
+      matcher_class = Class.new(BaseMatcher) do
+        def initialize(expected)
+          @expected = expected
         end
 
-        expect(matcher.new(3).matches?(3)).to be_true
-        expect(matcher.new(3)).to eq(3)
-
-        expect(matcher.new(3).matches?(4)).to be_false
-        expect(matcher.new(3)).not_to eq(4)
+        def matches?(actual)
+          (@actual = actual) == @expected
+        end
       end
+
+      let(:matcher) { matcher_class.new(3) }
     end
   end
 end

data/spec/rspec/matchers/be_close_spec.rb

@@ -8,7 +8,10 @@ module RSpec
       end
 
       it "is deprecated" do
-        expect(RSpec).to receive(:deprecate).with(/be_close.*/, :replacement => "be_within(0.5).of(3.0)")
+        expect_deprecation_with_type('be_close(3.0, 0.5)',
+          'be_within(0.5).of(3.0)',
+          'the be_close matcher'
+        )
         be_close(3.0, 0.5)
       end
 

data/spec/rspec/matchers/be_spec.rb

@@ -31,6 +31,22 @@ 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 = double("actual")
     actual.should_receive(:foo?).and_raise("aaaah")
@@ -50,7 +66,27 @@ describe "expect(...).to be_predicate" do
   it "does not support operator chaining like a basic `be` matcher does" do
     matcher = be_happy
     value = double(:happy? => false)
-    expect(be_happy == value).to be 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
 
@@ -231,35 +267,94 @@ describe "expect(...).not_to be_predicate(*args, &block)" do
   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
 

data/spec/rspec/matchers/change_spec.rb

@@ -193,7 +193,8 @@ 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
@@ -247,6 +248,80 @@ describe "expect { ... }.not_to change { block }" do
   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

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,19 +92,23 @@ 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 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"
+    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(x)" do
@@ -128,7 +132,7 @@ describe "Matchers should be able to generate their own descriptions" do
 
   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

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
+

data/spec/rspec/matchers/eq_spec.rb

@@ -28,7 +28,7 @@ module RSpec
         end.new
 
         expect(actual).to eq :anything # to trigger the matches? method
-        expect(called).to be_true
+        expect(called).to be_truthy
       end
 
       it "describes itself" do

data/spec/rspec/matchers/has_spec.rb

@@ -48,6 +48,20 @@ describe "expect(...).to have_sym(*args)" do
     }.to raise_error(NoMethodError)
   end
 
+  it "warns of deprecation if #has_sym?(*args) is private" do
+    klass = Class.new do
+      def has_foo?
+        true
+      end
+      private :has_foo?
+
+      # prevents double deprecation
+      def respond_to?(_); true; end
+    end
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /matching with have_foo on private method/)
+    expect(klass.new).to have_foo
+  end
+
   it "reraises an exception thrown in #has_sym?(*args)" do
     o = Object.new
     def o.has_sym?(*args)
@@ -57,6 +71,16 @@ describe "expect(...).to have_sym(*args)" do
       expect(o).to have_sym(:foo)
     }.to raise_error("Funky exception")
   end
+
+  it 'warns of deprecation when actual does not respond to #has_sym?' do
+    foo_class = Class.new do
+      def method_missing(method)
+        return true if method == :has_foo?
+      end
+    end
+    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /Matching with have_foo on an object that doesn't respond to `has_foo\?`/)
+    expect(foo_class.new).to have_foo
+  end
 end
 
 describe "expect(...).not_to have_sym(*args)" do