rspec-expectations 2.99.2 → 3.0.0.beta1

data/spec/rspec/matchers/matchers_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module RSpec
+  describe Matchers do
+
+    let(:sample_matchers) do
+      [:be,
+       :be_instance_of,
+       :be_kind_of]
+    end
+
+    context "once required" do
+      include TestUnitIntegrationSupport
+
+      it "includes itself in Test::Unit::TestCase" do
+        with_test_unit_loaded do
+          test_unit_case = Test::Unit::TestCase.allocate
+          sample_matchers.each do |sample_matcher|
+              expect(test_unit_case).to respond_to(sample_matcher)
+          end
+        end
+      end
+
+      it "includes itself in MiniTest::Unit::TestCase", :if => defined?(MiniTest) do
+        with_test_unit_loaded do
+          minitest_case = MiniTest::Unit::TestCase.allocate
+          sample_matchers.each do |sample_matcher|
+              expect(minitest_case).to respond_to(sample_matcher)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/rspec/matchers/operator_matcher_spec.rb

@@ -210,41 +210,22 @@ describe "operator matchers", :uses_should do
     let(:custom_klass) { Class.new }
     let(:custom_subklass) { Class.new(custom_klass) }
 
-    after do
-      RSpec::Matchers::BuiltIn::OperatorMatcher.unregister(custom_klass, "=~")
-    end
+    after {
+      RSpec::Matchers::OperatorMatcher.unregister(custom_klass, "=~")
+    }
 
     it "allows operator matchers to be registered for types" do
-      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)
+      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to eq(RSpec::Matchers::BuiltIn::Match)
     end
 
     it "considers ancestors when finding an operator matcher" do
-      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)
+      RSpec::Matchers::OperatorMatcher.register(custom_klass, "=~", RSpec::Matchers::BuiltIn::Match)
+      expect(RSpec::Matchers::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::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
+      expect(RSpec::Matchers::OperatorMatcher.get(custom_klass, "=~")).to be_nil
     end
   end
 

data/spec/rspec/matchers/raise_error_spec.rb

@@ -1,18 +1,5 @@
 require 'spec_helper'
 
-module WrapDeprecationCallSite
-  def expect_deprecation_with_call_site(file, line)
-    actual_call_site = nil
-    allow(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      actual_call_site = options[:call_site]
-    end
-
-    yield
-
-    expect(actual_call_site).to match([file, line].join(':'))
-  end
-end
-
 describe "expect { ... }.to raise_error" do
   it_behaves_like("an RSpec matcher", :valid_value => lambda { raise "boom" },
                                       :invalid_value => lambda { }) do
@@ -73,23 +60,42 @@ describe "expect { ... }.to raise_error {|err| ... }" do
   end
 end
 
+describe "expect { ... }.to raise_error do |err| ... end" do
+  it "passes the error to the block" do
+    error = nil
+    expect { non_existent_method }.to raise_error do |e|
+      error = e
+    end
+    expect(error).to be_kind_of(NameError)
+  end
+end
+
+describe "expect { ... }.to(raise_error { |err| ... }) do |err| ... end" do
+  it "passes the error only to the block taken directly by #raise_error" do
+    error_passed_to_curly = nil
+    error_passed_to_do_end = nil
+
+    expect { non_existent_method }.to(raise_error { |e| error_passed_to_curly = e }) do |e|
+      error_passed_to_do_end = e
+    end
+
+    expect(error_passed_to_curly).to be_kind_of(NameError)
+    expect(error_passed_to_do_end).to be_nil
+  end
+end
+
 describe "expect { ... }.not_to raise_error" do
 
   context "with a specific error class" do
-    it "is deprecated" do
-      RSpec.should_receive :deprecate
-      expect {"bees"}.not_to raise_error(RuntimeError)
+    it "is invalid" do
+      expect {
+        expect {"bees"}.not_to raise_error(RuntimeError)
+      }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
+
     end
   end
 
   context "with no specific error class" do
-    it "is not deprecated" do
-      run = nil
-      allow(RSpec).to receive(:deprecate) { run = true }
-      expect {"bees"}.not_to raise_error
-      expect(run).to be_nil
-    end
-
     it "passes if nothing is raised" do
       expect {}.not_to raise_error
     end
@@ -158,47 +164,43 @@ describe "expect { ... }.to raise_error(message)" do
   end
 end
 
-describe "expect { ... }.not_to raise_error(message)" do
-  include WrapDeprecationCallSite
-
-  before do
-    allow(RSpec).to receive(:deprecate)
+describe "expect { ... }.to raise_error.with_message(message)" do
+  it "raises an argument error if raise_error itself expects a message" do
+    expect {
+      expect { }.to raise_error("bees").with_message("sup")
+    }.to raise_error.with_message(/`expect { }\.to raise_error\(message\)\.with_message\(message\)` is not valid/)
   end
 
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with(
-      /not_to raise_error\(message\)/,
-      :replacement =>"`expect { }.not_to raise_error` (with no args)"
-    )
-    expect {raise 'blarg'}.not_to raise_error('blah')
+  it "passes if RuntimeError is raised with the right message" do
+    expect {raise 'blah'}.to raise_error.with_message('blah')
   end
 
-  it 'reports the line number of the deprecated syntax' do
-    allow(RSpec).to receive(:deprecate).and_call_original
-
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1) do
-      expect {raise 'blarg'}.not_to raise_error('blah')
-    end
+  it "passes if RuntimeError is raised with a matching message" do
+    expect {raise 'blah'}.to raise_error.with_message(/blah/)
   end
 
-  it "passes if RuntimeError error is raised with the different message" do
-    expect {raise 'blarg'}.not_to raise_error('blah')
+  it "passes if any other error is raised with the right message" do
+    expect {raise NameError.new('blah')}.to raise_error.with_message('blah')
   end
 
-  it "passes if any other error is raised with the wrong message" do
-    expect {raise NameError.new('blarg')}.not_to raise_error('blah')
+  it "fails if RuntimeError error is raised with the wrong message" do
+    expect do
+      expect {raise 'blarg'}.to raise_error.with_message('blah')
+    end.to fail_with(/expected Exception with \"blah\", got #<RuntimeError: blarg>/)
   end
 
-  it "fails if RuntimeError is raised with message" do
+  it "fails if any other error is raised with the wrong message" do
     expect do
-      expect {raise 'blah'}.not_to raise_error('blah')
-    end.to fail_with(/expected no Exception with "blah", got #<RuntimeError: blah>/)
+      expect {raise NameError.new('blarg')}.to raise_error.with_message('blah')
+    end.to fail_with(/expected Exception with \"blah\", got #<NameError: blarg>/)
   end
+end
 
-  it "fails if any other error is raised with message" do
-    expect do
-      expect {raise NameError.new('blah')}.not_to raise_error('blah')
-    end.to fail_with(/expected no Exception with "blah", got #<NameError: blah>/)
+describe "expect { ... }.not_to raise_error(message)" do
+  it "is invalid" do
+    expect {
+      expect {raise 'blarg'}.not_to raise_error(/blah/)
+    }.to raise_error(/`expect { }\.not_to raise_error\(message\)` is not valid/)
   end
 end
 
@@ -227,39 +229,10 @@ describe "expect { ... }.to raise_error(NamedError)" do
 end
 
 describe "expect { ... }.not_to raise_error(NamedError)" do
-  include WrapDeprecationCallSite
-
-  before do
-    allow(RSpec).to receive(:deprecate)
-  end
-
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with(
-      /not_to raise_error\(SpecificErrorClass\)/,
-      :replacement =>"`expect { }.not_to raise_error` (with no args)"
-    )
-    expect { }.not_to raise_error(NameError)
-  end
-
-  it 'reports the line number of the deprecated syntax' do
-    allow(RSpec).to receive(:deprecate).and_call_original
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1) do
-      expect { }.not_to raise_error(NameError)
-    end
-  end
-
-  it "passes if nothing is raised" do
-    expect { }.not_to raise_error(NameError)
-  end
-
-  it "passes if another error is raised" do
-    expect { raise }.not_to raise_error(NameError)
-  end
-
-  it "fails if named error is raised" do
+  it "is invalid" do
     expect {
-      expect { 1 + 'b' }.not_to raise_error(TypeError)
-    }.to fail_with(/expected no TypeError, got #<TypeError: String can't be/)
+      expect { }.not_to raise_error(NameError)
+    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass\)` is not valid/)
   end
 end
 
@@ -288,43 +261,10 @@ describe "expect { ... }.to raise_error(NamedError, error_message) with String"
 end
 
 describe "expect { ... }.not_to raise_error(NamedError, error_message) with String" do
-  include WrapDeprecationCallSite
-
-  before do
-    allow(RSpec).to receive(:deprecate)
-  end
-
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate).with(
-      /not_to raise_error\(SpecificErrorClass, message\)/,
-      :replacement =>"`expect { }.not_to raise_error` (with no args)"
-    )
-    expect {}.not_to raise_error(RuntimeError, "example message")
-  end
-
-  it 'reports the line number of the deprecated syntax' do
-    allow(RSpec).to receive(:deprecate).and_call_original
-    expect_deprecation_with_call_site(__FILE__, __LINE__ + 1) do
-      expect {}.not_to raise_error(RuntimeError, "example message")
-    end
-  end
-
-  it "passes if nothing is raised" do
-    expect {}.not_to raise_error(RuntimeError, "example message")
-  end
-
-  it "passes if a different error is raised" do
-    expect { raise }.not_to raise_error(NameError, "example message")
-  end
-
-  it "passes if same error is raised with different message" do
-    expect { raise RuntimeError.new("not the example message") }.not_to raise_error(RuntimeError, "example message")
-  end
-
-  it "fails if named error is raised with same message" do
+  it "is invalid" do
     expect {
-      expect { raise "example message" }.not_to raise_error(RuntimeError, "example message")
-    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
+      expect {}.not_to raise_error(RuntimeError, "example message")
+    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 
@@ -353,31 +293,10 @@ describe "expect { ... }.to raise_error(NamedError, error_message) with Regexp"
 end
 
 describe "expect { ... }.not_to raise_error(NamedError, error_message) with Regexp" do
-  before do
-    allow(RSpec).to receive(:deprecate)
-  end
-
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate)
-    expect {}.not_to raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "passes if nothing is raised" do
-    expect {}.not_to raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "passes if a different error is raised" do
-    expect { raise }.not_to raise_error(NameError, /ample mess/)
-  end
-
-  it "passes if same error is raised with non-matching message" do
-    expect { raise RuntimeError.new("non matching message") }.not_to raise_error(RuntimeError, /ample mess/)
-  end
-
-  it "fails if named error is raised with matching message" do
+  it "is invalid" do
     expect {
-      expect { raise "example message" }.not_to raise_error(RuntimeError, /ample mess/)
-    }.to fail_with(/expected no RuntimeError with message matching \/ample mess\/, got #<RuntimeError: example message>/)
+      expect {}.not_to raise_error(RuntimeError, /ample mess/)
+    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 
@@ -455,73 +374,10 @@ describe "expect { ... }.to raise_error(NamedError, error_message) { |err| ... }
 end
 
 describe "expect { ... }.not_to raise_error(NamedError, error_message) { |err| ... }" do
-  before do
-    allow(RSpec).to receive(:deprecate)
-  end
-
-  it "is deprecated" do
-    expect(RSpec).to receive(:deprecate)
-    expect {}.not_to raise_error(RuntimeError, "example message") { |err| }
-  end
-
-  it "passes if nothing is raised" do
-    ran = false
-
-    expect {}.not_to raise_error(RuntimeError, "example message") { |err|
-      ran = true
-    }
-
-    expect(ran).to eq false
-  end
-
-  it "passes if a different error is raised" do
-    ran = false
-
-    expect { raise }.not_to raise_error(NameError, "example message") { |err|
-      ran = true
-    }
-
-    expect(ran).to eq false
-  end
-
-  it "passes if same error is raised with different message" do
-    ran = false
-
-    expect {
-      raise RuntimeError.new("not the example message")
-    }.not_to raise_error(RuntimeError, "example message") { |err|
-      ran = true
-    }
-
-    expect(ran).to eq false
-  end
-
-  it "fails if named error is raised with same message" do
-    ran = false
-
-    expect {
-      expect {
-        raise "example message"
-      }.not_to raise_error(RuntimeError, "example message") { |err|
-        ran = true
-      }
-    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
-
-    expect(ran).to eq false
-  end
-
-  it 'skips the error verification block when using the expect {...}.to syntax' do
-    ran = false
-
+  it "is invalid" do
     expect {
-      expect {
-        raise "example message"
-      }.not_to raise_error(RuntimeError, "example message") { |err|
-        ran = true
-      }
-    }.to fail_with(/expected no RuntimeError with \"example message\", got #<RuntimeError: example message>/)
-
-    expect(ran).to eq false
+      expect {}.not_to raise_error(RuntimeError, "example message") { |err| }
+    }.to raise_error(/`expect { }\.not_to raise_error\(SpecificErrorClass, message\)` is not valid/)
   end
 end
 

data/spec/rspec/matchers/yield_spec.rb

@@ -16,19 +16,18 @@ module YieldHelpers
 end
 
 class InstanceEvaler
-  include RSpec::Matchers::Extensions::InstanceEvalWithArgs
 
   def yield_with_no_args(&block)
-    instance_eval_with_args(&block)
+    instance_exec(&block)
   end
 
   def yield_with_args(*args, &block)
-    instance_eval_with_args(*args, &block)
+    instance_exec(*args, &block)
   end
 
   def each_arg(*args, &block)
     args.each do |arg|
-      instance_eval_with_args(arg, &block)
+      instance_exec(arg, &block)
     end
   end
 end
@@ -53,7 +52,7 @@ describe "yield_control matcher" do
       expect { |b| _yield_with_args(1, 2, &b) }.to yield_control
     end
 
-    it 'passes if the block yields using instance_eval' do
+    it 'passes if the block yields using instance_exec' do
       expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_control
     end
 
@@ -63,6 +62,12 @@ describe "yield_control matcher" do
       }.to fail_with(/expected given block to yield control/)
     end
 
+    it 'does not return a meaningful value from the block' do
+      val = nil
+      expect { |b| val = _yield_with_args(&b) }.to yield_control
+      expect(val).to be_nil
+    end
+
     context "with exact count" do
       it 'fails if the block yields wrong number of times' do
         expect {
@@ -186,12 +191,18 @@ describe "yield_with_no_args matcher" do
     expect(yield_with_no_args.description).to eq("yield with no args")
   end
 
+  it 'does not return a meaningful value from the block' do
+    val = nil
+    expect { |b| val = _yield_with_no_args(&b) }.to yield_with_no_args
+    expect(val).to be_nil
+  end
+
   describe "expect {...}.to yield_with_no_args" do
     it 'passes if the block yields with no args' do
       expect { |b| _yield_with_no_args(&b) }.to yield_with_no_args
     end
 
-    it 'passes if the block yields with no args using instance_eval' do
+    it 'passes if the block yields with no args using instance_exec' do
       expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_with_no_args
     end
 
@@ -265,6 +276,12 @@ describe "yield_with_args matcher" do
     expect(yield_with_args(false).description).to eq("yield with args(false)")
   end
 
+  it 'does not return a meaningful value from the block' do
+    val = nil
+    expect { |b| val = _yield_with_args(1, &b) }.to yield_with_args(1)
+    expect(val).to be_nil
+  end
+
   describe "expect {...}.to yield_with_args" do
     it 'passes if the block yields with arguments' do
       expect { |b| _yield_with_args(1, &b) }.to yield_with_args
@@ -322,7 +339,7 @@ describe "yield_with_args matcher" do
       expect { |b| _yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
     end
 
-    it 'passes if the block yields with the given arguments using instance_eval' do
+    it 'passes if the block yields with the given arguments using instance_exec' do
       expect { |b| InstanceEvaler.new.yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
     end
 
@@ -362,7 +379,7 @@ describe "yield_with_args matcher" do
       expect { |b| _yield_with_args(false, &b) }.to yield_with_args(false)
     end
 
-    it 'passes if the block yields with the given arguments using instance_eval' do
+    it 'passes if the block yields with the given arguments using instance_exec' do
       expect { |b| InstanceEvaler.new.yield_with_args(false, &b) }.to yield_with_args(false)
     end
 
@@ -429,6 +446,12 @@ describe "yield_successive_args matcher" do
     expect(yield_successive_args([:a, 1], [:b, 2]).description).to eq("yield successive args([:a, 1], [:b, 2])")
   end
 
+  it 'does not return a meaningful value from the block' do
+    val = nil
+    expect { |b| val = _yield_with_args(1, &b) }.to yield_successive_args(1)
+    expect(val).to be_nil
+  end
+
   describe "expect {...}.to yield_successive_args([:a, 1], [:b, 2])" do
     it 'passes when the block successively yields the given args' do
       expect { |b| [ [:a, 1], [:b, 2] ].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
@@ -452,7 +475,7 @@ describe "yield_successive_args matcher" do
       expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
     end
 
-    it 'passes when the block successively yields the given args using instance_eval' do
+    it 'passes when the block successively yields the given args using instance_exec' do
       expect { |b| InstanceEvaler.new.each_arg(1, 2, 3, &b) }.to yield_successive_args(1, 2, 3)
     end