rspec-expectations 2.99.2 → 3.0.0.beta1

data/features/README.md

@@ -23,7 +23,7 @@ Note: You can also use `expect(..).to_not` instead of `expect(..).not_to`.
 
 ## What is a matcher?
 
-A matcher is any object that responds to the following methods:
+A Matcher is any object that responds to the following methods:
 
     matches?(actual)
     failure_message_for_should
@@ -33,7 +33,6 @@ These methods are also part of the matcher protocol, but are optional:
     does_not_match?(actual)
     failure_message_for_should_not
     description
-    supports_block_expectations?
 
 RSpec ships with a number of built-in matchers and a DSL for writing custom
 matchers.

data/features/built_in_matchers/README.md

@@ -77,6 +77,7 @@ e.g.
 ## Collection membership
 
     expect(actual).to include(expected)
+    expect(array).to match_array(expected)
 
 ### Examples
 
@@ -84,6 +85,8 @@ e.g.
     expect([1,2,3]).to       include(1, 2)
     expect(:a => 'b').to     include(:a => 'b')
     expect("this string").to include("is str")
+    expect([1,2,3]).to       match_array([1,2,3])
+    expect([1,2,3]).to       match_array([3,2,1])
 
 ## Ranges (1.9 only)
 

data/features/built_in_matchers/be.feature

@@ -3,28 +3,28 @@ Feature: "be" matchers
   There are several related "be" matchers:
 
     ```ruby
-    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)
+    expect(obj).to be_truthy  # passes if obj is truthy (not nil or false)
+    expect(obj).to be_falsey  # passes if obj is falsy (nil or false)
+    expect(obj).to be_nil     # passes if obj is nil
+    expect(obj).to be         # passes if obj is truthy (not nil or false)
     ```
 
   Scenario: be_truthy matcher
     Given a file named "be_truthy_spec.rb" with:
       """ruby
       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 }
+        specify { expect(true).to be_truthy }
+        specify { expect(7).to be_truthy }
+        specify { expect("foo").to be_truthy }
+        specify { expect(nil).not_to be_truthy }
+        specify { expect(false).not_to be_truthy }
 
         # deliberate failures
-        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 }
+        specify { expect(true).not_to be_truthy }
+        specify { expect(7).not_to be_truthy }
+        specify { expect("foo").not_to be_truthy }
+        specify { expect(nil).to be_truthy }
+        specify { expect(false).to be_truthy }
       end
       """
     When I run `rspec be_truthy_spec.rb`
@@ -59,18 +59,18 @@ Feature: "be" matchers
     Given a file named "be_falsey_spec.rb" with:
       """ruby
       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 }
+        specify { expect(nil).to be_falsey }
+        specify { expect(false).to be_falsey }
+        specify { expect(true).not_to be_falsey }
+        specify { expect(7).not_to be_falsey }
+        specify { expect("foo").not_to be_falsey }
 
         # deliberate failures
-        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 }
+        specify { expect(nil).not_to be_falsey }
+        specify { expect(false).not_to be_falsey }
+        specify { expect(true).to be_falsey }
+        specify { expect(7).to be_falsey }
+        specify { expect("foo").to be_falsey }
       end
       """
     When I run `rspec be_falsey_spec.rb`
@@ -105,18 +105,18 @@ Feature: "be" matchers
     Given a file named "be_nil_spec.rb" with:
       """ruby
       describe "be_nil matcher" do
-        specify { nil.should be_nil }
-        specify { false.should_not be_nil }
-        specify { true.should_not be_nil }
-        specify { 7.should_not be_nil }
-        specify { "foo".should_not be_nil }
+        specify { expect(nil).to be_nil }
+        specify { expect(false).not_to be_nil }
+        specify { expect(true).not_to be_nil }
+        specify { expect(7).not_to be_nil }
+        specify { expect("foo").not_to be_nil }
 
         # deliberate failures
-        specify { nil.should_not be_nil }
-        specify { false.should be_nil }
-        specify { true.should be_nil }
-        specify { 7.should be_nil }
-        specify { "foo".should be_nil }
+        specify { expect(nil).not_to be_nil }
+        specify { expect(false).to be_nil }
+        specify { expect(true).to be_nil }
+        specify { expect(7).to be_nil }
+        specify { expect("foo").to be_nil }
       end
       """
     When I run `rspec be_nil_spec.rb`
@@ -151,18 +151,18 @@ Feature: "be" matchers
     Given a file named "be_spec.rb" with:
       """ruby
       describe "be_matcher" do
-        specify { true.should be }
-        specify { 7.should be }
-        specify { "foo".should be }
-        specify { nil.should_not be }
-        specify { false.should_not be }
+        specify { expect(true).to be }
+        specify { expect(7).to be }
+        specify { expect("foo").to be }
+        specify { expect(nil).not_to be }
+        specify { expect(false).not_to be }
 
         # deliberate failures
-        specify { true.should_not be }
-        specify { 7.should_not be }
-        specify { "foo".should_not be }
-        specify { nil.should be }
-        specify { false.should be }
+        specify { expect(true).not_to be }
+        specify { expect(7).not_to be }
+        specify { expect("foo").not_to be }
+        specify { expect(nil).to be }
+        specify { expect(false).to be }
       end
       """
     When I run `rspec be_spec.rb`

data/features/built_in_matchers/be_within.feature

@@ -14,7 +14,7 @@ Feature: be_within matcher
   is within a delta of your expected value:
 
     ```ruby
-    area_of_circle.should be_within(0.1).of(28.3)
+    expect(area_of_circle).to be_within(0.1).of(28.3)
     ```
 
   Note that the difference between the actual and expected values must be

data/features/built_in_matchers/comparisons.feature

@@ -0,0 +1,97 @@
+Feature: comparsion matchers
+
+  RSpec provides a number of matchers that are based on Ruby's built-in
+  operators. These can be used for generalized comparsion of values. E.g.
+
+    ```ruby
+    expect(9).to be > 6
+    expect(3).to be <= 3
+    expect(1).to be < 6
+    ```
+
+
+  Scenario: numeric operator matchers
+    Given a file named "numeric_operator_matchers_spec.rb" with:
+      """ruby
+      describe do
+        example { expect(18).to be < 20 }
+        example { expect(18).to be > 15 }
+        example { expect(18).to be <= 19 }
+        example { expect(18).to be >= 17 }
+
+        # deliberate failures
+        example { expect(18).to be < 15 }
+        example { expect(18).to be > 20 }
+        example { expect(18).to be <= 17 }
+        example { expect(18).to be >= 19 }
+      end
+      """
+     When I run `rspec numeric_operator_matchers_spec.rb`
+     Then the output should contain "8 examples, 4 failures"
+      And the output should contain:
+      """
+           Failure/Error: example { expect(18).to be < 15 }
+             expected: < 15
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect(18).to be > 20 }
+             expected: > 20
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect(18).to be <= 17 }
+             expected: <= 17
+                  got:    18
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect(18).to be >= 19 }
+             expected: >= 19
+                  got:    18
+      """
+
+  Scenario: string operator matchers
+    Given a file named "string_operator_matchers_spec.rb" with:
+      """ruby
+      describe do
+        example { expect("Strawberry").to be < "Tomato" }
+        example { expect("Strawberry").to be > "Apple" }
+        example { expect("Strawberry").to be <= "Turnip" }
+        example { expect("Strawberry").to be >= "Banana" }
+
+        # deliberate failures
+        example { expect("Strawberry").to be < "Cranberry" }
+        example { expect("Strawberry").to be > "Zuchini" }
+        example { expect("Strawberry").to be <= "Potato" }
+        example { expect("Strawberry").to be >= "Tomato" }
+      end
+      """
+     When I run `rspec string_operator_matchers_spec.rb`
+     Then the output should contain "8 examples, 4 failures"
+      And the output should contain:
+      """
+           Failure/Error: example { expect("Strawberry").to be < "Cranberry" }
+             expected: < "Cranberry"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect("Strawberry").to be > "Zuchini" }
+             expected: > "Zuchini"
+                  got:   "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect("Strawberry").to be <= "Potato" }
+             expected: <= "Potato"
+                  got:    "Strawberry"
+      """
+      And the output should contain:
+      """
+           Failure/Error: example { expect("Strawberry").to be >= "Tomato" }
+             expected: >= "Tomato"
+                  got:    "Strawberry"
+      """

data/features/built_in_matchers/cover.feature

@@ -6,9 +6,9 @@ Feature: cover matcher
   as a Range):
 
     ```ruby
-    (1..10).should cover(5)
-    (1..10).should cover(4, 6)
-    (1..10).should_not cover(11)
+    expect(1..10).to cover(5)
+    expect(1..10).to cover(4, 6)
+    expect(1..10).not_to cover(11)
     ```
 
   Scenario: range usage

data/features/built_in_matchers/end_with.feature

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

data/features/built_in_matchers/equality.feature

@@ -13,37 +13,34 @@ Feature: equality matchers
   rspec-expectations ships with matchers that align with each of these methods:
 
     ```ruby
-    a.should equal(b) # passes if a.equal?(b)
-    a.should eql(b)   # passes if a.eql?(b)
-    a.should == b     # passes if a == b
+    expect(a).to equal(b) # passes if a.equal?(b)
+    expect(a).to eql(b)   # passes if a.eql?(b)
+    expect(a).to be == b  # passes if a == b
     ```
 
   It also ships with two matchers that have more of a DSL feel to them:
 
     ```ruby
-    a.should be(b) # passes if a.equal?(b)
-    a.should eq(b) # passes if a == b
+    expect(a).to be(b) # passes if a.equal?(b)
+    expect(a).to eq(b) # passes if a == b
     ```
 
-  These are a useful pair if you wish to avoid the warning that Ruby emits on
-  `a.should == b`
-
   Scenario: compare using eq (==)
     Given a file named "compare_using_eq.rb" with:
       """ruby
       describe "a string" do
         it "is equal to another string of the same value" do
-          "this string".should eq("this string")
+          expect("this string").to eq("this string")
         end
 
         it "is not equal to another string of a different value" do
-          "this string".should_not eq("a different string")
+          expect("this string").not_to eq("a different string")
         end
       end
 
       describe "an integer" do
         it "is equal to a float of the same value" do
-          5.should eq(5.0)
+          expect(5).to eq(5.0)
         end
       end
       """
@@ -55,17 +52,17 @@ Feature: equality matchers
       """ruby
       describe "a string" do
         it "is equal to another string of the same value" do
-          "this string".should == "this string"
+          expect("this string").to be == "this string"
         end
 
         it "is not equal to another string of a different value" do
-          "this string".should_not == "a different string"
+          expect("this string").not_to be == "a different string"
         end
       end
 
       describe "an integer" do
         it "is equal to a float of the same value" do
-          5.should == 5.0
+          expect(5).to be == 5.0
         end
       end
       """
@@ -77,15 +74,15 @@ Feature: equality matchers
       """ruby
       describe "an integer" do
         it "is equal to another integer of the same value" do
-          5.should eql(5)
+          expect(5).to eql(5)
         end
 
         it "is not equal to another integer of a different value" do
-          5.should_not eql(6)
+          expect(5).not_to eql(6)
         end
 
         it "is not equal to a float of the same value" do
-          5.should_not eql(5.0)
+          expect(5).not_to eql(5.0)
         end
 
       end
@@ -99,15 +96,15 @@ Feature: equality matchers
       describe "a string" do
         it "is equal to itself" do
           string = "this string"
-          string.should equal(string)
+          expect(string).to equal(string)
         end
 
         it "is not equal to another string of the same value" do
-          "this string".should_not equal("this string")
+          expect("this string").not_to equal("this string")
         end
 
         it "is not equal to another string of a different value" do
-          "this string".should_not equal("a different string")
+          expect("this string").not_to equal("a different string")
         end
 
       end
@@ -121,15 +118,15 @@ Feature: equality matchers
       describe "a string" do
         it "is equal to itself" do
           string = "this string"
-          string.should be(string)
+          expect(string).to be(string)
         end
 
         it "is not equal to another string of the same value" do
-          "this string".should_not be("this string")
+          expect("this string").not_to be("this string")
         end
 
         it "is not equal to another string of a different value" do
-          "this string".should_not be("a different string")
+          expect("this string").not_to be("a different string")
         end
 
       end

data/features/built_in_matchers/exist.feature

@@ -4,7 +4,7 @@ Feature: exist matcher
   (as indicated by #exist? or #exists?):
 
     ```ruby
-    obj.should exist # passes if obj.exist? or obj.exists?
+    expect(obj).to exist # passes if obj.exist? or obj.exists?
     ```
 
   Scenario: basic usage
@@ -28,14 +28,14 @@ Feature: exist matcher
 
       describe "Earth" do
         let(:earth) { Planet.new("Earth") }
-        specify { earth.should exist }
-        specify { earth.should_not exist } # deliberate failure
+        specify { expect(earth).to exist }
+        specify { expect(earth).not_to exist } # deliberate failure
       end
 
       describe "Tatooine" do
         let(:tatooine) { Planet.new("Tatooine") }
-        it { tatooine.should exist } # deliberate failure
-        it { tatooine.should_not exist }
+        specify { expect(tatooine).to exist } # deliberate failure
+        specify { expect(tatooine).not_to exist }
       end
       """
     When I run `rspec exist_matcher_spec.rb`

data/features/built_in_matchers/expect_error.feature

@@ -78,6 +78,19 @@ Feature: raise_error matcher
     When I run `rspec example_spec.rb`
     Then the example should pass
 
+  Scenario: matching message with `with_message`
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "matching error message with regex" do
+        it "matches the error message" do
+          expect { raise StandardError, "my message" }.
+            to raise_error.with_message(/my mess/)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the example should pass
+
   Scenario: match type + message with string
     Given a file named "example_spec.rb" with:
       """ruby
@@ -110,7 +123,7 @@ Feature: raise_error matcher
       describe "#foo" do
         it "raises NameError" do
           expect { Object.new.foo }.to raise_error { |error|
-            error.should be_a(NameError)
+            expect(error).to be_a(NameError)
           }
         end
       end
@@ -118,19 +131,6 @@ Feature: raise_error matcher
       When I run `rspec example_spec`
       Then the example should pass
 
-  Scenario: expect no occurence of a specific error
-    Given a file named "example_spec" with:
-      """
-      describe Object, "#public_instance_methods" do
-        it "does not raise" do
-          expect { Object.public_instance_methods }.
-            not_to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec example_spec`
-    Then the example should pass
-
   Scenario: expect no error at all
     Given a file named "example_spec" with:
       """