rspec-expectations 2.99.2 → 3.0.0.beta1

data/features/built_in_matchers/include.feature

@@ -5,26 +5,26 @@ Feature: include matcher
   as a string or array):
 
     ```ruby
-    "a string".should include("a")
-    "a string".should include("str")
-    "a string".should include("str", "g")
-    "a string".should_not include("foo")
-
-    [1, 2].should include(1)
-    [1, 2].should include(1, 2)
-    [1, 2].should_not include(17)
+    expect("a string").to include("a")
+    expect("a string").to include("str")
+    expect("a string").to include("str", "g")
+    expect("a string").not_to include("foo")
+
+    expect([1, 2]).to include(1)
+    expect([1, 2]).to include(1, 2)
+    expect([1, 2]).not_to include(17)
     ```
 
   The matcher also provides flexible handling for hashes:
 
     ```ruby
-    {:a => 1, :b => 2}.should include(:a)
-    {:a => 1, :b => 2}.should include(:a, :b)
-    {:a => 1, :b => 2}.should include(:a => 1)
-    {:a => 1, :b => 2}.should include(:b => 2, :a => 1)
-    {:a => 1, :b => 2}.should_not include(:c)
-    {:a => 1, :b => 2}.should_not include(:a => 2)
-    {:a => 1, :b => 2}.should_not include(:c => 3)
+    expect(:a => 1, :b => 2).to include(:a)
+    expect(:a => 1, :b => 2).to include(:a, :b)
+    expect(:a => 1, :b => 2).to include(:a => 1)
+    expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+    expect(:a => 1, :b => 2).not_to include(:c)
+    expect(:a => 1, :b => 2).not_to include(:a => 2)
+    expect(:a => 1, :b => 2).not_to include(:c => 3)
     ```
 
   Scenario: array usage

data/features/built_in_matchers/match.feature

@@ -5,10 +5,10 @@ Feature: match matcher
   method.
 
     ```ruby
-    "a string".should match(/str/) # passes
-    "a string".should match(/foo/) # fails
-    /foo/.should match("food")     # passes
-    /foo/.should match("drinks")   # fails
+    expect("a string").to match(/str/) # passes
+    expect("a string").to match(/foo/) # fails
+    expect(/foo/).to match("food")     # passes
+    expect(/foo/).to match("drinks")   # fails
     ```
 
   This is equivalent to using the =~ matcher (see the operator matchers
@@ -49,4 +49,3 @@ Feature: match matcher
       | 4 examples, 2 failures             |
       | expected /foo/ not to match "food" |
       | expected /foo/ to match "drinks"   |
-

data/features/built_in_matchers/match_array.feature

@@ -0,0 +1,37 @@
+Feature: match_array matcher
+
+  The `match_array` matcher provides a way to test arrays against each other
+  in a way that disregards differences in the ordering between the actual
+  and expected array. For example:
+
+    ```ruby
+    expect([1, 2, 3]).to    match_array [2, 3, 1] # pass
+    expect([:a, :c, :b]).to match_array [:a, :c]  # fail
+    ```
+
+  Scenario: array operator matchers
+    Given a file named "array_operator_matchers_spec.rb" with:
+      """ruby
+      describe do
+        example { expect([1, 2, 3]).to match_array [1, 2, 3] }
+        example { expect([1, 2, 3]).to match_array [1, 3, 2] }
+        example { expect([1, 2, 3]).to match_array [2, 1, 3] }
+        example { expect([1, 2, 3]).to match_array [2, 3, 1] }
+        example { expect([1, 2, 3]).to match_array [3, 1, 2] }
+        example { expect([1, 2, 3]).to match_array [3, 2, 1] }
+
+        # deliberate failures
+        example { expect([1, 2, 3]).to match_array [1, 2, 1] }
+      end
+      """
+     When I run `rspec array_operator_matchers_spec.rb`
+     Then the output should contain "7 examples, 1 failure"
+      And the output should contain:
+      """
+           Failure/Error: example { expect([1, 2, 3]).to match_array [1, 2, 1] }
+             expected collection contained:  [1, 1, 2]
+             actual collection contained:    [1, 2, 3]
+             the missing elements were:      [1]
+             the extra elements were:        [3]
+      """
+

data/features/built_in_matchers/predicates.feature

@@ -14,7 +14,7 @@ Feature: predicate matchers
   You could use a basic equality matcher to set expectations on these:
 
     ```ruby
-    7.zero?.should == true # fails with "expected true, got false (using ==)"
+    expect(7.zero?).to eq true # fails with "expected true, got false (using ==)"
     ```
 
   ...but RSpec provides dynamic predicate matchers that are more readable and
@@ -24,9 +24,9 @@ Feature: predicate matchers
   prefix the method with `be_` and remove the question mark.  Examples:
 
     ```ruby
-    7.should_not be_zero       # calls 7.zero?
-    [].should be_empty         # calls [].empty?
-    x.should be_multiple_of(3) # calls x.multiple_of?(3)
+    expect(7).not_to be_zero       # calls 7.zero?
+    expect([]).to be_empty         # calls [].empty?
+    expect(x).to be_multiple_of(3) # calls x.multiple_of?(3)
     ```
 
   Alternately, for a predicate method that begins with `has_` like
@@ -34,14 +34,18 @@ Feature: predicate matchers
   makes no sense.
 
     ```ruby
-    hash.should have_key(:foo)       # calls hash.has_key?(:foo)
-    array.should_not have_odd_values # calls array.has_odd_values?
+    expect(hash).to have_key(:foo)       # calls hash.has_key?(:foo)
+    expect(array).not_to have_odd_values # calls array.has_odd_values?
     ```
 
   In either case, RSpec provides nice, clear error messages, such as:
 
     `expected zero? to return true, got false`
 
+  Calling private methods will also fail:
+
+    `expected private_method? to return true but it's a private method`
+
   Any arguments passed to the matcher will be passed on to the predicate method.
 
   Scenario: should be_zero (based on Fixnum#zero?)
@@ -135,3 +139,23 @@ Feature: predicate matchers
       And the output should contain "expected multiple_of?(4) to return false, got true"
       And the output should contain "expected multiple_of?(5) to return true, got false"
 
+    Scenario: calling private method causes error
+      Given a file named "attempting_to_match_private_method_spec.rb" with:
+       """ruby
+       class WithPrivateMethods
+         def secret?
+           true
+         end
+         private :secret?
+       end
+
+       describe 'private methods' do
+         subject { WithPrivateMethods.new }
+
+         # deliberate failure
+         it { should be_secret }
+       end
+       """
+     When I run `rspec attempting_to_match_private_method_spec.rb`
+     Then the output should contain "1 example, 1 failure"
+     And the output should contain "expectation set on private method `secret?`"

data/features/built_in_matchers/respond_to.feature

@@ -4,22 +4,22 @@ Feature: respond_to matcher
   its most basic form:
 
     ```ruby
-    obj.should respond_to(:foo) # pass if obj.respond_to?(:foo)
+    expect(obj).to respond_to(:foo) # pass if obj.respond_to?(:foo)
     ```
 
   You can specify that an object responds to multiple messages in a single
   statement with multiple arguments passed to the matcher:
 
     ```ruby
-    obj.should respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
+    expect(obj).to respond_to(:foo, :bar) # passes if obj.respond_to?(:foo) && obj.respond_to?(:bar)
     ```
 
   If the number of arguments accepted by the method is important to you,
   you can specify that as well:
 
     ```ruby
-    obj.should respond_to(:foo).with(1).argument
-    obj.should respond_to(:bar).with(2).arguments
+    expect(obj).to respond_to(:foo).with(1).argument
+    expect(obj).to respond_to(:bar).with(2).arguments
     ```
 
   Note that this matcher relies entirely upon #respond_to?.  If an object

data/features/built_in_matchers/satisfy.feature

@@ -4,8 +4,8 @@ Feature: satisfy matcher
   you want to specify.  It passes if the block you provide returns true:
 
     ```ruby
-    10.should satisfy { |v| v % 5 == 0 }
-    7.should_not satisfy { |v| v % 5 == 0 }
+    expect(10).to satisfy { |v| v % 5 == 0 }
+    expect(7).not_to satisfy { |v| v % 5 == 0 }
     ```
 
   This flexibility comes at a cost, however: the failure message

data/features/built_in_matchers/start_with.feature

@@ -4,9 +4,9 @@ Feature: start_with matcher
   the expected characters or elements.
 
     ```ruby
-    "this string".should start_with("this")
-    "this string".should_not start_with("that")
-    [0,1,2].should start_with(0, 1)
+    expect("this string").to start_with("this")
+    expect("this string").not_to start_with("that")
+    expect([0,1,2]).to start_with(0, 1)
     ```
 
   Scenario: with a string

data/features/built_in_matchers/types.feature

@@ -2,19 +2,19 @@ Feature: specify types of objects
 
   rspec-expectations includes two matchers to specify types of objects:
 
-    * `obj.should be_kind_of(type)`: calls `obj.kind_of?(type)`, which returns
+    * `expect(obj).to be_kind_of(type)`: calls `obj.kind_of?(type)`, which returns
       true if type is in obj's class hierarchy or is a module and is
       included in a class in obj's class hierarchy.
-    * `obj.should be_instance_of(type)`: calls `obj.instance_of?(type)`, which
+    * `expect(obj).to be_instance_of(type)`: calls `obj.instance_of?(type)`, which
       returns true if and only if type if obj's class.
 
   Both of these matchers have aliases:
 
     ```ruby
-    obj.should be_a_kind_of(type)      # same as obj.should be_kind_of(type)
-    obj.should be_a(type)              # same as obj.should be_kind_of(type)
-    obj.should be_an(type)             # same as obj.should be_kind_of(type)
-    obj.should be_an_instance_of(type) # same as obj.should be_instance_of(type)
+    expect(obj).to be_a_kind_of(type)      # same as expect(obj).to be_kind_of(type)
+    expect(obj).to be_a(type)              # same as expect(obj).to be_kind_of(type)
+    expect(obj).to be_an(type)             # same as expect(obj).to be_kind_of(type)
+    expect(obj).to be_an_instance_of(type) # same as expect(obj).to be_instance_of(type)
     ```
 
   Scenario: be_(a_)kind_of matcher

data/features/custom_matchers/access_running_example.feature

@@ -24,7 +24,7 @@ Feature: access running example
         end
 
         it "does something" do
-          "foo".should bar
+          expect("foo").to bar
         end
       end
       """
@@ -42,12 +42,12 @@ Feature: access running example
 
       describe "something" do
         it "does something" do
-          "foo".should bar
+          expect("foo").to bar
         end
       end
       """
     When I run `rspec ./example_spec.rb`
     Then the output should contain "1 example, 1 failure"
     And the output should match /undefined.*method/
-    And the output should contain "RSpec::Matchers::DSL::Matcher"
+    And the output should contain "RSpec::Matchers::DSL::Matcher bar"
     And the output should not contain "ExampleGroup"

data/features/custom_matchers/define_matcher.feature

@@ -183,7 +183,7 @@ Feature: define matcher
 
       describe "these two arrays" do
         specify "should be similar" do
-          [1,2,3].should have_same_elements_as([2,3,1])
+          expect([1,2,3]).to have_same_elements_as([2,3,1])
         end
       end
       """
@@ -207,14 +207,14 @@ Feature: define matcher
       describe "group with MyHelpers" do
         include MyHelpers
         it "has access to the defined matcher" do
-          5.should be_just_like(5)
+          expect(5).to be_just_like(5)
         end
       end
 
       describe "group without MyHelpers" do
         it "does not have access to the defined matcher" do
           expect do
-            5.should be_just_like(5)
+            expect(5).to be_just_like(5)
           end.to raise_exception
         end
       end
@@ -234,12 +234,12 @@ Feature: define matcher
         end
 
         it "has access to the defined matcher" do
-          5.should be_just_like(5)
+          expect(5).to be_just_like(5)
         end
 
         describe "nested group" do
           it "has access to the defined matcher" do
-            5.should be_just_like(5)
+            expect(5).to be_just_like(5)
           end
         end
 
@@ -248,7 +248,7 @@ Feature: define matcher
       describe "group without matcher" do
         it "does not have access to the defined matcher" do
           expect do
-            5.should be_just_like(5)
+            expect(5).to be_just_like(5)
           end.to raise_exception
         end
       end
@@ -338,31 +338,3 @@ Feature: define matcher
       | 4 examples, 2 failures               |
       | expected 9 to be a multiple of 2     |
       | expected 9 not to be a multiple of 3 |
-
-  Scenario: matching against a regular expression
-    Given a file named "regular_expression_matcher_spec.rb" with:
-      """ruby
-      # Due to Ruby's method dispatch mechanism, use the `#match_regex` alias
-      # rather than the `#match` matcher when defining custom matchers via the
-      # DSL.
-
-      RSpec::Matchers.define :be_valid_us_zipcode do
-        match do |actual|
-          expect(actual).to match_regex(/\A\d{5}(-\d{4})?\z/)
-        end
-      end
-
-      describe "30316" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "30316-0001" do
-        it { should be_valid_us_zipcode }
-      end
-
-      describe "1000-61303" do
-        it { should_not be_valid_us_zipcode }
-      end
-      """
-    When I run `rspec regular_expression_matcher_spec.rb`
-    Then the stdout should contain "3 examples, 0 failures"

data/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -23,11 +23,11 @@ Feature: define matcher outside rspec
       class TestMultiples < Test::Unit::TestCase
 
         def test_9_should_be_a_multiple_of_3
-          9.should be_a_multiple_of(3)
+          expect(9).to be_a_multiple_of(3)
         end
 
         def test_9_should_be_a_multiple_of_4
-          9.should be_a_multiple_of(4)
+          expect(9).to be_a_multiple_of(4)
         end
 
       end

data/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -2,7 +2,7 @@ Feature: define matcher with fluent interface
 
   Use the chain() method to define matchers with a fluent interface.
 
-  Scenario: chained method with argumetn
+  Scenario: chained method with argument
     Given a file named "between_spec.rb" with:
       """ruby
       RSpec::Matchers.define :be_bigger_than do |first|

data/features/customized_message.feature

@@ -12,7 +12,24 @@ Feature: customized message
           it "is empty" do
             array = Array.new
             array << 1 # trigger a failure to demonstrate the message
-            array.should be_empty, "expected empty array, got #{array.inspect}"
+            expect(array).to be_empty, "expected empty array, got #{array.inspect}"
+          end
+        end
+      end
+
+      """
+    When I run `rspec example_spec.rb --format documentation`
+    Then the output should contain "expected empty array, got [1]"
+
+  Scenario: customize failure message with a proc
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe Array do
+        context "when created with `new`" do
+          it "is empty" do
+            array = Array.new
+            array << 1 # trigger a failure to demonstrate the message
+            expect(array).to be_empty, lambda { "expected empty array, got #{array.inspect}" }
           end
         end
       end

data/features/diffing.feature

@@ -17,7 +17,7 @@ Feature: diffing
         actual
           string
       ACTUAL
-          actual.should eq(expected)
+          expect(actual).to eq(expected)
         end
       end
       """
@@ -65,7 +65,7 @@ Feature: diffing
         it "is like another string" do
           expected = "this string"
           actual   = "that string"
-          actual.should eq(expected)
+          expect(actual).to eq(expected)
         end
       end
       """
@@ -77,7 +77,7 @@ Feature: diffing
       """ruby
       describe "a number" do
         it "is like another number" do
-          1.should eq(2)
+          expect(1).to eq(2)
         end
       end
       """

data/features/implicit_docstrings.feature

@@ -9,11 +9,11 @@ Feature: implicit docstrings
     """ruby
     describe "Examples with no docstrings generate their own:" do
 
-      specify { 3.should be < 5 }
+      specify { expect(3).to be < 5 }
 
-      specify { [1,2,3].should include(2) }
+      specify { expect([1,2,3]).to include(2) }
 
-      specify { [1,2,3].should respond_to(:size) }
+      specify { expect([1,2,3]).to respond_to(:size) }
 
     end
     """
@@ -29,17 +29,17 @@ Feature: implicit docstrings
     """ruby
     describe "Failing examples with no descriptions" do
 
-      # description is auto-generated as "should equal(5)" based on the last #should
+      # description is auto-generated as "to equal(5)" based on the last #expect
       it do
-        3.should equal(2)
-        5.should equal(5)
+        expect(3).to equal(2)
+        expect(5).to equal(5)
       end
 
-      it { 3.should be > 5 }
+      it { expect(3).to be > 5 }
 
-      it { [1,2,3].should include(4) }
+      it { expect([1,2,3]).to include(4) }
 
-      it { [1,2,3].should_not respond_to(:size) }
+      it { expect([1,2,3]).not_to respond_to(:size) }
 
     end
     """