rspec-expectations 2.13.0 → 2.99.0

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/equal_spec.rb

@@ -24,6 +24,32 @@ module RSpec
         expect(matcher.description).to eq "equal 1"
       end
 
+      context "when the expected object is falsey in conditinal semantics" do
+        it "describes itself with the expected object" do
+          matcher = equal(nil)
+          matcher.matches?(nil)
+          expect(matcher.description).to eq "equal nil"
+        end
+      end
+
+      context "when the expected object's #equal? always returns true" do
+        let(:strange_string) do
+          string = "foo"
+
+          def string.equal?(other)
+            true
+          end
+
+          string
+        end
+
+        it "describes itself with the expected object" do
+          matcher = equal(strange_string)
+          matcher.matches?(strange_string)
+          expect(matcher.description).to eq 'equal "foo"'
+        end
+      end
+
       it "suggests the `eq` matcher on failure" do
         expected, actual = "1", "1"
         expect {

data/spec/rspec/matchers/exist_spec.rb

@@ -8,7 +8,7 @@ describe "exist matcher" do
   end
 
   context "when the object does not respond to #exist? or #exists?" do
-    subject { mock }
+    subject { double }
 
     [:to, :not_to].each do |expect_method|
       describe "expect(...).#{expect_method} exist" do
@@ -25,12 +25,12 @@ describe "exist matcher" do
     context "when the object responds to ##{predicate}" do
       describe "expect(...).to exist" do
         it "passes if #{predicate}" do
-          expect(mock(predicate => true)).to exist
+          expect(double(predicate => true)).to exist
         end
 
         it "fails if not #{predicate}" do
           expect {
-            expect(mock(predicate => false)).to exist
+            expect(double(predicate => false)).to exist
           }.to fail_with(/expected .* to exist/)
         end
 
@@ -51,12 +51,12 @@ describe "exist matcher" do
 
       describe "expect(...).not_to exist" do
         it "passes if not #{predicate}" do
-          expect(mock(predicate => false)).not_to exist
+          expect(double(predicate => false)).not_to exist
         end
 
         it "fails if #{predicate}" do
           expect {
-            expect(mock(predicate => true)).not_to exist
+            expect(double(predicate => true)).not_to exist
           }.to fail_with(/expected .* not to exist/)
         end
       end
@@ -65,7 +65,7 @@ describe "exist matcher" do
 
   context "when the object responds to #exist? and #exists?" do
     context "when they both return falsey values" do
-      subject { mock(:exist? => false, :exists? => nil) }
+      subject { double(:exist? => false, :exists? => nil) }
 
       describe "expect(...).not_to exist" do
         it "passes" do
@@ -83,7 +83,7 @@ describe "exist matcher" do
     end
 
     context "when they both return truthy values" do
-      subject { mock(:exist? => true, :exists? => "something true") }
+      subject { double(:exist? => true, :exists? => "something true") }
 
       describe "expect(...).not_to exist" do
         it "fails" do
@@ -101,7 +101,7 @@ describe "exist matcher" do
     end
 
     context "when they return values with different truthiness" do
-      subject { mock(:exist? => true, :exists? => false) }
+      subject { double(:exist? => true, :exists? => false) }
 
       [:to, :not_to].each do |expect_method|
         describe "expect(...).#{expect_method} exist" do
@@ -116,7 +116,7 @@ describe "exist matcher" do
   end
 
   it 'passes any provided arguments to the call to #exist?' do
-    object = mock
+    object = double
     object.should_receive(:exist?).with(:foo, :bar) { true }
 
     expect(object).to exist(:foo, :bar)

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
@@ -117,6 +141,6 @@ describe "has" do
     def o.send(*args); raise "DOH! Library developers shouldn't use #send!" end
     expect {
       expect(o).to have_key(:a)
-    }.to_not raise_error
+    }.not_to raise_error
   end
 end

data/spec/rspec/matchers/have_spec.rb

@@ -10,7 +10,18 @@ describe "have matcher" do
     end
   end
 
-  before(:each) { stub_const("ActiveSupport::Inflector", inflector) }
+  before(:each) do
+    stub_const("ActiveSupport::Inflector", inflector)
+    allow_deprecation
+  end
+
+  def expect_have_deprecation(expression, message)
+    expect_deprecation_with_type(
+      "`#{expression}`",
+      message,
+      'the have matcher'
+    )
+  end
 
   def create_collection_owner_with(n)
     owner = RSpec::Expectations::Helper::CollectionOwner.new
@@ -326,13 +337,13 @@ EOF
 
   describe "have(n).items(args, block)" do
     it "passes args to target" do
-      target = mock("target")
+      target = double("target")
       target.should_receive(:items).with("arg1","arg2").and_return([1,2,3])
       expect(target).to have(3).items("arg1","arg2")
     end
 
     it "passes block to target" do
-      target = mock("target")
+      target = double("target")
       block = lambda { 5 }
       target.should_receive(:items).with("arg1","arg2", block).and_return([1,2,3])
       expect(target).to have(3).items("arg1","arg2", block)
@@ -402,6 +413,16 @@ EOF
     end
   end
 
+  if RUBY_VERSION >= '2.0'
+    describe RSpec::Matchers::BuiltIn::Have, "for an Enumerator whose size is nil but count is supplied" do
+      let(:enumerator) { %w[a b c d].to_enum(:each) }
+
+      it 'works fine' do
+        expect(enumerator).to have(4).items
+      end
+    end
+  end
+
   describe RSpec::Matchers::BuiltIn::Have do
     it "has method_missing as private" do
       expect(described_class.private_instance_methods).to include_method(:method_missing)
@@ -442,4 +463,391 @@ EOF
       end
     end
   end
+
+  context "deprecations for the have matcher" do
+    it "has the correct call site in the deprecation message" do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      expect([1, 2, 3]).to have(3).items
+    end
+
+    context "when the target is a collection" do
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection).to have(3).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to eq(3)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to have(3).items
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection).not_to have(4).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to_not eq(4)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to_not have(4).items
+      end
+    end
+
+    context "when the target owns a collection" do
+      class self::BagOfWords
+        attr_reader :words
+
+        def initialize(words)
+          @words = words
+        end
+      end
+
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection_owner).to have(3).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to eq(3)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to have(3).words
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection_owner).not_to have(4).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to_not eq(4)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to_not have(4).words
+      end
+    end
+
+    context "when the target is a Rails record" do
+      class TheModel
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = {}
+          @errors[:attr] = Array(errors)
+        end
+
+        def errors_on(attr, _ignore_opts = {})
+          Array(@errors[attr]).flatten.compact
+        end
+        alias_method :error_on, :errors_on
+      end
+
+      let(:message_preamble) do
+        "the rspec-collection_matchers gem " +
+          "or replace your expectation with something like "
+      end
+
+      before do
+        stub_const "RSpec::Rails", Module.new
+      end
+
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(record).to have(2).errors_on(:attr)"
+        message = message_preamble + <<-EOS.gsub(/^\s+\|/, '')
+          |
+          |
+          |    record.valid?
+          |    expect(record.errors[:attr].size).to eq(2)
+          |
+        EOS
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = TheModel.new(%w(foo bar))
+        expect(target).to have(2).errors_on(:attr)
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(record).not_to have(2).errors_on(:attr)"
+        message = message_preamble + <<-EOS.gsub(/^\s+\|/, '')
+          |
+          |
+          |    record.valid?
+          |    expect(record.errors[:attr].size).to_not eq(2)
+          |
+        EOS
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = TheModel.new('foo')
+        expect(target).not_to have(2).errors_on(:attr)
+      end
+
+      it "prints message for singular form: `error_on`" do
+        expectation_expression = "expect(record).to have(1).error_on(:attr)"
+        message = message_preamble + <<-EOS.gsub(/^\s+\|/, '')
+          |
+          |
+          |    record.valid?
+          |    expect(record.errors[:attr].size).to eq(1)
+          |
+        EOS
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = TheModel.new('foo')
+        expect(target).to have(1).error_on(:attr)
+      end
+
+      it "includes a validation context when provided" do
+        expectation_expression = "expect(record).to have(2).errors_on(:attr, :context => :spec)"
+        message = message_preamble + <<-EOS.gsub(/^\s+\|/, '')
+          |
+          |
+          |    record.valid?(:spec)
+          |    expect(record.errors[:attr].size).to eq(2)
+          |
+        EOS
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = TheModel.new(%w(foo bar))
+        options = {:context => :spec, :should_be_ignored => true}
+        expect(target).to have(2).errors_on(:attr, options)
+      end
+    end
+
+    context "when the target is an enumerator" do
+      it "prints a specific message for the positive expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).to have(3).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to eq(3)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to have(3).letters
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).not_to have(4).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to_not eq(4)`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to_not have(4).letters
+      end
+    end
+  end
+
+  context "deprecations for the have_at_most matcher" do
+    it "has the correct call site in the deprecation message" do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      expect([1, 2, 3]).to have_at_most(3).items
+    end
+
+    context "when the target is a collection" do
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection).to have_at_most(3).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to be <= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to have_at_most(3).items
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection).not_to have_at_most(2).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to be > 2`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to_not have_at_most(2).items
+      end
+    end
+
+    context "when the target owns a collection" do
+      class self::BagOfWords
+        attr_reader :words
+
+        def initialize(words)
+          @words = words
+        end
+      end
+
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection_owner).to have_at_most(3).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to be <= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to have_at_most(3).words
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection_owner).not_to have_at_most(2).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to be > 2`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to_not have_at_most(2).words
+      end
+    end
+
+    context "when the target is an enumerator" do
+      it "prints a specific message for the positive expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).to have_at_most(3).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to be <= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to have_at_most(3).letters
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).not_to have_at_most(2).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to be > 2`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to_not have_at_most(2).letters
+      end
+    end
+  end
+
+  context "deprecations for the have_at_least matcher" do
+    it "has the correct call site in the deprecation message" do
+      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+      expect([1, 2, 3]).to have_at_least(3).items
+    end
+
+    context "when the target is a collection" do
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection).to have_at_least(3).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to be >= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to have_at_least(3).items
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection).not_to have_at_least(4).items"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.size).to be < 4`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect([1, 2, 3]).to_not have_at_least(4).items
+      end
+    end
+
+    context "when the target owns a collection" do
+      class BagOfWords
+        attr_reader :words
+
+        def initialize(words)
+          @words = words
+        end
+      end
+
+      it "prints a specific message for the positive expectation format" do
+        expectation_expression = "expect(collection_owner).to have_at_least(3).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to be >= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to have_at_least(3).words
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        expectation_expression = "expect(collection_owner).not_to have_at_least(4).words"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection_owner.words.size).to be < 4`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to_not have_at_least(4).words
+      end
+    end
+
+    context "when the target is an enumerator" do
+      it "prints a specific message for the positive expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).to have_at_least(3).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to be >= 3`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to have_at_least(3).letters
+      end
+
+      it "prints a specific message for the negative expectation format" do
+        target = %w[a b c].to_enum(:each)
+
+        expectation_expression = "expect(collection).not_to have_at_least(4).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to be < 4`"
+
+        expect_have_deprecation(expectation_expression, message)
+
+        expect(target).to_not have_at_least(4).letters
+      end
+    end
+  end
 end

data/spec/rspec/matchers/include_matcher_integration_spec.rb

@@ -22,8 +22,8 @@ module RSpec
       end
 
       it "works with be_[some predicate]" do
-        expect([stub("actual", :happy? => true)]).to include( be_happy )
-        expect([stub("actual", :happy? => false)]).not_to include( be_happy )
+        expect([double("actual", :happy? => true)]).to include( be_happy )
+        expect([double("actual", :happy? => false)]).not_to include( be_happy )
       end
     end
   end

data/spec/rspec/matchers/include_spec.rb

@@ -137,7 +137,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(expected)" do
+  describe "expect(...).not_to include(expected)" do
     context "for a string target" do
       it "passes if target does not include expected" do
         expect("abc").not_to include("d")
@@ -188,7 +188,7 @@ describe "#include matcher" do
 
   end
 
-  describe "expect(...).to_not include(with, multiple, args)" do
+  describe "expect(...).not_to include(with, multiple, args)" do
     context "for a string target" do
       it "passes if the target does not include any of the expected" do
         expect("abc").not_to include("d", "e", "f")
@@ -280,7 +280,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(:key => value)" do
+  describe "expect(...).not_to include(:key => value)" do
     context 'for a hash target' do
       it "fails if target includes the key/value pair" do
         expect {
@@ -364,7 +364,7 @@ describe "#include matcher" do
     end
   end
 
-  describe "expect(...).to_not include(:key1 => value1, :key2 => value2)" do
+  describe "expect(...).not_to include(:key1 => value1, :key2 => value2)" do
     context 'for a hash target' do
       it "fails if target includes the key/value pairs" do
         expect {

data/spec/rspec/matchers/match_array_spec.rb

@@ -156,7 +156,7 @@ MESSAGE
   end
 end
 
-describe "expect(...).to_not match_array [:with, :multiple, :args]" do
+describe "expect(...).not_to match_array [:with, :multiple, :args]" do
   it "is not supported" do
     expect {
       expect([1,2,3]).not_to match_array [1,2,3]

data/spec/rspec/matchers/match_spec.rb

@@ -30,9 +30,22 @@ describe "expect(...).to match(expected)" do
     matcher.matches?("string")
     expect(matcher.failure_message_for_should).to eq "expected \"string\" to match /rings/"
   end
+
+  it "provides a diff on failure" do
+    allow(RSpec::Matchers.configuration).to receive(:color?).and_return(false)
+
+    failure_message_that_includes_diff = %r%
+\s*Diff:
+\s*@@ -1,2 \+1,2 @@
+\s*-/bar/
+\s*\+"foo"%
+
+    expect { expect("foo").to match(/bar/) }.to fail_with(failure_message_that_includes_diff)
+  end
+
 end
 
-describe "expect(...).to_not match(expected)" do
+describe "expect(...).not_to match(expected)" do
   it "passes when target (String) matches does not match (Regexp)" do
     expect("string").not_to match(/rings/)
   end