rspec-expectations 2.13.0 → 2.99.0

data/features/built_in_matchers/README.md

@@ -1,55 +1,55 @@
 # Built-in Matchers
 
-Here is a list of matchers that ship with rspec-expectations. Each matcher
-can be used with `should` or `should_not` e.g.
+rspec-expectations ships with a number of built-in matchers.
+Each matcher can be used with `expect(..).to` or `expect(..).not_to` to define
+positive and negative expectations respectively on an object. Most matchers can
+also be accessed using the `(...).should` and `(...).should_not` syntax, see
+[using should syntax](https://github.com/rspec/rspec-expectations/blob/master/Should.md)
+for why we recommend using `expect`.
 
-    result.should eq(3)
-    list.should_not be_empty
+e.g.
+
+    expect(result).to   eq(3)
+    expect(list).not_to be_empty
+    pi.should be > 3
 
 ## Object identity
 
-    actual.should be(expected) # passes if actual.equal?(expected)
-    
+    expect(actual).to be(expected) # passes if actual.equal?(expected)
+
 ## Object equivalence
 
-    actual.should eq(expected) # passes if actual == expected
+    expect(actual).to eq(expected) # passes if actual == expected
 
 ## Optional APIs for identity/equivalence
 
-    actual.should == expected     # passes if actual == expected
-    actual.should eql(expected)   # passes if actual.eql?(expected)
-    actual.should equal(expected) # passes if actual.equal?(expected)
+    expect(actual).to eql(expected)   # passes if actual.eql?(expected)
+    expect(actual).to equal(expected) # passes if actual.equal?(expected)
 
-    # NOTE: this can't work in Ruby 1.8, so we don't support it at all:
-    #   actual.should != expected
-    # The reason is that Ruby 1.8 parses it as:
-    #   !(actual.should.==(expected)),
-    # so by the time RSpec sees it it has no way to know that it's
-    # been negated. Use either of these instead:
-    #   actual.should_not eq(expected)
-    #   actual.should_not == expected
+    # NOTE: `expect` does not support `==` matcher.
 
 ## Comparisons
 
-    actual.should be >  expected
-    actual.should be >= expected
-    actual.should be <= expected
-    actual.should be <  expected
-    actual.should =~ /expression/
-    actual.should match(/expression/)
-    actual.should be_within(delta).of(expected)
+    expect(actual).to be >  expected
+    expect(actual).to be >= expected
+    expect(actual).to be <= expected
+    expect(actual).to be <  expected
+    expect(actual).to match(/expression/)
+    expect(actual).to be_within(delta).of(expected)
+
+    # NOTE: `expect` does not support `=~` matcher.
 
 ## Types/classes
 
-    actual.should be_instance_of(expected)
-    actual.should be_kind_of(expected)
+    expect(actual).to be_instance_of(expected)
+    expect(actual).to be_kind_of(expected)
 
 ## Truthiness and existentialism
 
-    actual.should be_true  # passes if actual is truthy (not nil or false)
-    actual.should be_false # passes if actual is falsy (nil or false)
-    actual.should be_nil   # passes if actual is nil
-    actual.should be       # passes if actual is truthy (not nil or false)
+    expect(actual).to be_true  # passes if actual is truthy (not nil or false)
+    expect(actual).to be_false # passes if actual is falsy (nil or false)
+    expect(actual).to be_nil   # passes if actual is nil
+    expect(actual).to be       # passes if actual is truthy (not nil or false)
 
 ## Expecting errors
 
@@ -66,25 +66,25 @@ can be used with `should` or `should_not` e.g.
 
 ## Predicate matchers
 
-    actual.should be_xxx         # passes if actual.xxx?
-    actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+    expect(actual).to be_xxx         # passes if actual.xxx?
+    expect(actual).to have_xxx(:arg) # passes if actual.has_xxx?(:arg)
 
 ### Examples
 
-    [].should be_empty # passes because [].empty? returns true
-    { :a => 1 }.should have_key(:a) # passes because the hash has the key :a
+    expect([]).to      be_empty
+    expect(:a => 1).to have_key(:a)
 
 ## Collection membership
 
-    actual.should include(expected)
+    expect(actual).to include(expected)
 
 ### Examples
 
-    [1,2,3].should include(1)
-    [1,2,3].should include(1, 2)
-    {:a => 'b'}.should include(:a => 'b')
-    "this string".should include("is str")
+    expect([1,2,3]).to       include(1)
+    expect([1,2,3]).to       include(1, 2)
+    expect(:a => 'b').to     include(:a => 'b')
+    expect("this string").to include("is str")
 
 ## Ranges (1.9 only)
 
-    (1..10).should cover(3)
+    expect(1..10).to cover(3)

data/features/built_in_matchers/be.feature

@@ -3,101 +3,101 @@ Feature: "be" matchers
   There are several related "be" matchers:
 
     ```ruby
-    obj.should be_true  # passes if obj is truthy (not nil or false)
-    obj.should be_false # passes if obj is falsy (nil or false)
+    obj.should be_truthy  # passes if obj is truthy (not nil or false)
+    obj.should be_falsey # passes if obj is falsy (nil or false)
     obj.should be_nil   # passes if obj is nil
     obj.should be       # passes if obj is truthy (not nil or false)
     ```
 
-  Scenario: be_true matcher
-    Given a file named "be_true_spec.rb" with:
+  Scenario: be_truthy matcher
+    Given a file named "be_truthy_spec.rb" with:
       """ruby
-      describe "be_true matcher" do
-        specify { true.should be_true }
-        specify { 7.should be_true }
-        specify { "foo".should be_true }
-        specify { nil.should_not be_true }
-        specify { false.should_not be_true }
+      describe "be_truthy matcher" do
+        specify { true.should be_truthy }
+        specify { 7.should be_truthy }
+        specify { "foo".should be_truthy }
+        specify { nil.should_not be_truthy }
+        specify { false.should_not be_truthy }
 
         # deliberate failures
-        specify { true.should_not be_true }
-        specify { 7.should_not be_true }
-        specify { "foo".should_not be_true }
-        specify { nil.should be_true }
-        specify { false.should be_true }
+        specify { true.should_not be_truthy }
+        specify { 7.should_not be_truthy }
+        specify { "foo".should_not be_truthy }
+        specify { nil.should be_truthy }
+        specify { false.should be_truthy }
       end
       """
-    When I run `rspec be_true_spec.rb`
+    When I run `rspec be_truthy_spec.rb`
     Then the output should contain "10 examples, 5 failures"
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: true
       """
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: 7
       """
     And the output should contain:
       """
-             expected: non-true value
+             expected: falsey value
                   got: "foo"
       """
     And the output should contain:
       """
-             expected: true value
+             expected: truthy value
                   got: nil
       """
     And the output should contain:
       """
-             expected: true value
+             expected: truthy value
                   got: false
       """
 
-  Scenario: be_false matcher
-    Given a file named "be_false_spec.rb" with:
+  Scenario: be_falsey matcher
+    Given a file named "be_falsey_spec.rb" with:
       """ruby
-      describe "be_false matcher" do
-        specify { nil.should be_false }
-        specify { false.should be_false }
-        specify { true.should_not be_false }
-        specify { 7.should_not be_false }
-        specify { "foo".should_not be_false }
+      describe "be_falsey matcher" do
+        specify { nil.should be_falsey }
+        specify { false.should be_falsey }
+        specify { true.should_not be_falsey }
+        specify { 7.should_not be_falsey }
+        specify { "foo".should_not be_falsey }
 
         # deliberate failures
-        specify { nil.should_not be_false }
-        specify { false.should_not be_false }
-        specify { true.should be_false }
-        specify { 7.should be_false }
-        specify { "foo".should be_false }
+        specify { nil.should_not be_falsey }
+        specify { false.should_not be_falsey }
+        specify { true.should be_falsey }
+        specify { 7.should be_falsey }
+        specify { "foo".should be_falsey }
       end
       """
-    When I run `rspec be_false_spec.rb`
+    When I run `rspec be_falsey_spec.rb`
     Then the output should contain "10 examples, 5 failures"
     And the output should contain:
       """
-             expected: non-false value
+             expected: truthy value
                   got: nil
       """
     And the output should contain:
       """
-             expected: non-false value
+             expected: truthy value
                   got: false
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: true
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: 7
       """
     And the output should contain:
       """
-             expected: false value
+             expected: falsey value
                   got: "foo"
       """
 

data/features/built_in_matchers/be_within.feature

@@ -4,11 +4,11 @@ Feature: be_within matcher
   Consider this irb session:
 
       > radius = 3
-        => 3 
+        => 3
       > area_of_circle = radius * radius * Math::PI
-        => 28.2743338823081 
+        => 28.2743338823081
       > area_of_circle == 28.2743338823081
-        => false 
+        => false
 
   Instead, you should use the be_within matcher to check that the value
   is within a delta of your expected value:

data/features/built_in_matchers/expect_change.feature

@@ -11,14 +11,14 @@ Feature: expect change
             @count ||= 0
             @count += 1
           end
-          
+
           def count
             @count ||= 0
           end
         end
       end
       """
-  
+
   Scenario: expect change
     Given a file named "spec/example_spec.rb" with:
       """ruby
@@ -45,13 +45,13 @@ Feature: expect change
       require "counter"
 
       describe Counter, "#increment" do
-        it "should not increment the count by 1 (using to_not)" do
-          expect { Counter.increment }.to_not change{Counter.count}
-        end
-
         it "should not increment the count by 1 (using not_to)" do
           expect { Counter.increment }.not_to change{Counter.count}
         end
+
+        it "should not increment the count by 1 (using to_not)" do
+          expect { Counter.increment }.to_not change{Counter.count}
+        end
       end
       """
     When I run `rspec spec/example_spec.rb`

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/diffing.feature

@@ -43,7 +43,7 @@ Feature: diffing
         actual
           string
       ACTUAL
-          actual.should =~ expected
+          expect(actual).to match expected
         end
       end
       """

data/features/step_definitions/additional_cli_steps.rb

@@ -20,3 +20,13 @@ Then /^the example should fail$/ do
   step %q{the output should contain "1 failure"}
   step %q{the exit status should not be 0}
 end
+
+deprecation_message = /rspec-expectations' built-in integration with (Test::Unit|minitest < 5.x) is deprecated/
+
+Then /^the output should contain a deprecation warning about rspec\-expecations' built\-in integration$/ do
+  expect(all_output).to match(deprecation_message)
+end
+
+Then /^the output should not contain a deprecation warning about rspec\-expecations' built\-in integration$/ do
+  expect(all_output).not_to match(deprecation_message)
+end

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/support/rubinius.rb

@@ -0,0 +1,6 @@
+# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
+ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
+
+Around "@unsupported-on-rbx" do |scenario, block|
+  block.call unless defined?(Rubinius)
+end

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`