rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/features/README.md

@@ -1,48 +0,0 @@
-rspec-expectations is used to define expected outcomes.
-
-    describe Account do
-      it "has a balance of zero when first created" do
-        expect(Account.new.balance).to eq(Money.new(0))
-      end
-    end
-
-## Basic structure
-
-The basic structure of an rspec expectation is:
-
-    expect(actual).to matcher(expected)
-    expect(actual).not_to matcher(expected)
-
-Note: You can also use `expect(..).to_not` instead of `expect(..).not_to`.
-      One is an alias to the other, so you can use whichever reads better to you.
-
-#### Examples
-
-    expect(5).to eq(5)
-    expect(5).not_to eq(4)
-
-## What is a matcher?
-
-A Matcher is any object that responds to the following methods:
-
-    matches?(actual)
-    failure_message
-
-These methods are also part of the matcher protocol, but are optional:
-
-    does_not_match?(actual)
-    failure_message_when_negated
-    description
-
-RSpec ships with a number of built-in matchers and a DSL for writing custom
-matchers.
-
-## Issues
-
-The documentation for rspec-expectations is a work in progress. We'll be adding
-Cucumber features over time, and clarifying existing ones.  If you have
-specific features you'd like to see added, find the existing documentation
-incomplete or confusing, or, better yet, wish to write a missing Cucumber
-feature yourself, please [submit an
-issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
-request](http://github.com/rspec/rspec-expectations).

data/features/Upgrade.md

@@ -1,53 +0,0 @@
-# Upgrade to rspec-expectations-2.0
-
-## What's new
-
-### New `eq` matcher.
-
-`RSpec::Matchers` now offers you two approaches to differentiating between
-object identity. You can use the rspec-1 approach:
-
-    actual.should == expected     # object equality
-    actual.should equal(expected) # object identity
-
-... or, if you prefer:
-
-    actual.should eq(expected) # object equality
-    actual.should be(expected) # object identity
-
-## What's been removed
-
-### simple_matcher
-
-Use RSpec::Matchers.define instead. For example, if you had:
-
-    def eat_cheese
-      simple_matcher("eat cheese") do |actual|
-        actual.eat?(:cheese)
-      end
-    end
-
-Change it to:
-
-    RSpec::Matchers.define :eat_cheese do
-      match do |actual|
-        actual.eat?(:cheese)
-      end
-    end
-
-### wrap_expectation
-
-Use RSpec::Matchers.define instead.
-
-    RSpec::Matchers.define :eat_cheese do
-      match do |actual|
-        actual.should eat?(:cheese)
-      end
-    end
-
-    RSpec::Matchers.define :eat_cheese do
-      include MyCheesyAssertions
-      match_unless_raises Test::Unit::AssertionFailedError do |actual|
-        assert_eats_chesse actual
-      end
-    end

data/features/built_in_matchers/README.md

@@ -1,96 +0,0 @@
-# Built-in Matchers
-
-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`.
-
-e.g.
-
-    expect(result).to   eq(3)
-    expect(list).not_to be_empty
-    pi.should be > 3
-
-## Object identity
-
-    expect(actual).to be(expected) # passes if actual.equal?(expected)
-
-## Object equivalence
-
-    expect(actual).to eq(expected) # passes if actual == expected
-
-## Optional APIs for identity/equivalence
-
-    expect(actual).to eql(expected)   # passes if actual.eql?(expected)
-    expect(actual).to equal(expected) # passes if actual.equal?(expected)
-
-    # NOTE: `expect` does not support `==` matcher.
-
-## Comparisons
-
-    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
-
-    expect(actual).to be_instance_of(expected)
-    expect(actual).to be_kind_of(expected)
-
-## Truthiness and existentialism
-
-    expect(actual).to be_truthy # passes if actual is truthy (not nil or false)
-    expect(actual).to be true   # passes if actual == true
-    expect(actual).to be_falsey # passes if actual is falsy (nil or false)
-    expect(actual).to be false  # passes if actual == false
-    expect(actual).to be_nil    # passes if actual is nil
-
-## Expecting errors
-
-    expect { ... }.to raise_error
-    expect { ... }.to raise_error(ErrorClass)
-    expect { ... }.to raise_error("message")
-    expect { ... }.to raise_error(ErrorClass, "message")
-
-## Expecting throws
-
-    expect { ... }.to throw_symbol
-    expect { ... }.to throw_symbol(:symbol)
-    expect { ... }.to throw_symbol(:symbol, 'value')
-
-## Predicate matchers
-
-    expect(actual).to be_xxx         # passes if actual.xxx?
-    expect(actual).to have_xxx(:arg) # passes if actual.has_xxx?(:arg)
-
-### Examples
-
-    expect([]).to      be_empty
-    expect(:a => 1).to have_key(:a)
-
-## Collection membership
-
-    expect(actual).to include(expected)
-    expect(array).to match_array(expected_array)
-    # ...which is the same as:
-    expect(array).to contain_exactly(individual, elements)
-
-### Examples
-
-    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")
-    expect([1, 2, 3]).to     contain_exactly(2, 1, 3)
-    expect([1, 2, 3]).to     match_array([3, 2, 1])
-
-## Ranges (1.9 only)
-
-    expect(1..10).to cover(3)

data/features/built_in_matchers/be.feature

@@ -1,175 +0,0 @@
-Feature: "be" matchers
-
-  There are several related "be" matchers:
-
-    ```ruby
-    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 { 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 { 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`
-    Then the output should contain "10 examples, 5 failures"
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: true
-      """
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: 7
-      """
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: "foo"
-      """
-    And the output should contain:
-      """
-             expected: truthy value
-                  got: nil
-      """
-    And the output should contain:
-      """
-             expected: truthy value
-                  got: false
-      """
-
-  Scenario: be_falsey matcher
-    Given a file named "be_falsey_spec.rb" with:
-      """ruby
-      describe "be_falsey matcher" do
-        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 { 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`
-    Then the output should contain "10 examples, 5 failures"
-    And the output should contain:
-      """
-             expected: truthy value
-                  got: nil
-      """
-    And the output should contain:
-      """
-             expected: truthy value
-                  got: false
-      """
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: true
-      """
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: 7
-      """
-    And the output should contain:
-      """
-             expected: falsey value
-                  got: "foo"
-      """
-
-  Scenario: be_nil matcher
-    Given a file named "be_nil_spec.rb" with:
-      """ruby
-      describe "be_nil matcher" do
-        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 { 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`
-    Then the output should contain "10 examples, 5 failures"
-    And the output should contain:
-      """
-             expected: not nil
-                  got: nil
-      """
-    And the output should contain:
-      """
-             expected: nil
-                  got: false
-      """
-    And the output should contain:
-      """
-             expected: nil
-                  got: true
-      """
-    And the output should contain:
-      """
-             expected: nil
-                  got: 7
-      """
-    And the output should contain:
-      """
-             expected: nil
-                  got: "foo"
-      """
-
-  Scenario: be matcher
-    Given a file named "be_spec.rb" with:
-      """ruby
-      describe "be_matcher" do
-        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 { 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`
-    Then the output should contain all of these:
-      | 10 examples, 5 failures             |
-      | expected true to evaluate to false  |
-      | expected 7 to evaluate to false     |
-      | expected "foo" to evaluate to false |
-      | expected nil to evaluate to true    |
-      | expected false to evaluate to true  |

data/features/built_in_matchers/be_within.feature

@@ -1,48 +0,0 @@
-Feature: be_within matcher
-
-  Normal equality expectations do not work well for floating point values.
-  Consider this irb session:
-
-      > radius = 3
-        => 3
-      > area_of_circle = radius * radius * Math::PI
-        => 28.2743338823081
-      > area_of_circle == 28.2743338823081
-        => false
-
-  Instead, you should use the be_within matcher to check that the value
-  is within a delta of your expected value:
-
-    ```ruby
-    expect(area_of_circle).to be_within(0.1).of(28.3)
-    ```
-
-  Note that the difference between the actual and expected values must be
-  smaller than your delta; if it is equal, the matcher will fail.
-
-  Scenario: basic usage
-    Given a file named "be_within_matcher_spec.rb" with:
-      """ruby
-      describe 27.5 do
-        it { should be_within(0.5).of(27.9) }
-        it { should be_within(0.5).of(28.0) }
-        it { should be_within(0.5).of(27.1) }
-        it { should be_within(0.5).of(27.0) }
-
-        it { should_not be_within(0.5).of(28.1) }
-        it { should_not be_within(0.5).of(26.9) }
-
-        # deliberate failures
-        it { should_not be_within(0.5).of(28) }
-        it { should_not be_within(0.5).of(27) }
-        it { should be_within(0.5).of(28.1) }
-        it { should be_within(0.5).of(26.9) }
-      end
-      """
-    When I run `rspec be_within_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 10 examples, 4 failures                     |
-      | expected 27.5 not to be within 0.5 of 28   |
-      | expected 27.5 not to be within 0.5 of 27   |
-      | expected 27.5 to be within 0.5 of 28.1     |
-      | expected 27.5 to be within 0.5 of 26.9     |

data/features/built_in_matchers/comparisons.feature

@@ -1,97 +0,0 @@
-Feature: comparison matchers
-
-  RSpec provides a number of matchers that are based on Ruby's built-in
-  operators. These can be used for generalized comparison 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"
-      """