rspec-expectations 2.13.0 → 2.14.0.rc1

data/features/built_in_matchers/expect_error.feature

@@ -124,7 +124,7 @@ Feature: raise_error matcher
       describe Object, "#public_instance_methods" do
         it "does not raise" do
           expect { Object.public_instance_methods }.
-            to_not raise_error(NameError)
+            not_to raise_error(NameError)
         end
       end
       """
@@ -136,7 +136,7 @@ Feature: raise_error matcher
       """
       describe "#to_s" do
         it "does not raise" do
-          expect { Object.new.to_s }.to_not raise_error
+          expect { Object.new.to_s }.not_to raise_error
         end
       end
       """

data/features/built_in_matchers/start_with.feature

@@ -1,6 +1,6 @@
 Feature: start_with matcher
 
-  Use the `start_with` matcher to specify that a string or array starts with 
+  Use the `start_with` matcher to specify that a string or array starts with
   the expected characters or elements.
 
     ```ruby

data/features/built_in_matchers/throw_symbol.feature

@@ -26,11 +26,11 @@ Feature: throw_symbol matcher
       describe "throw" do
         specify { expect { throw :foo    }.to     throw_symbol }
         specify { expect { throw :bar, 7 }.to     throw_symbol }
-        specify { expect { 5 + 5         }.to_not throw_symbol }
+        specify { expect { 5 + 5         }.not_to throw_symbol }
 
         # deliberate failures
-        specify { expect { throw :foo    }.to_not throw_symbol }
-        specify { expect { throw :bar, 7 }.to_not throw_symbol }
+        specify { expect { throw :foo    }.not_to throw_symbol }
+        specify { expect { throw :bar, 7 }.not_to throw_symbol }
         specify { expect { 5 + 5         }.to     throw_symbol }
       end
       """
@@ -47,12 +47,12 @@ Feature: throw_symbol matcher
       describe "throw symbol" do
         specify { expect { throw :foo    }.to     throw_symbol(:foo) }
         specify { expect { throw :foo, 7 }.to     throw_symbol(:foo) }
-        specify { expect { 5 + 5         }.to_not throw_symbol(:foo) }
-        specify { expect { throw :bar    }.to_not throw_symbol(:foo) }
+        specify { expect { 5 + 5         }.not_to throw_symbol(:foo) }
+        specify { expect { throw :bar    }.not_to throw_symbol(:foo) }
 
         # deliberate failures
-        specify { expect { throw :foo    }.to_not throw_symbol(:foo) }
-        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo) }
+        specify { expect { throw :foo    }.not_to throw_symbol(:foo) }
+        specify { expect { throw :foo, 7 }.not_to throw_symbol(:foo) }
         specify { expect { 5 + 5         }.to     throw_symbol(:foo) }
         specify { expect { throw :bar    }.to     throw_symbol(:foo) }
       end
@@ -70,12 +70,12 @@ Feature: throw_symbol matcher
       """ruby
       describe "throw symbol with argument" do
         specify { expect { throw :foo, 7 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :foo, 8 }.to_not throw_symbol(:foo, 7) }
-        specify { expect { throw :bar, 7 }.to_not throw_symbol(:foo, 7) }
-        specify { expect { throw :foo    }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 8 }.not_to throw_symbol(:foo, 7) }
+        specify { expect { throw :bar, 7 }.not_to throw_symbol(:foo, 7) }
+        specify { expect { throw :foo    }.not_to throw_symbol(:foo, 7) }
 
         # deliberate failures
-        specify { expect { throw :foo, 7 }.to_not throw_symbol(:foo, 7) }
+        specify { expect { throw :foo, 7 }.not_to throw_symbol(:foo, 7) }
         specify { expect { throw :foo, 8 }.to     throw_symbol(:foo, 7) }
         specify { expect { throw :bar, 7 }.to     throw_symbol(:foo, 7) }
         specify { expect { throw :foo    }.to     throw_symbol(:foo, 7) }

data/features/built_in_matchers/yield.feature

@@ -30,6 +30,10 @@ Feature: yield matchers
           yield *args
         end
 
+        def self.yield_twice_with(*args)
+          2.times { yield *args }
+        end
+
         def self.raw_yield
           yield
         end
@@ -47,17 +51,28 @@ Feature: yield matchers
       describe "yield_control matcher" do
         specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control }
         specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_control }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.twice }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.exactly(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_least(1) }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_most(3).times }
 
         # deliberate failures
         specify { expect { |b| MyClass.yield_once_with(1, &b) }.not_to yield_control }
         specify { expect { |b| MyClass.dont_yield(&b) }.to yield_control }
+        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control.at_least(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.twice }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(2).times }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(1) }
+        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_most(3).times }
       end
       """
     When I run `rspec yield_control_spec.rb`
     Then the output should contain all of these:
-      | 4 examples, 2 failures                      |
-      | expected given block to yield control       |
-      | expected given block not to yield control   |
+      | 13 examples, 7 failures                                   |
+      | expected given block to yield control                     |
+      | expected given block not to yield control                 |
+      | expected given block not to yield control at least twice  |
+      | expected given block not to yield control at most 3 times |
 
   Scenario: yield_with_args matcher
     Given a file named "yield_with_args_spec.rb" with:

data/features/custom_matchers/define_diffable_matcher.feature

@@ -12,7 +12,7 @@ Feature: define diffable matcher
         match do |actual|
           actual == expected
         end
-        
+
         diffable
       end
 

data/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -9,19 +9,19 @@ Feature: define matcher outside rspec
       """ruby
       require "rspec/expectations"
       require "test/unit"
-      
+
       RSpec::Matchers.define :be_a_multiple_of do |expected|
         match do |actual|
           actual % expected == 0
         end
       end
-      
+
       class Test::Unit::TestCase
         include RSpec::Matchers
       end
-      
+
       class TestMultiples < Test::Unit::TestCase
-      
+
         def test_9_should_be_a_multiple_of_3
           9.should be_a_multiple_of(3)
         end
@@ -29,10 +29,10 @@ Feature: define matcher outside rspec
         def test_9_should_be_a_multiple_of_4
           9.should be_a_multiple_of(4)
         end
-        
+
       end
       """
     When I run `ruby test_multiples.rb`
-    Then the exit status should not be 0 
+    Then the exit status should not be 0
     And the output should contain "expected 9 to be a multiple of 4"
     And the output should contain "2 tests, 0 assertions, 0 failures, 1 errors"

data/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -1,7 +1,7 @@
 Feature: define matcher with fluent interface
 
   Use the chain() method to define matchers with a fluent interface.
-  
+
   Scenario: chained method with argumetn
     Given a file named "between_spec.rb" with:
       """ruby

data/features/customized_message.feature

@@ -3,7 +3,7 @@ Feature: customized message
   RSpec tries to provide useful failure messages, but for cases in which you
   want more specific information, you can define your own message right in the
   example. This works for any matcher _other than the operator matchers_.
-  
+
   Scenario: customize failure message
     Given a file named "example_spec.rb" with:
       """ruby

data/features/support/env.rb

@@ -1,5 +1,14 @@
 require 'aruba/cucumber'
 
+timeouts = { 'java' => 60 }
+
 Before do
-  @aruba_timeout_seconds = 15
+  @aruba_timeout_seconds = timeouts.fetch(RUBY_PLATFORM) { 15 }
 end
+
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
+  end
+end if RUBY_PLATFORM == 'java'
+

data/features/syntax_configuration.feature

@@ -47,6 +47,9 @@ Feature: Syntax Configuration
         config.expect_with :rspec do |c|
           c.syntax = :should
         end
+        config.mock_with :rspec do |c|
+          c.syntax = :should
+        end
       end
       """
     When I run `rspec disable_expect_syntax.rb syntaxes_spec.rb`

data/features/test_frameworks/test_unit.feature

@@ -1,11 +1,12 @@
 Feature: Test::Unit integration
 
-  RSpec-expectations is a stand-alone gem that can be used without
-  the rest of RSpec.  It can easily be used with another test
-  framework such as Test::Unit if you like RSpec's should/should_not
-  syntax but prefer the test organization of another framework.
+  RSpec-expectations is a stand-alone gem that can be used without the rest of
+  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
+  prefer RSpec's approach to expressing expectations, you can have both.
 
-  Scenario: Basic Test::Unit usage
+  The one downside is that failures are reported as errors with MiniTest.
+
+  Scenario: use rspec/expectations with Test::Unit
     Given a file named "rspec_expectations_test.rb" with:
       """ruby
       require 'test/unit'
@@ -17,30 +18,27 @@ Feature: Test::Unit integration
         end
 
         def be_an_int
-          RSpec.deprecate(:be_an_int, :be_an_integer)
+          # This is actually an internal rspec-expectations API, but is used
+          # here to demonstrate that deprecation warnings from within
+          # rspec-expectations work correcty without depending on rspec-core
+          RSpec.deprecate(:be_an_int, :replacement => :be_an_integer)
           be_an_integer
         end
 
         def test_passing_expectation
-          x = 1 + 3
-          x.should == 4
+          expect(1 + 3).to eq 4
         end
 
         def test_failing_expectation
-          array = [1, 2]
-          array.should be_empty
-        end
-
-        def test_expect_matcher
-          expect { @a = 5 }.to change { @a }.from(nil).to(5)
+          expect([1,2]).to be_empty
         end
 
-        def test_custom_matcher_and_deprecation_warning
-          1.should be_an_int
+        def test_custom_matcher_with_deprecation_warning
+          expect(1).to be_an_int
         end
       end
       """
      When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "4 tests, 0 assertions, 1 failures, 0 errors" or "4 tests, 0 assertions, 0 failures, 1 errors"
+     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
       And the output should contain "expected empty? to return true, got false"
       And the output should contain "be_an_int is deprecated"

data/lib/rspec/expectations.rb

@@ -37,7 +37,7 @@ module RSpec
   # `eq.failure_message_for_should_not`.
   #
   # rspec-expectations ships with a standard set of useful matchers, and writing
-  # your own matchers is quite simple. 
+  # your own matchers is quite simple.
   #
   # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
   # built-in matchers that ship with rspec-expectations, and how to write your

data/lib/rspec/expectations/deprecation.rb

@@ -1,38 +1,17 @@
 module RSpec
-  unless respond_to?(:deprecate)
-    class << self
-      # Used internally by RSpec to display standard deprecation warnings.
-      # This is also defined in rspec-core, but we can't assume it's loaded
-      # since rspec-expectations should be usable w/o rspec-core.
-      def deprecate(method, alternate_method=nil, version=nil)
-        version_string = version ? "rspec-#{version}" : "a future version of RSpec"
-
-        message = <<-NOTICE
-
-*****************************************************************
-DEPRECATION WARNING: you are using deprecated behaviour that will
-be removed from #{version_string}.
-
-#{caller(0)[2]}
-
-* #{method} is deprecated.
-NOTICE
-      if alternate_method
-        message << <<-ADDITIONAL
-* please use #{alternate_method} instead.
-ADDITIONAL
-      end
-
-        message << "*****************************************************************"
-        warn_deprecation(message)
-      end
-
-      # Used internally by RSpec to display custom deprecation warnings.  This
-      # is also defined in rspec-core, but we can't assume it's loaded since
-      # rspec-expectations should be usable w/o rspec-core.
-      def warn_deprecation(message)
-        warn(message)
+  module Expectations
+    module Deprecation
+      # @private
+      #
+      # Used internally to print deprecation warnings
+      def deprecate(deprecated, options={})
+        message = "DEPRECATION: #{deprecated} is deprecated."
+        message << " Use #{options[:replacement]} instead." if options[:replacement]
+        message << " Called from #{caller(0)[2]}."
+        warn message
       end
     end
   end
+
+  extend(Expectations::Deprecation) unless respond_to?(:deprecate)
 end

data/lib/rspec/expectations/differ.rb

@@ -6,11 +6,11 @@ module RSpec
   module Expectations
     class Differ
       # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-      def diff_as_string(data_new, data_old)
-        data_old = data_old.split(/\n/).map! { |e| e.chomp }
-        data_new = data_new.split(/\n/).map! { |e| e.chomp }
+      def diff_as_string(input_data_new, input_data_old)
+        output = matching_encoding("", input_data_old)
+        data_old = input_data_old.split(matching_encoding("\n", input_data_old)).map! { |e| e.chomp }
+        data_new = input_data_new.split(matching_encoding("\n", input_data_new)).map! { |e| e.chomp }
         diffs = Diff::LCS.diff(data_old, data_new)
-        output = ""
         return output if diffs.empty?
         oldhunk = hunk = nil
         file_length_difference = 0
@@ -33,16 +33,24 @@ module RSpec
                 hunk.unshift(oldhunk)
               end
             else
-              output << oldhunk.diff(format)
+              output << matching_encoding(oldhunk.diff(format).to_s, output)
             end
           ensure
             oldhunk = hunk
-            output << "\n"
+            output << matching_encoding("\n", output)
           end
         end
         #Handle the last remaining hunk
-        output << oldhunk.diff(format) << "\n"
+        output << matching_encoding(oldhunk.diff(format).to_s,output)
+        output << matching_encoding("\n",output)
         color_diff output
+      rescue Encoding::CompatibilityError
+        if input_data_new.encoding != input_data_old.encoding
+          "Could not produce a diff because the encoding of the actual string (#{input_data_old.encoding}) "+
+          "differs from the encoding of the expected string (#{input_data_new.encoding})"
+        else
+          "Could not produce a diff because of the encoding of the string (#{input_data_old.encoding})"
+        end
       end
 
       def diff_as_object(actual, expected)
@@ -108,6 +116,16 @@ module RSpec
           PP.pp(object,"")
         end
       end
+
+      if String.method_defined?(:encoding)
+        def matching_encoding(string, source)
+          string.encode(source.encoding)
+        end
+      else
+        def matching_encoding(string, source)
+          string
+        end
+      end
     end
 
   end

data/lib/rspec/expectations/expectation_target.rb

@@ -7,8 +7,8 @@ module RSpec
     #   # used with `to`
     #   expect(actual).to eq(3)
     #
-    #   # with `to_not`
-    #   expect(actual).to_not eq(3)
+    #   # with `not_to`
+    #   expect(actual).not_to eq(3)
     class ExpectationTarget
       class << self
         attr_accessor :deprecated_should_enabled
@@ -36,29 +36,28 @@ module RSpec
 
       # Runs the given expectation, passing if `matcher` returns false.
       # @example
-      #   expect(value).to_not eq(5)
       #   expect(value).not_to eq(5)
       # @param [Matcher]
       #   matcher
       # @param [String] message optional message to display when the expectation fails
       # @return [Boolean] false if the negative expectation succeeds (else raises)
       # @see RSpec::Matchers
-      def to_not(matcher=nil, message=nil, &block)
-        prevent_operator_matchers(:to_not, matcher)
+      def not_to(matcher=nil, message=nil, &block)
+        prevent_operator_matchers(:not_to, matcher)
         RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
       end
-      alias not_to to_not
+      alias to_not not_to
 
       def self.enable_deprecated_should
         return if deprecated_should_enabled?
 
         def should(*args)
-          RSpec.deprecate "`expect { }.should`", "`expect { }.to`", 3
+          RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
           @target.should(*args)
         end
 
         def should_not(*args)
-          RSpec.deprecate "`expect { }.should_not`", "`expect { }.to_not`", 3
+          RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
           @target.should_not(*args)
         end
 

data/lib/rspec/expectations/extensions/object.rb

@@ -6,17 +6,7 @@ module RSpec
       def const_missing(name)
         case name
         when :Rspec, :Spec
-          RSpec.warn_deprecation <<-WARNING
-*****************************************************************
-DEPRECATION WARNING: you are using a deprecated constant that will
-be removed from a future version of RSpec.
-
-#{caller(0)[2]}
-
-* #{name} is deprecated.
-* RSpec is the new top-level module in RSpec-2
-***************************************************************
-WARNING
+          RSpec.deprecate(name.to_s, :replacement => "RSpec")
           RSpec
         else
           begin
@@ -31,7 +21,7 @@ WARNING
 
     # @deprecated (no replacement)
     def differ=(ignore)
-      RSpec.deprecate("RSpec::Expectations.differ=(differ)", "nothing at all (diffing is now automatic and no longer configurable)")
+      RSpec.deprecate("RSpec::Expectations.differ=(differ)")
     end
   end
 end