rspec-expectations 2.12.1 → 2.13.0

data/lib/rspec/matchers/matcher.rb

@@ -25,7 +25,7 @@ module RSpec
         end
 
         PERSISTENT_INSTANCE_VARIABLES = [
-          :@name, :@declarations, :@diffable, :@messages,
+          :@name, :@declarations, :@diffable,
           :@match_block, :@match_for_should_not_block,
           :@expected_exception
         ].to_set
@@ -37,6 +37,7 @@ module RSpec
             instance_variables.map {|ivar| ivar.intern}.each do |ivar|
               instance_variable_set(ivar, nil) unless (PERSISTENT_INSTANCE_VARIABLES + [:@expected]).include?(ivar)
             end
+            @messages = {}
             making_declared_methods_public do
               instance_eval_with_args(*@expected, &@declarations)
             end
@@ -230,7 +231,7 @@ module RSpec
 
         def method_missing(method, *args, &block)
           if matcher_execution_context.respond_to?(method)
-            matcher_execution_context.send method, *args, &block
+            matcher_execution_context.__send__ method, *args, &block
           else
             super(method, *args, &block)
           end
@@ -272,7 +273,7 @@ module RSpec
           if @messages.has_key?(key)
             @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
           else
-            send("default_#{key}")
+            __send__("default_#{key}")
           end
         end
 

data/lib/rspec/matchers/operator_matcher.rb

@@ -32,7 +32,7 @@ module RSpec
       def self.use_custom_matcher_or_delegate(operator)
         define_method(operator) do |expected|
           if uses_generic_implementation_of?(operator) && matcher = OperatorMatcher.get(@actual.class, operator)
-            @actual.send(::RSpec::Matchers.last_should, matcher.new(expected))
+            @actual.__send__(::RSpec::Matchers.last_should, matcher.new(expected))
           else
             eval_match(@actual, operator, expected)
           end

data/lib/rspec/matchers/pretty.rb

@@ -7,7 +7,7 @@ module RSpec
 
       def to_sentence(words)
         return "" unless words
-        words = Array(words).map{|w| w.inspect}
+        words = Array(words).map { |w| to_word(w) }
         case words.length
           when 0
             ""
@@ -34,6 +34,10 @@ module RSpec
         result
       end
 
+      def to_word(item)
+        item.respond_to?(:description) ? item.description : item.inspect
+      end
+
       def name_to_sentence
         split_words(name)
       end

data/spec/rspec/expectations/differ_spec.rb

@@ -36,7 +36,7 @@ module RSpec
 EOD
 
           diff = differ.diff_as_string(expected, actual)
-          diff.should eql(expected_diff)
+          expect(diff).to eql(expected_diff)
         end
       end
 
@@ -71,15 +71,7 @@ EOD
 EOD
 
           diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-
-        it "outputs a message if the diff is empty" do
-          diff = differ.diff_as_object('foo', 'foo')
-          diff.should eq(
-            "foo.==(foo) returned false even though the diff between " \
-            "foo and foo is empty. Check the implementation of foo.==."
-          )
+          expect(diff).to eq expected_diff
         end
 
         it "outputs unified diff message of two arrays" do
@@ -101,7 +93,7 @@ EOD
 EOD
 
           diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
+          expect(diff).to eq expected_diff
         end
 
         it "outputs unified diff message of two hashes" do
@@ -120,7 +112,7 @@ EOD
 EOD
 
           diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
+          expect(diff).to eq expected_diff
         end
 
         it "outputs unified diff of single line strings" do
@@ -135,7 +127,7 @@ EOD
 EOD
 
           diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
+          expect(diff).to eq expected_diff
         end
 
         it "outputs unified diff of multi line strings" do
@@ -151,7 +143,7 @@ EOD
 EOD
 
           diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
+          expect(diff).to eq expected_diff
         end
       end
     end
@@ -168,10 +160,11 @@ EOD
 
 
         diff = differ.diff_as_string(expected,actual)
-        diff.should == expected_diff
+        expect(diff).to eq expected_diff
       end
     end
 
     end
   end
 end
+

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -8,24 +8,28 @@ module RSpec
     describe ExpectationTarget do
       context 'when constructed via #expect' do
         it 'constructs a new instance targetting the given argument' do
-          expect(7).target.should eq(7)
+          expect(expect(7).target).to eq(7)
         end
 
         it 'constructs a new instance targetting the given block' do
           block = lambda {}
-          expect(&block).target.should be(block)
+          expect(expect(&block).target).to be(block)
         end
 
         it 'raises an ArgumentError when given an argument and a block' do
-          lambda { expect(7) { } }.should raise_error(ArgumentError)
+          expect {
+            expect(7) { }
+          }.to raise_error(ArgumentError)
         end
 
         it 'raises an ArgumentError when given neither an argument nor a block' do
-          lambda { expect }.should raise_error(ArgumentError)
+          expect {
+            expect
+          }.to raise_error(ArgumentError)
         end
 
         it 'can be passed nil' do
-          expect(nil).target.should be_nil
+          expect(expect(nil).target).to be_nil
         end
 
         it 'passes a valid positive expectation' do
@@ -38,13 +42,19 @@ module RSpec
         end
 
         it 'fails an invalid positive expectation' do
-          lambda { expect(5).to eq(4) }.should fail_with(/expected: 4.*got: 5/m)
+          expect {
+            expect(5).to eq(4)
+          }.to fail_with(/expected: 4.*got: 5/m)
         end
 
         it 'fails an invalid negative expectation' do
           message = /expected 5 not to be a kind of Fixnum/
-          lambda { expect(5).to_not be_a(Fixnum) }.should fail_with(message)
-          lambda { expect(5).not_to be_a(Fixnum) }.should fail_with(message)
+          expect {
+            expect(5).to_not be_a(Fixnum)
+          }.to fail_with(message)
+          expect {
+            expect(5).not_to be_a(Fixnum)
+          }.to fail_with(message)
         end
 
         it 'does not support operator matchers from #to' do

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

@@ -7,18 +7,18 @@ describe Object, "#should" do
     @matcher.stub!(:matches?).and_return(true)
     @matcher.stub!(:failure_message_for_should)
   end
-  
+
   it "accepts and interacts with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)    
-    @target.should @matcher
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    expect(@target).to @matcher
   end
-  
+
   it "asks for a failure_message_for_should when matches? returns false" do
     @matcher.should_receive(:matches?).with(@target).and_return(false)
     @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
-    lambda {
-      @target.should @matcher
-    }.should fail_with("the failure message")
+    expect {
+      expect(@target).to @matcher
+    }.to fail_with("the failure message")
   end
 
   context "on interpretters that have BasicObject", :if => defined?(BasicObject) do
@@ -39,7 +39,7 @@ describe Object, "#should" do
     end
 
     it 'works properly on BasicObject-subclassed proxy objects' do
-      proxy_class.new(Object.new).should be_proxied
+      expect(proxy_class.new(Object.new)).to be_proxied
     end
   end
 end
@@ -49,19 +49,19 @@ describe Object, "#should_not" do
     @target = "target"
     @matcher = mock("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)
-    
-    @target.should_not @matcher
+
+    expect(@target).not_to @matcher
   end
-  
+
   it "asks for a failure_message_for_should_not when matches? returns true" do
     @matcher.should_receive(:matches?).with(@target).and_return(true)
     @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
-    lambda {
-      @target.should_not @matcher
-    }.should fail_with("the failure message for should not")
+    expect {
+      expect(@target).not_to @matcher
+    }.to fail_with("the failure message for should not")
   end
 end

data/spec/rspec/expectations/fail_with_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require 'spec_helper'
 
 describe RSpec::Expectations, "#fail_with with diff" do
@@ -9,62 +10,86 @@ describe RSpec::Expectations, "#fail_with with diff" do
 
   it "calls differ if expected/actual are not strings (or numbers or procs)" do
     differ.should_receive(:diff_as_object).and_return("diff")
-    lambda {
+    expect {
       RSpec::Expectations.fail_with "the message", Object.new, Object.new
-    }.should fail_with("the message\nDiff:diff")
+    }.to fail_with("the message\nDiff:diff")
   end
 
   context "with two strings" do
     context "and actual is multiline" do
       it "calls differ" do
         differ.should_receive(:diff_as_string).and_return("diff")
-        lambda {
+        expect {
           RSpec::Expectations.fail_with "the message", "expected\nthis", "actual"
-        }.should fail_with("the message\nDiff:diff")
+        }.to fail_with("the message\nDiff:diff")
       end
     end
 
     context "and expected is multiline" do
       it "calls differ" do
         differ.should_receive(:diff_as_string).and_return("diff")
-        lambda {
+        expect {
           RSpec::Expectations.fail_with "the message", "expected", "actual\nthat"
-        }.should fail_with("the message\nDiff:diff")
+        }.to fail_with("the message\nDiff:diff")
       end
     end
 
     context "and both are single line strings" do
       it "does not call differ" do
         differ.should_not_receive(:diff_as_string)
-        lambda {
+        expect {
           RSpec::Expectations.fail_with("the message", "expected", "actual")
-        }.should fail_with("the message")
+        }.to fail_with("the message")
+      end
+    end
+
+    context "and they are UTF-16LE encoded", :if => String.method_defined?(:encode) do
+      it 'does not diff when they are not multiline' do
+        differ.should_not_receive(:diff_as_string)
+
+        str_1 = "This is a pile of poo: 💩".encode("UTF-16LE")
+        str_2 = "This is a pile of poo: 💩".encode("UTF-16LE")
+
+        expect {
+          RSpec::Expectations.fail_with("the message", str_1, str_2)
+        }.to fail_with("the message")
+      end
+
+      it 'diffs when they are multiline' do
+        differ.should_receive(:diff_as_string).and_return("diff")
+
+        str_1 = "This is a pile of poo:\n💩".encode("UTF-16LE")
+        str_2 = "This is a pile of poo:\n💩".encode("UTF-16LE")
+
+        expect {
+          RSpec::Expectations.fail_with("the message", str_1, str_2)
+        }.to fail_with("the message\nDiff:diff")
       end
     end
   end
 
   it "does not call differ if no expected/actual" do
-    lambda {
+    expect {
       RSpec::Expectations.fail_with "the message"
-    }.should fail_with("the message")
+    }.to fail_with("the message")
   end
 
   it "does not call differ expected is Numeric" do
-    lambda {
+    expect {
       RSpec::Expectations.fail_with "the message", 1, "1"
-    }.should fail_with("the message")
+    }.to fail_with("the message")
   end
 
   it "does not call differ when actual is Numeric" do
-    lambda {
+    expect {
       RSpec::Expectations.fail_with "the message", "1", 1
-    }.should fail_with("the message")
+    }.to fail_with("the message")
   end
 
   it "does not call differ if expected or actual are procs" do
-    lambda {
+    expect {
       RSpec::Expectations.fail_with "the message", lambda {}, lambda {}
-    }.should fail_with("the message")
+    }.to fail_with("the message")
   end
 end
 

data/spec/rspec/expectations/handler_spec.rb

@@ -59,7 +59,7 @@ module RSpec
           matcher = mock("matcher")
           actual = Object.new
           matcher.should_receive(:matches?).with(actual).and_return(:this_value)
-          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value
+          expect(RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)).to eq :this_value
         end
 
         it "calls failure_message_for_should if the matcher implements it" do
@@ -129,7 +129,7 @@ module RSpec
           actual = Object.new
           matcher.should_receive(:matches?).with(actual).and_return(false)
           matcher.stub!(:negative_failure_message).and_return("ignore")
-          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false
+          expect(RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)).to be_false
         end
 
 
@@ -185,20 +185,20 @@ module RSpec
       include ExampleExpectations
 
       it "handles submitted args" do
-        5.should arbitrary_matcher(:expected => 5)
-        5.should arbitrary_matcher(:expected => "wrong").with(5)
-        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
-        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
-        5.should_not arbitrary_matcher(:expected => 4)
-        5.should_not arbitrary_matcher(:expected => 5).with(4)
-        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
-        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+        expect(5).to arbitrary_matcher(:expected => 5)
+        expect(5).to arbitrary_matcher(:expected => "wrong").with(5)
+        expect { expect(5).to arbitrary_matcher(:expected => 4) }.to fail_with("expected 4, got 5")
+        expect { expect(5).to arbitrary_matcher(:expected => 5).with(4) }.to fail_with("expected 4, got 5")
+        expect(5).to_not arbitrary_matcher(:expected => 4)
+        expect(5).to_not arbitrary_matcher(:expected => 5).with(4)
+        expect { expect(5).to_not arbitrary_matcher(:expected => 5) }.to fail_with("expected not 5, got 5")
+        expect { expect(5).to_not arbitrary_matcher(:expected => 4).with(5) }.to fail_with("expected not 5, got 5")
       end
 
       it "handles the submitted block" do
-        5.should arbitrary_matcher { 5 }
-        5.should arbitrary_matcher(:expected => 4) { 5 }
-        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+        expect(5).to arbitrary_matcher { 5 }
+        expect(5).to arbitrary_matcher(:expected => 4) { 5 }
+        expect(5).to arbitrary_matcher(:expected => 4).with(5) { 3 }
       end
 
     end

data/spec/rspec/expectations/syntax_spec.rb

@@ -2,31 +2,93 @@ require 'spec_helper'
 
 module RSpec
   module Expectations
-    module Syntax
-      describe "the should and should_not expectations" do
+    describe Syntax do
+      context "when passing a message to an expectation" do
         let(:warner) { ::Kernel }
 
-        describe "#should" do
+        describe "expect(...).to" do
           it "prints a warning when the message object isn't a String" do
             warner.should_receive(:warn).with /ignoring.*message/
-            3.should eq(3), :not_a_string
+            expect(3).to eq(3), :not_a_string
           end
 
           it "doesn't print a warning when message is a String" do
             warner.should_not_receive(:warn)
-            3.should eq(3), "a string"
+            expect(3).to eq(3), "a string"
           end
         end
 
-        describe "#should_not" do
+        describe "expect(...).to_not" do
           it "prints a warning when the message object isn't a String" do
             warner.should_receive(:warn).with /ignoring.*message/
-            3.should_not eq(4), :not_a_string
+            expect(3).not_to eq(4), :not_a_string
           end
 
           it "doesn't print a warning when message is a String" do
             warner.should_not_receive(:warn)
-            3.should_not eq(4), "a string"
+            expect(3).not_to eq(4), "a string"
+          end
+        end
+      end
+
+      describe "expression generation" do
+        let(:target) { "foo" }
+        let(:expectation) { "eq('bar')" }
+        let(:positive_expect_example) { "expect(foo).to eq('bar')" }
+        let(:positive_should_example) { "foo.should eq('bar')" }
+        let(:negative_expect_example) { "expect(foo).not_to eq('bar')" }
+        let(:negative_should_example) { "foo.should_not eq('bar')" }
+
+        def positive_expression
+          Syntax.positive_expression(target, expectation)
+        end
+
+        def negative_expression
+          Syntax.negative_expression(target, expectation)
+        end
+
+        context "when only :expect is enabled" do
+          before do
+            expect(Syntax.should_enabled?).to be_false
+            expect(Syntax.expect_enabled?).to be_true
+          end
+
+          it 'generates a positive expression using the expect syntax' do
+            expect(positive_expression).to eq(positive_expect_example)
+          end
+
+          it 'generates a negative expression using the expect syntax' do
+            expect(negative_expression).to eq(negative_expect_example)
+          end
+        end
+
+        context "when both :should and :expect are enabled", :uses_should do
+          before do
+            expect(Syntax.should_enabled?).to be_true
+            expect(Syntax.expect_enabled?).to be_true
+          end
+
+          it 'generates a positive expression using the expect syntax' do
+            expect(positive_expression).to eq(positive_expect_example)
+          end
+
+          it 'generates a negative expression using the expect syntax' do
+            expect(negative_expression).to eq(negative_expect_example)
+          end
+        end
+
+        context "when only :should is enabled", :uses_only_should do
+          before do
+            Syntax.should_enabled?.should be_true
+            Syntax.expect_enabled?.should be_false
+          end
+
+          it 'generates a positive expression using the expect syntax' do
+            positive_expression.should eq(positive_should_example)
+          end
+
+          it 'generates a negative expression using the expect syntax' do
+            negative_expression.should eq(negative_should_example)
           end
         end
       end