rspec-expectations 2.99.0.beta1 → 2.99.0.beta2

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

@@ -15,6 +15,14 @@ describe "have matcher" do
     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
     (1..n).each do |number|
@@ -470,7 +478,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.size).to eq(3)`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to have(3).items
       end
@@ -482,7 +490,7 @@ EOF
                   "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_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to_not have(4).items
       end
@@ -504,7 +512,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to have(3).words
@@ -517,7 +525,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to_not have(4).words
@@ -534,7 +542,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.count).to eq(3)`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect(target).to have(3).letters
       end
@@ -548,7 +556,7 @@ EOF
                   "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_have_deprecation(expectation_expression, message)
 
         expect(target).to_not have(4).letters
       end
@@ -569,7 +577,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.size).to be <= 3`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to have_at_most(3).items
       end
@@ -581,7 +589,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.size).to be > 2`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to_not have_at_most(2).items
       end
@@ -603,7 +611,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to have_at_most(3).words
@@ -616,7 +624,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to_not have_at_most(2).words
@@ -633,7 +641,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.count).to be <= 3`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect(target).to have_at_most(3).letters
       end
@@ -647,7 +655,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.count).to be > 2`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect(target).to_not have_at_most(2).letters
       end
@@ -668,7 +676,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.size).to be >= 3`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to have_at_least(3).items
       end
@@ -680,7 +688,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.size).to be < 4`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect([1, 2, 3]).to_not have_at_least(4).items
       end
@@ -702,7 +710,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to have_at_least(3).words
@@ -715,7 +723,7 @@ EOF
                   "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)
+        expect_have_deprecation(expectation_expression, message)
 
         target = BagOfWords.new(%w[foo bar baz])
         expect(target).to_not have_at_least(4).words
@@ -732,7 +740,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.count).to be >= 3`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect(target).to have_at_least(3).letters
       end
@@ -746,7 +754,7 @@ EOF
                   "or replace your expectation with something like " +
                   "`expect(collection.count).to be < 4`"
 
-        expect(RSpec).to receive(:deprecate).with("`#{expectation_expression}`", :replacement => message)
+        expect_have_deprecation(expectation_expression, message)
 
         expect(target).to_not have_at_least(4).letters
       end

data/spec/rspec/matchers/matcher_spec.rb

@@ -138,6 +138,19 @@ module RSpec::Matchers::DSL
     end
 
     it "provides expected" do
+      expect_no_deprecation
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) {}.for_expected('expected', 'strings')
+      expect(matcher.expected).to eq %w[expected strings]
+    end
+
+    it "provides expected as an array" do
+      expect_no_deprecation
+      matcher = RSpec::Matchers::DSL::Matcher.new(:name) {}.for_expected('expected string')
+      expect(matcher.expected_as_array).to eq ['expected string']
+    end
+
+    it "warns of deprecation about expected when it's a single value" do
+      expect_deprecation_with_call_site __FILE__, __LINE__ + 2
       matcher = RSpec::Matchers::DSL::Matcher.new(:name) {}.for_expected('expected string')
       expect(matcher.expected).to eq ['expected string']
     end

data/spec/rspec/matchers/operator_matcher_spec.rb

@@ -211,21 +211,40 @@ describe "operator matchers", :uses_should do
     let(:custom_subklass) { Class.new(custom_klass) }
 
     after {
-      RSpec::Matchers::OperatorMatcher.unregister(custom_klass, "=~")
+      RSpec::Matchers::BuiltIn::OperatorMatcher.unregister(custom_klass, "=~")
     }
 
     it "allows operator matchers to be registered for types" do
-      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
+      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
     end
 
     it "considers ancestors when finding an operator matcher" do
-      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_subklass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
+      RSpec::Matchers::BuiltIn::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_subklass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
     end
 
     it "returns nil if there is no matcher registered for a type" do
-      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to be_nil
+      expect(RSpec::Matchers::BuiltIn::OperatorMatcher.get(custom_klass, "=~")).to be_nil
+    end
+
+    context "when accessing it using the old 2.x const name" do
+      it 'returns the new constant scoped by `BuiltIn`' do
+        allow_deprecation
+        expect(RSpec::Matchers::OperatorMatcher).to be(RSpec::Matchers::BuiltIn::OperatorMatcher)
+      end
+
+      it 'issues a deprecation warning' do
+        expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /OperatorMatcher/)
+        RSpec::Matchers::OperatorMatcher
+      end
+
+      it 'allows other undefined constant to raise errors like normal' do
+        expect_no_deprecation
+        expect {
+          RSpec::Matchers::FooBarBazz
+        }.to raise_error(NameError, /RSpec::Matchers::FooBarBazz/)
+      end
     end
   end
 

data/spec/spec_helper.rb

@@ -1,25 +1,5 @@
 Dir['./spec/support/**/*'].each {|f| require f}
 
-module DeprecationHelpers
-  def allow_deprecation
-    allow(RSpec.configuration.reporter).to receive(:deprecation)
-  end
-
-  def expect_deprecation_with_call_site(file, line)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      matcher = include([file, line].join(':'))
-      unless matcher.matches?(options[:call_site])
-        # RSpec::Expectations::ExpectationNotMetError is rescued in the `match` block
-        # of a custom matcher and returned as `false` from `matches?`. This would
-        # prevent an expectation failure here from surfacing in the test suite if
-        # it's triggered from within a `match` block, so we need to raise
-        # a different error class instead.
-        raise matcher.failure_message_for_should
-      end
-    end
-  end
-end
-
 RSpec::configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.color_enabled = true
@@ -32,7 +12,6 @@ RSpec::configure do |config|
     expectations.syntax = :expect
   end
 
-  config.include SpecHelperMethods
   config.include DeprecationHelpers
 end
 

data/spec/support/helper_methods.rb

@@ -1,11 +1,36 @@
-module SpecHelperMethods
-  def expect_deprecation_with_call_site(file, line)
+module DeprecationHelpers
+
+  def expect_deprecation_with_call_site(file, line, snippet = //)
     expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to include([file, line].join(':'))
+      matcher = include([file, line].join(':'))
+      call_site = options[:call_site] || options[:message]
+
+      unless matcher.matches?(call_site)
+        # RSpec::Expectations::ExpectationNotMetError is rescued in the `match` block
+        # of a custom matcher and returned as `false` from `matches?`. This would
+        # prevent an expectation failure here from surfacing in the test suite if
+        # it's triggered from within a `match` block, so we need to raise
+        # a different error class instead.
+        raise matcher.failure_message_for_should
+      end
+
+      deprecated = options[:deprecated] || options[:message]
+      expect(deprecated).to match(snippet)
     end
   end
 
+  def expect_deprecation_with_type(expression, message, type)
+    expect(RSpec).to receive(:deprecate).with(expression,
+      :replacement => message,
+      :type        => type
+    )
+  end
+
   def allow_deprecation
     allow(RSpec.configuration.reporter).to receive(:deprecation)
   end
+
+  def expect_no_deprecation
+    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
+  end
 end

data/spec/support/shared_examples.rb

@@ -1,13 +1,55 @@
 shared_examples_for "an RSpec matcher" do |options|
   let(:valid_value)   { options.fetch(:valid_value) }
   let(:invalid_value) { options.fetch(:invalid_value) }
+  let(:deprecations)  { [] }
+
+  def matched_deprecations
+    deprecations.select { |opts| opts[:deprecated] =~ /matcher == value/ }
+  end
+
+  before do
+    allow(RSpec.configuration.reporter).to receive(:deprecation) do |opts|
+      deprecations << opts
+    end
+  end
 
   it 'matches a valid value when using #== so it can be composed' do
     expect(matcher).to eq(valid_value)
   end
 
+  it 'matches a valid value when using #=== so it can be composed' do
+    expect(matcher).to be === valid_value
+  end
+
   it 'does not match an invalid value when using #== so it can be composed' do
     expect(matcher).not_to eq(invalid_value)
   end
+
+  it 'does not match an invalid value when using #=== so it can be composed' do
+    expect(matcher).not_to be === invalid_value
+  end
+
+  it 'does not print a deprecation warning when using #===' do
+    matcher === valid_value
+    matcher === invalid_value
+    expect(matched_deprecations).to eq([])
+  end
+
+  it 'does not print a deprecation warning when using #== if it returns false' do
+    (matcher == invalid_value).nil? # calling a method to avoid a warning
+    expect(matched_deprecations).to eq([])
+  end
+
+  it 'does not print a deprecation warning when using #== if it returns true because it was given the same object' do
+    expect(matcher).to be == matcher
+    expect(matched_deprecations).to eq([])
+  end
+
+  it 'prints a deprecation warning for #== when given a valid value since' do
+    (matcher == valid_value).nil? # calling a method to avoid a warning
+    expect(matched_deprecations.count).to eq(1)
+    deprecation = matched_deprecations.first
+    expect(deprecation[:call_site]).to include([__FILE__, __LINE__ - 3].join(':'))
+  end
 end