rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/features/built_in_matchers/contain_exactly.feature

@@ -1,46 +0,0 @@
-Feature: contain_exactly matcher
-
-  The `contain_exactly` 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    contain_exactly(2, 3, 1) # pass
-    expect([:a, :c, :b]).to contain_exactly(:a, :c ) # fail
-    ```
-
-  This matcher is also available as `match_array`, which expects the
-  expected array to be given as a single array argument rather than
-  as individual splatted elements. The above could also be written as:
-
-    ```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 "contain_exactly_matcher_spec.rb" with:
-      """ruby
-      describe do
-        example { expect([1, 2, 3]).to contain_exactly(1, 2, 3) }
-        example { expect([1, 2, 3]).to contain_exactly(1, 3, 2) }
-        example { expect([1, 2, 3]).to contain_exactly(2, 1, 3) }
-        example { expect([1, 2, 3]).to contain_exactly(2, 3, 1) }
-        example { expect([1, 2, 3]).to contain_exactly(3, 1, 2) }
-        example { expect([1, 2, 3]).to contain_exactly(3, 2, 1) }
-
-        # deliberate failures
-        example { expect([1, 2, 3]).to contain_exactly(1, 2, 1) }
-      end
-      """
-     When I run `rspec contain_exactly_matcher_spec.rb`
-     Then the output should contain "7 examples, 1 failure"
-      And the output should contain:
-      """
-           Failure/Error: example { expect([1, 2, 3]).to contain_exactly(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/cover.feature

@@ -1,47 +0,0 @@
-@ruby-1.9
-Feature: cover matcher
-
-  Use the cover matcher to specify that a range covers one or more
-  expected objects.  This works on any object that responds to #cover?  (such
-  as a Range):
-
-    ```ruby
-    expect(1..10).to cover(5)
-    expect(1..10).to cover(4, 6)
-    expect(1..10).not_to cover(11)
-    ```
-
-  Scenario: range usage
-    Given a file named "range_cover_matcher_spec.rb" with:
-      """ruby
-      describe (1..10) do
-        it { should cover(4) }
-        it { should cover(6) }
-        it { should cover(8) }
-        it { should cover(4, 6) }
-        it { should cover(4, 6, 8) }
-        it { should_not cover(11) }
-        it { should_not cover(11, 12) }
-
-        # deliberate failures
-        it { should cover(11) }
-        it { should_not cover(4) }
-        it { should_not cover(6) }
-        it { should_not cover(8) }
-        it { should_not cover(4, 6, 8) }
-
-        # both of these should fail since it covers 5 but not 11
-        it { should cover(5, 11) }
-        it { should_not cover(5, 11) }
-      end
-      """
-    When I run `rspec range_cover_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 14 examples, 7 failures                 |
-      | expected 1..10 to cover 11              |
-      | expected 1..10 not to cover 4           |
-      | expected 1..10 not to cover 6           |
-      | expected 1..10 not to cover 8           |
-      | expected 1..10 not to cover 4, 6, and 8 |
-      | expected 1..10 to cover 5 and 11        |
-      | expected 1..10 not to cover 5 and 11    |

data/features/built_in_matchers/end_with.feature

@@ -1,48 +0,0 @@
-Feature: end_with matcher
-
-  Use the `end_with` matcher to specify that a string or array ends with the
-  expected characters or elements.
-
-    ```ruby
-    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
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "this string" do
-        it { should end_with "string" }
-        it { should_not end_with "stringy" }
-
-        # deliberate failures
-        it { should_not end_with "string" }
-        it { should end_with "stringy" }
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                          |
-      | expected "this string" not to end with "string" |
-      | expected "this string" to end with "stringy"    |
-
-  Scenario: array usage
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe [0, 1, 2, 3, 4] do
-        it { should end_with 4 }
-        it { should end_with 3, 4 }
-        it { should_not end_with 3 }
-        it { should_not end_with 0, 1, 2, 3, 4, 5 }
-
-        # deliberate failures
-        it { should_not end_with 4 }
-        it { should end_with 3 }
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain all of these:
-      | 6 examples, 2 failures                     |
-      | expected [0, 1, 2, 3, 4] not to end with 4 |
-      | expected [0, 1, 2, 3, 4] to end with 3     |

data/features/built_in_matchers/equality.feature

@@ -1,136 +0,0 @@
-Feature: equality matchers
-
-  Ruby exposes several different methods for handling equality:
-
-      a.equal?(b) # object identity - a and b refer to the same object
-      a.eql?(b)   # object equivalence - a and b have the same value
-      a == b      # object equivalence - a and b have the same value with type conversions
-
-  Note that these descriptions are guidelines but are not forced by the
-  language. Any object can implement any of these methods with its own
-  semantics.
-
-  rspec-expectations ships with matchers that align with each of these methods:
-
-    ```ruby
-    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
-    expect(a).to be(b) # passes if a.equal?(b)
-    expect(a).to eq(b) # passes if a == 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
-          expect("this string").to eq("this string")
-        end
-
-        it "is not equal to another string of a different value" do
-          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
-          expect(5).to eq(5.0)
-        end
-      end
-      """
-    When I run `rspec compare_using_eq.rb`
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: compare using ==
-    Given a file named "compare_using_==.rb" with:
-      """ruby
-      describe "a string" do
-        it "is equal to another string of the same value" do
-          expect("this string").to be == "this string"
-        end
-
-        it "is not equal to another string of a different value" do
-          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
-          expect(5).to be == 5.0
-        end
-      end
-      """
-    When I run `rspec compare_using_==.rb`
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: compare using eql (eql?)
-    Given a file named "compare_using_eql.rb" with:
-      """ruby
-      describe "an integer" do
-        it "is equal to another integer of the same value" do
-          expect(5).to eql(5)
-        end
-
-        it "is not equal to another integer of a different value" do
-          expect(5).not_to eql(6)
-        end
-
-        it "is not equal to a float of the same value" do
-          expect(5).not_to eql(5.0)
-        end
-
-      end
-      """
-    When I run `rspec compare_using_eql.rb`
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: compare using equal (equal?)
-    Given a file named "compare_using_equal.rb" with:
-      """ruby
-      describe "a string" do
-        it "is equal to itself" do
-          string = "this string"
-          expect(string).to equal(string)
-        end
-
-        it "is not equal to another string of the same value" do
-          expect("this string").not_to equal("this string")
-        end
-
-        it "is not equal to another string of a different value" do
-          expect("this string").not_to equal("a different string")
-        end
-
-      end
-      """
-    When I run `rspec compare_using_equal.rb`
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: compare using be (equal?)
-    Given a file named "compare_using_be.rb" with:
-      """ruby
-      describe "a string" do
-        it "is equal to itself" do
-          string = "this string"
-          expect(string).to be(string)
-        end
-
-        it "is not equal to another string of the same value" do
-          expect("this string").not_to be("this string")
-        end
-
-        it "is not equal to another string of a different value" do
-          expect("this string").not_to be("a different string")
-        end
-
-      end
-      """
-    When I run `rspec compare_using_be.rb`
-    Then the output should contain "3 examples, 0 failures"
-

data/features/built_in_matchers/exist.feature

@@ -1,45 +0,0 @@
-Feature: exist matcher
-
-  The exist matcher is used to specify that something exists
-  (as indicated by #exist? or #exists?):
-
-    ```ruby
-    expect(obj).to exist # passes if obj.exist? or obj.exists?
-    ```
-
-  Scenario: basic usage
-    Given a file named "exist_matcher_spec.rb" with:
-      """ruby
-      class Planet
-        attr_reader :name
-
-        def initialize(name)
-          @name = name
-        end
-
-        def inspect
-          "<Planet: #{name}>"
-        end
-
-        def exist? # also works with exists?
-          %w[Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune].include?(name)
-        end
-      end
-
-      describe "Earth" do
-        let(:earth) { Planet.new("Earth") }
-        specify { expect(earth).to exist }
-        specify { expect(earth).not_to exist } # deliberate failure
-      end
-
-      describe "Tatooine" do
-        let(:tatooine) { Planet.new("Tatooine") }
-        specify { expect(tatooine).to exist } # deliberate failure
-        specify { expect(tatooine).not_to exist }
-      end
-      """
-    When I run `rspec exist_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                |
-      | expected <Planet: Earth> not to exist |
-      | expected <Planet: Tatooine> to exist  |

data/features/built_in_matchers/expect_change.feature

@@ -1,59 +0,0 @@
-Feature: expect change
-
-  Expect the execution of a block of code to change the state of an object.
-
-  Background:
-    Given a file named "lib/counter.rb" with:
-      """ruby
-      class Counter
-        class << self
-          def increment
-            @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
-      require "counter"
-
-      describe Counter, "#increment" do
-        it "should increment the count" do
-          expect { Counter.increment }.to change{Counter.count}.from(0).to(1)
-        end
-
-        # deliberate failure
-        it "should increment the count by 2" do
-          expect { Counter.increment }.to change{Counter.count}.by(2)
-        end
-      end
-      """
-    When I run `rspec spec/example_spec.rb`
-    Then the output should contain "1 failure"
-    Then the output should contain "expected result to have changed by 2, but was changed by 1"
-
-  Scenario: expect no change
-    Given a file named "spec/example_spec.rb" with:
-      """ruby
-      require "counter"
-
-      describe Counter, "#increment" do
-        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`
-    Then the output should contain "2 failures"
-    Then the output should contain "expected result not to have changed, but did change from 1 to 2"

data/features/built_in_matchers/expect_error.feature

@@ -1,144 +0,0 @@
-Feature: raise_error matcher
-
-  Use the `raise_error` matcher to specify that a block of code raises an
-  error. The most basic form passes if any error is thrown:
-
-    ```ruby
-    expect { raise StandardError }.to raise_error
-    ```
-
-  You can use `raise_exception` instead if you prefer that wording:
-
-    ```ruby
-    expect { 3 / 0 }.to raise_exception
-    ```
-
-  `raise_error` and `raise_exception` are functionally interchangeable, so use
-  the one that makes the most sense to you in any given context.
-
-  In addition to the basic form, above, there are a number of ways to specify
-  details of an error/exception:
-
-    ```ruby
-    expect { raise "oops" }.to raise_error
-    expect { raise "oops" }.to raise_error(RuntimeError)
-    expect { raise "oops" }.to raise_error("oops")
-    expect { raise "oops" }.to raise_error(/op/)
-    expect { raise "oops" }.to raise_error(RuntimeError, "oops")
-    expect { raise "oops" }.to raise_error(RuntimeError, /op/)
-    ```
-
-  Scenario: expect any error
-    Given a file named "example_spec" with:
-      """
-      describe "calling a missing method" do
-        it "raises" do
-          expect { Object.new.foo }.to raise_error
-        end
-      end
-      """
-    When I run `rspec example_spec`
-    Then the example should pass
-
-  Scenario: expect specific error
-    Given a file named "example_spec" with:
-      """
-      describe "calling a missing method" do
-        it "raises" do
-          expect { Object.new.foo }.to raise_error(NameError)
-        end
-      end
-      """
-    When I run `rspec example_spec`
-    Then the example should pass
-
-  Scenario: match message with a string
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "matching error message with string" do
-        it "matches the error message" do
-          expect { raise StandardError, 'this message exactly'}.
-            to raise_error('this message exactly')
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the example should pass
-
-  Scenario: match message with a regexp
-    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(/my mess/)
-        end
-      end
-      """
-    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
-      describe "matching error message with string" do
-        it "matches the error message" do
-          expect { raise StandardError, 'this message exactly'}.
-            to raise_error(StandardError, 'this message exactly')
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the example should pass
-
-  Scenario: match type + message with regexp
-    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(StandardError, /my mess/)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the example should pass
-
-  Scenario: set expectations on error object passed to block
-    Given a file named "example_spec" with:
-      """
-      describe "#foo" do
-        it "raises NameError" do
-          expect { Object.new.foo }.to raise_error { |error|
-            expect(error).to be_a(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:
-      """
-      describe "#to_s" do
-        it "does not raise" do
-          expect { Object.new.to_s }.not_to raise_error
-        end
-      end
-      """
-    When I run `rspec example_spec`
-    Then the example should pass