rspec-expectations 2.13.0 → 2.99.0

data/spec/rspec/{matchers → expectations}/configuration_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 require 'delegate'
 
 module RSpec
-  module Matchers
+  module Expectations
     describe "RSpec::Matchers.configuration" do
       it 'returns a memoized configuration instance' do
-        expect(RSpec::Matchers.configuration).to be_a(RSpec::Matchers::Configuration)
+        expect(RSpec::Matchers.configuration).to be_a(RSpec::Expectations::Configuration)
         expect(RSpec::Matchers.configuration).to be(RSpec::Matchers.configuration)
       end
     end
@@ -13,6 +13,25 @@ module RSpec
     describe Configuration do
       let(:config) { Configuration.new }
 
+      context "when accessing it using the old 2.x const name" do
+        it 'returns the new constant' do
+          allow_deprecation
+          expect(RSpec::Matchers::Configuration).to be(RSpec::Expectations::Configuration)
+        end
+
+        it 'issues a deprecation warning' do
+          expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /RSpec::Matchers::Configuration/)
+          RSpec::Matchers::Configuration
+        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
+
       describe "#backtrace_formatter" do
         let(:original_backtrace) { %w[ clean-me/a.rb other/file.rb clean-me/b.rb ] }
         let(:cleaned_backtrace)  { %w[ other/file.rb ] }
@@ -22,7 +41,12 @@ module RSpec
         end
 
         before do
-          RSpec.configuration.stub(:backtrace_clean_patterns) { [/clean-me/] }
+          @old_patterns = RSpec.configuration.backtrace_exclusion_patterns
+          RSpec.configuration.backtrace_exclusion_patterns = [/clean-me/]
+        end
+
+        after do
+          RSpec.configuration.backtrace_exclusion_patterns = @old_patterns
         end
 
         it "defaults to rspec-core's backtrace formatter when rspec-core is loaded" do
@@ -36,7 +60,7 @@ module RSpec
         end
 
         it "can be set to another backtrace formatter" do
-          config.backtrace_formatter = stub(:format_backtrace => ['a'])
+          config.backtrace_formatter = double(:format_backtrace => ['a'])
           expect(formatted_backtrace).to eq(['a'])
         end
       end
@@ -60,134 +84,97 @@ module RSpec
       end
 
       shared_examples_for "configuring the expectation syntax" do
-        # We want a sandboxed method that ensures that we wind up with
-        # both syntaxes properly enabled when the example ends.
-        #
-        # On platforms that fork, using a sub process is the easiest,
-        # most robust way to achieve that.
-        #
-        # On jRuby we just re-enable both syntaxes at the end of the example;
-        # however, this is a generally inferior approach because it depends on
-        # the code-under-test working properly; if it doesn't work properly,
-        # it could leave things in a "broken" state where tons of other examples fail.
-        if RUBY_PLATFORM == "java"
-          def sandboxed
-            orig_syntax = RSpec::Matchers.configuration.syntax
-            yield
-          ensure
-            configure_syntax(orig_syntax)
-          end
-        else
-          include InSubProcess
-          alias sandboxed in_sub_process
+        before do
+          @orig_syntax = RSpec::Matchers.configuration.syntax
+        end
+
+        after do
+          configure_syntax(@orig_syntax)
         end
 
         it 'can limit the syntax to :should' do
-          sandboxed do
-            configure_syntax :should
-            configured_syntax.should eq([:should])
+          configure_syntax :should
+          configured_syntax.should eq([:should])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            lambda { expect(6).to eq(6) }.should raise_error(NameError)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          lambda { expect(6).to eq(6) }.should raise_error(NameError)
         end
 
         it 'is a no-op when configured to :should twice' do
-          sandboxed do
-            configure_syntax :should
-
-            Expectations::Syntax.default_should_host.
-                                 stub(:method_added).
-                                 and_raise("no methods should be added here")
-
-            configure_syntax :should
-          end
+          configure_syntax :should
+          Expectations::Syntax.default_should_host.should_not_receive(:method_added)
+          configure_syntax :should
+          RSpec::Mocks.verify # because configure_syntax is called again in an after hook
         end
 
         it 'can limit the syntax to :expect' do
-          sandboxed do
-            configure_syntax :expect
-            expect(configured_syntax).to eq([:expect])
+          configure_syntax :expect
+          expect(configured_syntax).to eq([:expect])
 
-            expect(3).to eq(3)
-            expect { 3.should eq(3) }.to raise_error(NameError)
-            expect { 3.should_not eq(3) }.to raise_error(NameError)
-          end
+          expect(3).to eq(3)
+          expect { 3.should eq(3) }.to raise_error(NameError)
+          expect { 3.should_not eq(3) }.to raise_error(NameError)
         end
 
         it 'is a no-op when configured to :expect twice' do
-          sandboxed do
-            RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
+          RSpec::Matchers.stub(:method_added).and_raise("no methods should be added here")
 
-            configure_syntax :expect
-            configure_syntax :expect
-          end
+          configure_syntax :expect
+          configure_syntax :expect
         end
 
         it 'can re-enable the :should syntax' do
-          sandboxed do
-            configure_syntax :expect
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          configure_syntax :expect
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            expect(3).to eq(3)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         end
 
         it 'can re-enable the :expect syntax' do
-          sandboxed do
-            configure_syntax :should
-            configure_syntax [:should, :expect]
-            configured_syntax.should eq([:should, :expect])
+          configure_syntax :should
+          configure_syntax [:should, :expect]
+          configured_syntax.should eq([:should, :expect])
 
-            3.should eq(3)
-            3.should_not eq(4)
-            expect(3).to eq(3)
-          end
+          3.should eq(3)
+          3.should_not eq(4)
+          expect(3).to eq(3)
         end
 
         it 'does not add the deprecated #should to ExpectationTarget when only :should is enabled' do
           et = Expectations::ExpectationTarget
 
-          sandboxed do
-            configure_syntax :should
-            et.new(Proc.new {}).should be_an(et)
-            et.new(Proc.new {}).should_not be_a(Proc)
-          end
+          configure_syntax :should
+          et.new(Proc.new {}).should be_an(et)
+          et.new(Proc.new {}).should_not be_a(Proc)
         end
 
         it 'does not add the deprecated #should to ExpectationTarget when only :expect is enabled' do
-          sandboxed do
-            configure_syntax :expect
-            expect(expect(3)).not_to respond_to(:should)
-            expect(expect(3)).not_to respond_to(:should_not)
-          end
+          configure_syntax :expect
+          expect(expect(3)).not_to respond_to(:should)
+          expect(expect(3)).not_to respond_to(:should_not)
         end
 
         context 'when both :expect and :should are enabled' do
-          before { RSpec.stub(:warn) }
+          before { allow(RSpec).to receive(:deprecate) }
 
           it 'allows `expect {}.should` to be used' do
-            sandboxed do
-              configure_syntax [:should, :expect]
-              expect { raise "boom" }.should raise_error("boom")
-              expect { }.should_not raise_error
-            end
+            configure_syntax [:should, :expect]
+            expect { raise "boom" }.should raise_error("boom")
+            expect { }.should_not raise_error
           end
 
           it 'prints a deprecation notice when `expect {}.should` is used' do
-            sandboxed do
-              configure_syntax [:should, :expect]
+            configure_syntax [:should, :expect]
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to.*instead/)
-              expect { raise "boom" }.should raise_error("boom")
+            expect(RSpec).to receive(:deprecate)
+            expect { raise "boom" }.should raise_error("boom")
 
-              RSpec.should_receive(:warn).with(/please use `expect \{ \}.to_not.*instead/)
-              expect { }.should_not raise_error
-            end
+            expect(RSpec).to receive(:deprecate)
+            expect { }.should_not raise_error
           end
         end
       end

data/spec/rspec/expectations/differ_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 require 'ostruct'
 
@@ -13,10 +14,11 @@ module RSpec
         # color disabled context
 
       describe '#diff_as_string' do
+        subject { differ.diff_as_string(@expected, @actual) }
         it "outputs unified diff of two strings" do
-          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
-          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
-          expected_diff= <<'EOD'
+          @expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          @actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expect(subject).to eql(<<-'EOD')
 
 
 @@ -1,6 +1,6 @@
@@ -35,8 +37,33 @@ module RSpec
  line
 EOD
 
-          diff = differ.diff_as_string(expected, actual)
-          expect(diff).to eql(expected_diff)
+        end
+        if RUBY_VERSION.to_f > 1.9
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION < '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql(<<-EOD.encode('UTF-16LE'))
+
+@@ -1,2 +1,2 @@
+-Tu avec carte {count} item has
++Tu avec carté {count} itém has
+EOD
+          end
+          it 'copes with encoded strings', :pending => (Diff::LCS::VERSION >= '1.2.2') do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has".encode('UTF-16LE')
+            expect(subject).to eql 'Could not produce a diff because of the encoding of the string (UTF-16LE)'
+          end
+          it 'handles differently encoded strings that are compatible' do
+            @expected = "강인철".encode('UTF-8')
+            @actual   = "abc".encode('us-ascii')
+            expect(subject).to eql "\n@@ -1,2 +1,2 @@\n-abc\n+강인철\n"
+          end
+          it 'outputs a message when encountering differently encoded strings' do
+            @expected="Tu avec carté {count} itém has".encode('UTF-16LE')
+            @actual="Tu avec carte {count} item has"
+            expect(subject).to eql 'Could not produce a diff because the encoding of the actual string (UTF-8) differs from the encoding of the expected string (UTF-16LE)'
+          end
         end
       end
 
@@ -115,6 +142,39 @@ EOD
           expect(diff).to eq expected_diff
         end
 
+        it 'outputs unified diff message of two hashes with differing encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-"a" => "a"
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+"ö" => "ö"} : '+"\303\266" => "\303\266"' }
+}
+
+          diff = differ.diff_as_object({'ö' => 'ö'}, {'a' => 'a'})
+          expect(diff).to eq expected_diff
+        end
+
+        it 'outputs unified diff message of two hashes with encoding different to key encoding' do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-:a => "a"
+#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+\"한글\" => \"한글2\"} : '+"\355\225\234\352\270\200" => "\355\225\234\352\270\2002"' }
+}
+
+          diff = differ.diff_as_object({ "한글" => "한글2"}, { :a => "a"})
+          expect(diff).to eq expected_diff
+        end
+
+        it "outputs unified diff message of two hashes with object keys" do
+          expected_diff = %Q{
+@@ -1,2 +1,2 @@
+-["a", "c"] => "b"
++["d", "c"] => "b"
+}
+
+          diff = differ.diff_as_object({ ['d','c'] => 'b'}, { ['a','c'] => 'b' })
+          expect(diff).to eq expected_diff
+        end
+
         it "outputs unified diff of single line strings" do
           expected = "this is one string"
           actual   = "this is another string"
@@ -167,4 +227,3 @@ EOD
     end
   end
 end
-

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -22,6 +22,12 @@ module RSpec
           }.to raise_error(ArgumentError)
         end
 
+        it 'raises a wrong number of args ArgumentError when given two args' do
+          expect {
+            expect(1, 2)
+          }.to raise_error(ArgumentError, /wrong number of arg/)
+        end
+
         it 'raises an ArgumentError when given neither an argument nor a block' do
           expect {
             expect
@@ -37,10 +43,13 @@ module RSpec
         end
 
         it 'passes a valid negative expectation' do
-          expect(5).to_not eq(4)
           expect(5).not_to eq(4)
         end
 
+        it 'passes a valid negative expectation with a split infinitive' do
+          expect(5).to_not eq(4)
+        end
+
         it 'fails an invalid positive expectation' do
           expect {
             expect(5).to eq(4)
@@ -50,10 +59,14 @@ module RSpec
         it 'fails an invalid negative expectation' do
           message = /expected 5 not to be a kind of Fixnum/
           expect {
-            expect(5).to_not be_a(Fixnum)
+            expect(5).not_to be_a(Fixnum)
           }.to fail_with(message)
+        end
+
+        it 'fails an invalid negative expectation with a split infinitive' do
+          message = /expected 5 not to be a kind of Fixnum/
           expect {
-            expect(5).not_to be_a(Fixnum)
+            expect(5).to_not be_a(Fixnum)
           }.to fail_with(message)
         end
 
@@ -69,6 +82,62 @@ module RSpec
           }.to raise_error(ArgumentError)
         end
       end
+
+      context "when passed a block" do
+        it 'can be used with a block matcher' do
+          expect { }.not_to raise_error
+        end
+
+        context 'when passed a value matcher' do
+          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `to`)' do
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
+            expect { }.to be_an(Object)
+          end
+
+          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `not_to`)' do
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
+            expect { }.not_to be_an(String)
+          end
+
+          it 'issues a warning to instruct the user to use a value expression or fix the matcher (for `to_not`)' do
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1, /block expectation/)
+            expect { }.to_not be_an(String)
+          end
+
+          it 'assumes a custom matcher that does not define `supports_block_expectations?` is not a block matcher (since it is relatively rare)' do
+            custom_matcher = Module.new do
+              def self.matches?(value); true; end
+              def self.description; "foo"; end
+            end
+
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 2, /block expectation/)
+            expect(3).to custom_matcher # to show the custom matcher can be used as a matcher
+            expect { 3 }.to custom_matcher
+          end
+
+          it "uses the matcher's `description` in the warning" do
+            custom_matcher = Module.new do
+              def self.matches?(value); true; end
+              def self.description; "matcher-description"; end
+            end
+
+            expect_deprecation_with_replacement(/\(matcher-description\)/)
+            expect { }.to custom_matcher
+          end
+
+          context 'when the matcher does not define `description` (since it is an optional part of the protocol)' do
+            it 'uses `inspect` in the warning instead' do
+              custom_matcher = Module.new do
+                def self.matches?(value); true; end
+                def self.inspect; "matcher-inspect"; end
+              end
+
+              expect_deprecation_with_replacement(/\(matcher-inspect\)/)
+              expect { }.to custom_matcher
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Object, "#should" do
   before(:each) do
     @target = "target"
-    @matcher = mock("matcher")
-    @matcher.stub!(:matches?).and_return(true)
-    @matcher.stub!(:failure_message_for_should)
+    @matcher = double("matcher")
+    @matcher.stub(:matches?).and_return(true)
+    @matcher.stub(:failure_message_for_should)
   end
 
   it "accepts and interacts with a matcher" do
@@ -32,6 +32,10 @@ describe Object, "#should" do
           true
         end
 
+        def respond_to?(name, include_all=false)
+          super || name == :proxied? || @target.respond_to?(name, include_all)
+        end
+
         def method_missing(name, *args)
           @target.send(name, *args)
         end
@@ -47,12 +51,12 @@ end
 describe Object, "#should_not" do
   before(:each) do
     @target = "target"
-    @matcher = mock("matcher")
+    @matcher = double("matcher")
   end
 
   it "accepts and interacts with a matcher" do
     @matcher.should_receive(:matches?).with(@target).and_return(false)
-    @matcher.stub!(:failure_message_for_should_not)
+    @matcher.stub(:failure_message_for_should_not)
 
     expect(@target).not_to @matcher
   end

data/spec/rspec/expectations/fail_with_spec.rb

@@ -1,6 +1,25 @@
 # encoding: utf-8
 require 'spec_helper'
 
+
+describe RSpec::Expectations, "#fail_with with diff of arrays" do
+  before { RSpec::Matchers.configuration.stub(:color? => false) }
+
+  it "splits items with newlines" do
+    expected_diff = "\nDiff:\n@@ -1 +1,3 @@\n+a\\nb\n+c\\nd\n"
+    expect {
+      RSpec::Expectations.fail_with("", [], ["a\nb", "c\nd"])
+    }.to fail_with(expected_diff)
+  end
+
+  it "shows inner arrays on a single line" do
+    expected_diff = "\nDiff:\n@@ -1 +1,3 @@\n+a\\nb\n+[\"c\\nd\"]\n"
+    expect {
+      RSpec::Expectations.fail_with("", [], ["a\nb", ["c\nd"]])
+    }.to fail_with(expected_diff)
+  end
+end
+
 describe RSpec::Expectations, "#fail_with with diff" do
   let(:differ) { double("differ") }