rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/features/composing_matchers.feature

@@ -1,250 +0,0 @@
-Feature: Composing Matchers
-
-  RSpec's matchers are designed to be composable so that you can
-  combine them to express the exact details of what you expect
-  but nothing more. This can help you avoid writing over-specified
-  brittle specs, by using a matcher in place of an exact value to
-  specify only the essential aspects of what you expect.
-
-  The following matchers accept matchers as arguments:
-
-    * `change { }.by(matcher)`
-    * `change { }.from(matcher).to(matcher)`
-    * `contain_exactly(matcher, matcher, matcher)`
-    * `end_with(matcher, matcher)`
-    * `include(matcher, matcher)`
-    * `include(:key => matcher, :other => matcher)`
-    * `match(arbitrary_nested_structure_with_matchers)`
-    * `output(matcher).to_stdout`
-    * `output(matcher).to_stderr`
-    * `raise_error(ErrorClass, matcher)`
-    * `start_with(matcher, matcher)`
-    * `throw_symbol(:sym, matcher)`
-    * `yield_with_args(matcher, matcher)`
-    * `yield_successive_args(matcher, matcher)`
-
-  Note that many built-in matchers do not accept matcher arguments
-  because they have precise semantics that do not allow for a matcher
-  argument. For example, `equal(some_object)` is designed to pass only
-  if the actual and expected arguments are references to the same object.
-  It would not make sense to support a matcher argument here.
-
-  All of RSpec's built-in matchers have one or more aliases that allow
-  you to use a noun-phrase rather than verb form since they read better
-  as composed arguments. They also provide customized failure output so
-  that the failure message reads better as well.
-
-  A full list of these aliases is out of scope here, but here are some
-  of the aliases used below:
-
-    * `be < 2` => `a_value < 2`
-    * `be > 2` => `a_value > 2`
-    * `be_an_instance_of` => `an_instance_of`
-    * `be_within` => `a_value_within`
-    * `contain_exactly` => `a_collection_containing_exactly`
-    * `end_with` => `a_string_ending_with`, `ending_with`
-    * `match` => `a_string_matching`
-    * `start_with` => `a_string_starting_with`
-
-  For a full list, see the API docs for the `RSpec::Matchers` module.
-
-  Scenario: Composing matchers with `change`
-    Given a file named "change_spec.rb" with:
-      """
-      describe "Passing matchers to `change`" do
-        specify "you can pass a matcher to `by`" do
-          k = 0
-          expect { k += 1.05 }.to change { k }.
-            by( a_value_within(0.1).of(1.0) )
-        end
-
-        specify "you can pass matchers to `from` and `to" do
-          s = "food"
-          expect { s = "barn" }.to change { s }.
-            from( a_string_matching(/foo/) ).
-            to( a_string_matching(/bar/) )
-        end
-      end
-      """
-    When I run `rspec change_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `contain_exactly`
-    Given a file named "contain_exactly_spec.rb" with:
-      """
-      describe "Passing matchers to `contain_exactly`" do
-        specify "you can pass matchers in place of exact values" do
-          expect(["barn", 2.45]).to contain_exactly(
-            a_value_within(0.1).of(2.5),
-            a_string_starting_with("bar")
-          )
-        end
-      end
-      """
-    When I run `rspec contain_exactly_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `end_with`
-    Given a file named "end_with_spec.rb" with:
-      """
-      describe "Passing matchers to `end_with`" do
-        specify "you can pass matchers in place of exact values" do
-          expect(["barn", "food", 2.45]).to end_with(
-            a_string_matching("foo"),
-            a_value > 2
-          )
-        end
-      end
-      """
-    When I run `rspec end_with_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `include`
-    Given a file named "include_spec.rb" with:
-      """
-      describe "Passing matchers to `contain_exactly`" do
-        specify "you can use matchers in place of array values" do
-          expect(["barn", 2.45]).to include( a_string_starting_with("bar") )
-        end
-
-        specify "you can use matchers in place of hash values" do
-          expect(:a => "food", :b => "good").to include(:a => a_string_matching(/foo/))
-        end
-
-        specify "you can use matchers in place of hash keys" do
-          expect("food" => "is good").to include( a_string_matching(/foo/) )
-        end
-      end
-      """
-    When I run `rspec include_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `match`:
-    Given a file named "match_spec.rb" with:
-      """
-      describe "Passing matchers to `match`" do
-        specify "you can match nested data structures against matchers" do
-          hash = {
-            :a => {
-              :b => ["foo", 5],
-              :c => { :d => 2.05 }
-            }
-          }
-
-          expect(hash).to match(
-            :a => {
-              :b => a_collection_containing_exactly(
-                a_string_starting_with("f"),
-                an_instance_of(Fixnum)
-              ),
-              :c => { :d => (a_value < 3) }
-            }
-          )
-        end
-      end
-      """
-    When I run `rspec match_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `output`
-    Given a file named "output_spec.rb" with:
-      """
-      describe "Passing matchers to `output`" do
-        specify "you can pass a matcher in place of the output (to_stdout)" do
-          expect {
-            print 'foo'
-          }.to output(a_string_starting_with('f')).to_stdout
-        end
-        specify "you can pass a matcher in place of the output (to_stderr)" do
-          expect {
-            warn 'foo'
-          }.to output(a_string_starting_with('f')).to_stderr
-        end
-      end
-      """
-    When I run `rspec output_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `raise_error`
-    Given a file named "raise_error_spec.rb" with:
-      """
-      describe "Passing matchers to `raise_error`" do
-        specify "you can pass a matcher in place of the message" do
-          expect {
-            raise RuntimeError, "this goes boom"
-          }.to raise_error(RuntimeError, a_string_ending_with("boom"))
-        end
-      end
-      """
-    When I run `rspec raise_error_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `start_with`
-    Given a file named "start_with_spec.rb" with:
-      """
-      describe "Passing matchers to `start_with`" do
-        specify "you can pass matchers in place of exact values" do
-          expect(["barn", "food", 2.45]).to start_with(
-            a_string_matching("bar"),
-            a_string_matching("foo")
-          )
-        end
-      end
-      """
-    When I run `rspec start_with_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `throw_symbol`
-    Given a file named "throw_symbol_spec.rb" with:
-      """
-      describe "Passing matchers to `throw_symbol`" do
-        specify "you can pass a matcher in place of a throw arg" do
-          expect {
-            throw :pi, Math::PI
-          }.to throw_symbol(:pi, a_value_within(0.01).of(3.14))
-        end
-      end
-      """
-    When I run `rspec throw_symbol_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `yield_with_args`
-    Given a file named "yield_with_args_spec.rb" with:
-      """
-      describe "Passing matchers to `yield_with_args`" do
-        specify "you can pass matchers in place of the args" do
-          expect { |probe|
-            "food".tap(&probe)
-          }.to yield_with_args(a_string_matching(/foo/))
-        end
-      end
-      """
-    When I run `rspec yield_with_args_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers with `yield_successive_args`
-    Given a file named "yield_successive_args_spec.rb" with:
-      """
-      describe "Passing matchers to `yield_successive_args`" do
-        specify "you can pass matchers in place of the args" do
-          expect { |probe|
-            [1, 2, 3].each(&probe)
-          }.to yield_successive_args(a_value < 2, 2, a_value > 2)
-        end
-      end
-      """
-    When I run `rspec yield_successive_args_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Composing matchers using a compound `and` expression
-    Given a file named "include_spec.rb" with:
-      """
-      describe "Passing a compound matcher expression to `include`" do
-        example do
-          expect(["food", "drink"]).to include( a_string_starting_with("f").and ending_with("d"))
-        end
-      end
-      """
-    When I run `rspec include_spec.rb`
-    Then the examples should all pass
-

data/features/compound_expectations.feature

@@ -1,45 +0,0 @@
-Feature: Compound Expectations
-
-  Matchers can be composed using `and` or `or` to make compound expectations.
-
-  Scenario: Use `and` to chain expectations
-    Given a file named "compound_and_matcher_spec.rb" with:
-      """ruby
-      describe "A compound `and` matcher" do
-        let(:string) { "foo bar bazz" }
-
-        it "passes when both are true" do
-          expect(string).to start_with("foo").and end_with("bazz")
-        end
-
-        it "fails when the first matcher fails" do
-          expect(string).to start_with("bar").and end_with("bazz")
-        end
-
-        it "fails when the second matcher fails" do
-          expect(string).to start_with("foo").and end_with("bar")
-        end
-      end
-      """
-    When I run `rspec compound_and_matcher_spec.rb`
-    Then the output should contain "3 examples, 2 failures"
-
-  Scenario: Use `or` to chain expectations
-    Given a file named "stoplight_spec.rb" with:
-      """ruby
-      class StopLight
-        def color
-          %w[ green yellow red ].shuffle.first
-        end
-      end
-
-      describe StopLight, "#color" do
-        it "is green, yellow or red" do
-          light = StopLight.new
-          expect(light.color).to eq("green").or eq("yellow").or eq("red")
-        end
-      end
-      """
-    When I run `rspec stoplight_spec.rb`
-    Then the example should pass
-

data/features/custom_matchers/access_running_example.feature

@@ -1,53 +0,0 @@
-Feature: access running example
-
-  In order to take advantage of services that are available
-    in my examples when I'm writing matchers
-  As a spec author
-  I want to call methods on the running example
-
-  If the method exists in the context of the example, it gets
-  called. If not, a NoMethodError is raised on the Matcher itself
-  (not the example).
-
-  Scenario: call method defined on example from matcher
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :bar do
-        match do |_|
-          foo == "foo"
-        end
-      end
-
-      describe "something" do
-        def foo
-          "foo"
-        end
-
-        it "does something" do
-          expect("foo").to bar
-        end
-      end
-      """
-    When I run `rspec ./example_spec.rb`
-    Then the output should contain "1 example, 0 failures"
-
-  Scenario: call method _not_ defined on example from matcher
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :bar do
-        match do |_|
-          foo == "foo"
-        end
-      end
-
-      describe "something" do
-        it "does something" do
-          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 not contain "ExampleGroup"

data/features/custom_matchers/define_diffable_matcher.feature

@@ -1,27 +0,0 @@
-Feature: define diffable matcher
-
-  When a matcher is defined as diffable, and the --diff
-  flag is set, the output will include a diff of the submitted
-  objects.
-
-  @wip
-  Scenario: define a diffable matcher
-    Given a file named "diffable_matcher_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :be_just_like do |expected|
-        match do |actual|
-          actual == expected
-        end
-
-        diffable
-      end
-
-      describe "this" do
-        it {should be_just_like("that")}
-      end
-      """
-    When I run `rspec ./diffable_matcher_spec.rb --diff`
-    Then the exit status should not be 0
-
-    And the output should contain "should be just like that"
-    And the output should contain "Diff:\n@@ -1,2 +1,2 @@\n-that\n+this"

data/features/custom_matchers/define_matcher.feature

@@ -1,340 +0,0 @@
-Feature: define matcher
-
-  In order to express my domain clearly in my code examples
-  As an RSpec user
-  I want a shortcut to define custom matchers
-
-  Scenario: define a matcher with default messages
-    Given a file named "matcher_with_default_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-
-      """
-    When I run `rspec ./matcher_with_default_message_spec.rb --format documentation`
-    Then the exit status should not be 0
-
-    And the output should contain "should be a multiple of 3"
-    And the output should contain "should not be a multiple of 4"
-    And the output should contain "Failure/Error: it {should be_a_multiple_of(4)}"
-    And the output should contain "Failure/Error: it {should_not be_a_multiple_of(3)}"
-
-    And the output should contain "4 examples, 2 failures"
-    And the output should contain "expected 9 to be a multiple of 4"
-    And the output should contain "expected 9 not to be a multiple of 3"
-
-  Scenario: overriding the failure_message
-    Given a file named "matcher_with_failure_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message do |actual|
-          "expected that #{actual} would be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should be_a_multiple_of(4)}
-      end
-      """
-    When I run `rspec ./matcher_with_failure_message_spec.rb`
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would be a multiple of 4"
-
-  Scenario: overriding the failure_message_when_negated
-    Given a file named "matcher_with_failure_for_message_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        failure_message_when_negated do |actual|
-          "expected that #{actual} would not be a multiple of #{expected}"
-        end
-      end
-
-      # fail intentionally to generate expected output
-      describe 9 do
-        it {should_not be_a_multiple_of(3)}
-      end
-      """
-    When I run `rspec ./matcher_with_failure_for_message_spec.rb`
-    Then the exit status should not be 0
-    And the stdout should contain "1 example, 1 failure"
-    And the stdout should contain "expected that 9 would not be a multiple of 3"
-
-  Scenario: overriding the description
-    Given a file named "matcher_overriding_description_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-        description do
-          "be multiple of #{expected}"
-        end
-      end
-
-      describe 9 do
-        it {should be_a_multiple_of(3)}
-      end
-
-      describe 9 do
-        it {should_not be_a_multiple_of(4)}
-      end
-      """
-    When I run `rspec ./matcher_overriding_description_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "2 examples, 0 failures"
-    And the stdout should contain "should be multiple of 3"
-    And the stdout should contain "should not be multiple of 4"
-
-  Scenario: with no args
-    Given a file named "matcher_with_no_args_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_7_fingers do
-        match do |thing|
-          thing.fingers.length == 7
-        end
-      end
-
-      class Thing
-        def fingers; (1..7).collect {"finger"}; end
-      end
-
-      describe Thing do
-        it {should have_7_fingers}
-      end
-      """
-    When I run `rspec ./matcher_with_no_args_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should have 7 fingers"
-
-  Scenario: with multiple args
-    Given a file named "matcher_with_multiple_args_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :be_the_sum_of do |a,b,c,d|
-        match do |sum|
-          a + b + c + d == sum
-        end
-      end
-
-      describe 10 do
-        it {should be_the_sum_of(1,2,3,4)}
-      end
-      """
-    When I run `rspec ./matcher_with_multiple_args_spec.rb --format documentation`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-    And the stdout should contain "should be the sum of 1, 2, 3, and 4"
-
-  Scenario: with helper methods
-    Given a file named "matcher_with_internal_helper_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      RSpec::Matchers.define :have_same_elements_as do |sample|
-        match do |actual|
-          similar?(sample, actual)
-        end
-
-        def similar?(a, b)
-          a.sort == b.sort
-        end
-      end
-
-      describe "these two arrays" do
-        specify "should be similar" do
-          expect([1,2,3]).to have_same_elements_as([2,3,1])
-        end
-      end
-      """
-    When I run `rspec ./matcher_with_internal_helper_spec.rb`
-    Then the exit status should be 0
-    And the stdout should contain "1 example, 0 failures"
-
-  Scenario: scoped in a module
-    Given a file named "scoped_matcher_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      module MyHelpers
-        extend RSpec::Matchers::DSL
-
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-      end
-
-      describe "group with MyHelpers" do
-        include MyHelpers
-        it "has access to the defined matcher" do
-          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
-            expect(5).to be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    When I run `rspec ./scoped_matcher_spec.rb`
-    Then the stdout should contain "2 examples, 0 failures"
-
-  Scenario: scoped in an example group
-    Given a file named "scoped_matcher_spec.rb" with:
-      """ruby
-      require 'rspec/expectations'
-
-      describe "group with matcher" do
-        matcher :be_just_like do |expected|
-          match {|actual| actual == expected}
-        end
-
-        it "has access to the defined matcher" do
-          expect(5).to be_just_like(5)
-        end
-
-        describe "nested group" do
-          it "has access to the defined matcher" do
-            expect(5).to be_just_like(5)
-          end
-        end
-
-      end
-
-      describe "group without matcher" do
-        it "does not have access to the defined matcher" do
-          expect do
-            expect(5).to be_just_like(5)
-          end.to raise_exception
-        end
-      end
-      """
-
-    When I run `rspec scoped_matcher_spec.rb`
-    Then the output should contain "3 examples, 0 failures"
-
-  Scenario: matcher with separate logic for should and should_not
-    Given a file named "matcher_with_separate_should_not_logic_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :contain do |*expected|
-        match do |actual|
-          expected.all? { |e| actual.include?(e) }
-        end
-
-        match_when_negated do |actual|
-          expected.none? { |e| actual.include?(e) }
-        end
-      end
-
-      describe [1, 2, 3] do
-        it { should contain(1, 2) }
-        it { should_not contain(4, 5, 6) }
-
-        # deliberate failures
-        it { should contain(1, 4) }
-        it { should_not contain(1, 4) }
-      end
-      """
-    When I run `rspec matcher_with_separate_should_not_logic_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                    |
-      | expected [1, 2, 3] to contain 1 and 4     |
-      | expected [1, 2, 3] not to contain 1 and 4 |
-
-  Scenario: use define_method to create a helper method with access to matcher params
-    Given a file named "define_method_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        define_method :is_multiple? do |actual|
-          actual % expected == 0
-        end
-        match { |actual| is_multiple?(actual) }
-      end
-
-      describe 9 do
-        it { should be_a_multiple_of(3) }
-        it { should_not be_a_multiple_of(4) }
-
-        # deliberate failures
-        it { should be_a_multiple_of(2) }
-        it { should_not be_a_multiple_of(3) }
-      end
-      """
-    When I run `rspec define_method_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures               |
-      | expected 9 to be a multiple of 2     |
-      | expected 9 not to be a multiple of 3 |
-
-  Scenario: include a module with helper methods in the matcher
-    Given a file named "include_module_spec.rb" with:
-      """ruby
-      module MatcherHelpers
-        def is_multiple?(actual, expected)
-          actual % expected == 0
-        end
-      end
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        include MatcherHelpers
-        match { |actual| is_multiple?(actual, expected) }
-      end
-
-      describe 9 do
-        it { should be_a_multiple_of(3) }
-        it { should_not be_a_multiple_of(4) }
-
-        # deliberate failures
-        it { should be_a_multiple_of(2) }
-        it { should_not be_a_multiple_of(3) }
-      end
-      """
-    When I run `rspec include_module_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures               |
-      | expected 9 to be a multiple of 2     |
-      | expected 9 not to be a multiple of 3 |