rspec-expectations 2.14.5 → 2.99.0.beta1

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

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

@@ -24,32 +24,6 @@ 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/have_spec.rb

@@ -10,7 +10,10 @@ 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 create_collection_owner_with(n)
     owner = RSpec::Expectations::Helper::CollectionOwner.new
@@ -452,4 +455,301 @@ 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+
+        target = BagOfWords.new(%w[foo bar baz])
+        expect(target).to_not have(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(3).letters"
+
+        message = "the rspec-collection_matchers gem " +
+                  "or replace your expectation with something like " +
+                  "`expect(collection.count).to eq(3)`"
+
+        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => 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(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+
+        expect(target).to_not have_at_least(4).letters
+      end
+    end
+  end
 end