rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/expectations/encoded_string_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module RSpec::Expectations
+  describe EncodedString do
+    let(:target_encoding) { 'UTF-8' }
+
+    if String.method_defined?(:encoding)
+
+      describe '#source_encoding' do
+        it 'knows the original encoding of the string' do
+          str = EncodedString.new("abc".encode('ASCII-8BIT'), "UTF-8")
+          expect( str.source_encoding.to_s ).to eq('ASCII-8BIT')
+        end
+      end
+
+      describe '#<<' do
+        context 'with strings that can be converted to the target encoding' do
+          it 'encodes and appends the string' do
+            valid_ascii_string = "abc".force_encoding("ASCII-8BIT")
+            valid_unicode_string = "\xE2\x82\xAC".force_encoding('UTF-8')
+
+            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << valid_ascii_string
+            expect(resulting_string).to eq "\xE2\x82\xACabc".force_encoding('UTF-8')
+          end
+        end
+
+        context 'with a string that cannot be converted to the target encoding' do
+          it 'replaces undefined characters with either a ? or a unicode ?' do
+            ascii_string = "\xAE".force_encoding("ASCII-8BIT")
+            valid_unicode_string = "\xE2\x82\xAC".force_encoding('UTF-8')
+
+            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << ascii_string
+            expected_bytes = [226, 130, 172, "?".unpack("c").first]
+            actual_bytes = resulting_string.each_byte.to_a
+
+            expect(actual_bytes).to eq(expected_bytes)
+          end
+        end
+
+        context 'with two ascii strings with a target encoding of UTF-8 ' do
+          it 'has an encoding of UTF-8' do
+            ascii_string = 'abc'.force_encoding("ASCII-8BIT")
+            other_ascii_string = '123'.force_encoding("ASCII-8BIT")
+
+            resulting_string = build_encoded_string(ascii_string, target_encoding) << other_ascii_string
+            expect(resulting_string.encoding.to_s).to eq 'UTF-8'
+          end
+        end
+      end
+
+      describe '#split' do
+        it 'splits the string based on the delimiter accounting for encoding' do
+          wrapped_string = "aaaaaaaaaaa\xAEaaaaa".force_encoding("ASCII-8BIT")
+
+          expect {
+            build_encoded_string(wrapped_string, target_encoding).split("\xE2\x82\xAC".force_encoding("UTF-8"))
+          }.not_to raise_error
+        end
+      end
+
+      def build_encoded_string(string, target_encoding)
+        EncodedString.new(string, target_encoding)
+      end
+    else
+
+      describe '#source_encoding' do
+        it 'defaults to US-ASCII' do
+          str = EncodedString.new("abc", "UTF-8")
+          expect( str.source_encoding ).to eq('US-ASCII')
+        end
+      end
+    end
+  end
+end

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

@@ -4,18 +4,18 @@ describe Object, "#should" do
   before(:each) do
     @target = "target"
     @matcher = double("matcher")
-    @matcher.stub(:matches?).and_return(true)
-    @matcher.stub(:failure_message_for_should)
+    allow(@matcher).to receive(:matches?).and_return(true)
+    allow(@matcher).to receive(:failure_message)
   end
 
   it "accepts and interacts with a matcher" do
-    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    expect(@matcher).to 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")
+  it "asks for a failure_message when matches? returns false" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(false)
+    expect(@matcher).to receive(:failure_message).and_return("the failure message")
     expect {
       expect(@target).to @matcher
     }.to fail_with("the failure message")
@@ -51,15 +51,15 @@ describe Object, "#should_not" do
   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)
+    expect(@matcher).to receive(:matches?).with(@target).and_return(false)
+    allow(@matcher).to receive(:failure_message_when_negated)
 
     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")
+  it "asks for a failure_message_when_negated when matches? returns true" do
+    expect(@matcher).to receive(:matches?).with(@target).and_return(true)
+    expect(@matcher).to receive(:failure_message_when_negated).and_return("the failure message for should not")
     expect {
       expect(@target).not_to @matcher
     }.to fail_with("the failure message for should not")

data/spec/rspec/expectations/fail_with_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 
 describe RSpec::Expectations, "#fail_with with diff of arrays" do
-  before { RSpec::Matchers.configuration.stub(:color? => false) }
+  before { allow(RSpec::Matchers.configuration).to receive_messages(:color? => false) }
 
   it "splits items with newlines" do
     expected_diff = "\nDiff:\n@@ -1 +1,3 @@\n+a\\nb\n+c\\nd\n"
@@ -24,11 +24,11 @@ describe RSpec::Expectations, "#fail_with with diff" do
   let(:differ) { double("differ") }
 
   before(:each) do
-    RSpec::Expectations.stub(:differ) { differ }
+    allow(RSpec::Expectations).to receive(:differ) { differ }
   end
 
   it "calls differ if expected/actual are not strings (or numbers or procs)" do
-    differ.should_receive(:diff_as_object).and_return("diff")
+    expect(differ).to receive(:diff_as_object).and_return("diff")
     expect {
       RSpec::Expectations.fail_with "the message", Object.new, Object.new
     }.to fail_with("the message\nDiff:diff")
@@ -37,7 +37,7 @@ describe RSpec::Expectations, "#fail_with with diff" do
   context "with two strings" do
     context "and actual is multiline" do
       it "calls differ" do
-        differ.should_receive(:diff_as_string).and_return("diff")
+        expect(differ).to receive(:diff_as_string).and_return("diff")
         expect {
           RSpec::Expectations.fail_with "the message", "expected\nthis", "actual"
         }.to fail_with("the message\nDiff:diff")
@@ -46,7 +46,7 @@ describe RSpec::Expectations, "#fail_with with diff" do
 
     context "and expected is multiline" do
       it "calls differ" do
-        differ.should_receive(:diff_as_string).and_return("diff")
+        expect(differ).to receive(:diff_as_string).and_return("diff")
         expect {
           RSpec::Expectations.fail_with "the message", "expected", "actual\nthat"
         }.to fail_with("the message\nDiff:diff")
@@ -55,7 +55,7 @@ describe RSpec::Expectations, "#fail_with with diff" do
 
     context "and both are single line strings" do
       it "does not call differ" do
-        differ.should_not_receive(:diff_as_string)
+        expect(differ).not_to receive(:diff_as_string)
         expect {
           RSpec::Expectations.fail_with("the message", "expected", "actual")
         }.to fail_with("the message")
@@ -64,7 +64,7 @@ describe RSpec::Expectations, "#fail_with with diff" do
 
     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)
+        expect(differ).not_to 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")
@@ -75,7 +75,7 @@ describe RSpec::Expectations, "#fail_with with diff" do
       end
 
       it 'diffs when they are multiline' do
-        differ.should_receive(:diff_as_string).and_return("diff")
+        expect(differ).to 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")

data/spec/rspec/expectations/handler_spec.rb

@@ -25,13 +25,13 @@ module ExampleExpectations
       "expected #{@expected}, got #{@target}"
     end
 
-    def negative_failure_message
+    def failure_message_when_negated
       "expected not #{@expected}, got #{@target}"
     end
   end
 
   class PositiveOnlyMatcher < ArbitraryMatcher
-    undef negative_failure_message rescue nil
+    undef failure_message_when_negated rescue nil
   end
 
   def arbitrary_matcher(*args, &block)
@@ -51,22 +51,22 @@ module RSpec
         it "asks the matcher if it matches" do
           matcher = double("matcher")
           actual = Object.new
-          matcher.should_receive(:matches?).with(actual).and_return(true)
+          expect(matcher).to receive(:matches?).with(actual).and_return(true)
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "returns the match value" do
           matcher = double("matcher")
           actual = Object.new
-          matcher.should_receive(:matches?).with(actual).and_return(:this_value)
+          expect(matcher).to receive(:matches?).with(actual).and_return(: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
-          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
+        it "calls failure_message if the matcher implements it" do
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message")
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
         end
@@ -74,44 +74,44 @@ module RSpec
         it "calls fail if matcher.diffable?" do
           matcher = double("matcher",
             :diffable? => true,
-            :failure_message_for_should => "message",
+            :failure_message => "message",
             :matches? => false,
             :expected => 1,
             :actual   => 2
           )
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message", 1, 2)
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
         end
 
-        it "calls failure_message if the matcher does not implement failure_message_for_should" do
+        it "calls failure_message if the matcher does not implement failure_message" do
           matcher = double("matcher", :failure_message => "message", :matches? => false)
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message")
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
 
         end
 
         it "uses the custom failure message when one is provided" do
-          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
         end
 
         it "uses the custom failure message when one is provided as a callable object" do
-          matcher = double("matcher", :failure_message_for_should => "message", :matches? => false)
+          matcher = double("matcher", :failure_message => "message", :matches? => false)
           actual = Object.new
 
           failure_message = double("failure message", :call => "custom")
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
 
           RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, failure_message)
         end
@@ -121,81 +121,59 @@ module RSpec
     describe NegativeExpectationHandler do
       describe "#handle_matcher" do
         it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
-          matcher = double("matcher", :does_not_match? => true, :negative_failure_message => nil)
+          matcher = double("matcher", :does_not_match? => true, :failure_message_when_negated => nil)
           actual = Object.new
-          matcher.should_receive(:does_not_match?).with(actual).and_return(true)
+          expect(matcher).to receive(:does_not_match?).with(actual).and_return(true)
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
           matcher = double("matcher")
           actual = Object.new
-          matcher.stub(:negative_failure_message)
-          matcher.should_receive(:matches?).with(actual).and_return(false)
+          allow(matcher).to receive(:failure_message_when_negated)
+          expect(matcher).to receive(:matches?).with(actual).and_return(false)
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "returns the match value" do
           matcher = double("matcher")
           actual = Object.new
-          matcher.should_receive(:matches?).with(actual).and_return(false)
-          matcher.stub(:negative_failure_message).and_return("ignore")
+          expect(matcher).to receive(:matches?).with(actual).and_return(false)
+          allow(matcher).to receive(:failure_message_when_negated).and_return("ignore")
           expect(RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)).to be_falsey
         end
 
-
-        it "calls failure_message_for_should_not if the matcher implements it" do
-          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
-          actual = Object.new
-
-          ::RSpec::Expectations.should_receive(:fail_with).with("message")
-
-          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
-
-        end
-
-        it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do
-          matcher = double("matcher", :negative_failure_message => "message", :matches? => true)
-          actual = Object.new
-
-          ::RSpec::Expectations.should_receive(:fail_with).with("message")
-
-          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
-
-        end
-
-
         it "calls fail if matcher.diffable?" do
           matcher = double("matcher",
             :diffable? => true,
-            :failure_message_for_should_not => "message",
+            :failure_message_when_negated => "message",
             :matches? => true,
             :expected => 1,
             :actual   => 2
           )
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+          expect(::RSpec::Expectations).to receive(:fail_with).with("message", 1, 2)
 
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
         end
 
         it "uses the custom failure message when one is provided" do
-          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          matcher = double("matcher", :failure_message_when_negated => "message", :matches? => true)
           actual = Object.new
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
 
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
         end
 
         it "uses the custom failure message when one is provided as a callable object" do
-          matcher = double("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          matcher = double("matcher", :failure_message_when_negated => "message", :matches? => true)
           actual = Object.new
 
           failure_message = double("failure message", :call => "custom")
 
-          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+          expect(::RSpec::Expectations).to receive(:fail_with).with("custom")
 
           RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, failure_message)
         end

data/spec/rspec/expectations/minitest_integration_spec.rb

@@ -0,0 +1,27 @@
+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 MinitestIntegration
+
+      it "includes itself in Minitest::Test" do
+        with_minitest_loaded do
+          minitest_case = MiniTest::Test.allocate
+          sample_matchers.each do |sample_matcher|
+              expect(minitest_case).to respond_to(sample_matcher)
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/spec/rspec/expectations/syntax_spec.rb

@@ -20,118 +20,68 @@ module RSpec
 
         describe "expect(...).to" do
           it "prints a warning when the message object isn't a String" do
-            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
             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)
+            expect(warner).not_to receive(:warn)
             expect(3).to eq(3), "a string"
           end
 
           it "doesn't print a warning when message responds to to_str" do
-            warner.should_not_receive(:warn)
+            expect(warner).not_to receive(:warn)
             expect(3).to eq(3), string_like_object
           end
 
           it "prints a warning when the message object handles to_s but not to_str" do
-            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
             expect(3).to eq(3), insufficiently_string_like_object
           end
 
           it "doesn't print a warning when message responds to call" do
-            warner.should_not_receive(:warn)
+            expect(warner).not_to receive(:warn)
             expect(3).to eq(3), callable_object
           end
         end
 
         describe "expect(...).not_to" do
           it "prints a warning when the message object isn't a String" do
-            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
             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)
+            expect(warner).not_to receive(:warn)
             expect(3).not_to eq(4), "a string"
           end
 
           it "doesn't print a warning when message responds to to_str" do
-            warner.should_not_receive(:warn)
+            expect(warner).not_to receive(:warn)
             expect(3).not_to eq(4), string_like_object
           end
 
           it "prints a warning when the message object handles to_s but not to_str" do
-            warner.should_receive(:warn).with(/ignoring.*message/)
+            expect(warner).to receive(:warn).with(/ignoring.*message/)
             expect(3).not_to eq(4), insufficiently_string_like_object
           end
 
           it "doesn't print a warning when message responds to call" do
-            warner.should_not_receive(:warn)
+            expect(warner).not_to receive(:warn)
             expect(3).not_to eq(4), callable_object
           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')" }
+      describe "enabling the should syntax on something other than the default syntax host" do
+        include_context "with the default expectation syntax"
 
-        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_falsey
-            expect(Syntax.expect_enabled?).to be_truthy
-          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_truthy
-            expect(Syntax.expect_enabled?).to be_truthy
-          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
+        it "continues to warn about the should syntax" do
+          my_host = Class.new
+          expect(RSpec).to receive(:deprecate)
+          Syntax.enable_should(my_host)
 
-        context "when only :should is enabled", :uses_only_should do
-          before do
-            Syntax.should_enabled?.should be_truthy
-            Syntax.expect_enabled?.should be_falsey
-          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
+          3.should eq 3
         end
       end
     end