rspec-expectations 2.14.5 → 2.99.0

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
@@ -452,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