rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/features/built_in_matchers/satisfy.feature

@@ -1,33 +0,0 @@
-Feature: satisfy matcher
-
-  The satisfy matcher is extremely flexible and can handle almost anything
-  you want to specify.  It passes if the block you provide returns true:
-
-    ```ruby
-    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
-  ("expected [actual] to satisfy block") is not very descriptive
-  or helpful.  You will usually be better served by using one of
-  the other built-in matchers, or writing a custom matcher.
-
-  Scenario: basic usage
-    Given a file named "satisfy_matcher_spec.rb" with:
-      """ruby
-      describe 10 do
-        it { should satisfy { |v| v > 5 } }
-        it { should_not satisfy { |v| v > 15 } }
-
-        # deliberate failures
-        it { should_not satisfy { |v| v > 5 } }
-        it { should satisfy { |v| v > 15 } }
-      end
-      """
-    When I run `rspec satisfy_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures           |
-      | expected 10 not to satisfy block |
-      | expected 10 to satisfy block     |
-

data/features/built_in_matchers/start_with.feature

@@ -1,48 +0,0 @@
-Feature: start_with matcher
-
-  Use the `start_with` matcher to specify that a string or array starts with
-  the expected characters or elements.
-
-    ```ruby
-    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
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "this string" do
-        it { should start_with "this" }
-        it { should_not start_with "that" }
-
-        # deliberate failures
-        it { should_not start_with "this" }
-        it { should start_with "that" }
-      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 start with "this" |
-      | expected "this string" to start with "that"     |
-
-  Scenario: with an array
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe [0, 1, 2, 3, 4] do
-        it { should start_with 0 }
-        it { should start_with(0, 1)}
-        it { should_not start_with(2) }
-        it { should_not start_with(0, 1, 2, 3, 4, 5) }
-
-        # deliberate failures
-        it { should_not start_with 0 }
-        it { should start_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 start with 0 |
-      | expected [0, 1, 2, 3, 4] to start with 3     |

data/features/built_in_matchers/throw_symbol.feature

@@ -1,91 +0,0 @@
-Feature: throw_symbol matcher
-
-  The throw_symbol matcher is used to specify that a block of code
-  throws a symbol.  The most basic form passes if any symbol is thrown:
-
-    ```ruby
-    expect { throw :foo }.to throw_symbol
-    ```
-
-  You'll often want to specify that a particular symbol is thrown:
-
-    ```ruby
-    expect { throw :foo }.to throw_symbol(:foo)
-    ```
-
-  If you care about the additional argument given to throw, you can
-  specify that as well:
-
-    ```ruby
-    expect { throw :foo, 7 }.to throw_symbol(:foo, 7)
-    ```
-
-  Scenario: basic usage
-    Given a file named "throw_symbol_matcher_spec.rb" with:
-      """ruby
-      describe "throw" do
-        specify { expect { throw :foo    }.to     throw_symbol }
-        specify { expect { throw :bar, 7 }.to     throw_symbol }
-        specify { expect { 5 + 5         }.not_to throw_symbol }
-
-        # deliberate failures
-        specify { expect { throw :foo    }.not_to throw_symbol }
-        specify { expect { throw :bar, 7 }.not_to throw_symbol }
-        specify { expect { 5 + 5         }.to     throw_symbol }
-      end
-      """
-    When I run `rspec throw_symbol_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 6 examples, 3 failures                      |
-      | expected no Symbol to be thrown, got :foo   |
-      | expected no Symbol to be thrown, got :bar   |
-      | expected a Symbol to be thrown, got nothing |
-
-  Scenario: specify thrown symbol
-    Given a file named "throw_symbol_matcher_spec.rb" with:
-      """ruby
-      describe "throw symbol" do
-        specify { expect { throw :foo    }.to     throw_symbol(:foo) }
-        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo) }
-        specify { expect { 5 + 5         }.not_to throw_symbol(:foo) }
-        specify { expect { throw :bar    }.not_to throw_symbol(:foo) }
-
-        # deliberate failures
-        specify { expect { throw :foo    }.not_to throw_symbol(:foo) }
-        specify { expect { throw :foo, 7 }.not_to throw_symbol(:foo) }
-        specify { expect { 5 + 5         }.to     throw_symbol(:foo) }
-        specify { expect { throw :bar    }.to     throw_symbol(:foo) }
-      end
-      """
-    When I run `rspec throw_symbol_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                          |
-      | expected :foo not to be thrown, got :foo        |
-      | expected :foo not to be thrown, got :foo with 7 |
-      | expected :foo to be thrown, got nothing         |
-      | expected :foo to be thrown, got :bar            |
-
-  Scenario: specify thrown symbol and argument
-    Given a file named "throw_symbol_argument_matcher_spec.rb" with:
-      """ruby
-      describe "throw symbol with argument" do
-        specify { expect { throw :foo, 7 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :foo, 8 }.not_to throw_symbol(:foo, 7) }
-        specify { expect { throw :bar, 7 }.not_to throw_symbol(:foo, 7) }
-        specify { expect { throw :foo    }.not_to throw_symbol(:foo, 7) }
-
-        # deliberate failures
-        specify { expect { throw :foo, 7 }.not_to throw_symbol(:foo, 7) }
-        specify { expect { throw :foo, 8 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :bar, 7 }.to     throw_symbol(:foo, 7) }
-        specify { expect { throw :foo    }.to     throw_symbol(:foo, 7) }
-      end
-      """
-    When I run `rspec throw_symbol_argument_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                                       |
-      | expected :foo with 7 not to be thrown, got :foo with 7       |
-      | expected :foo with 7 to be thrown, got :foo with 8           |
-      | expected :foo with 7 to be thrown, got :bar                  |
-      | expected :foo with 7 to be thrown, got :foo with no argument |
-

data/features/built_in_matchers/types.feature

@@ -1,116 +0,0 @@
-Feature: specify types of objects
-
-  rspec-expectations includes two matchers to specify types of objects:
-
-    * `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.
-    * `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
-    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
-    Given a file named "be_kind_of_matcher_spec.rb" with:
-      """ruby
-      module MyModule; end
-
-      class Fixnum
-        include MyModule
-      end
-
-      describe 17 do
-        # the actual class
-        it { should be_kind_of(Fixnum) }
-        it { should be_a_kind_of(Fixnum) }
-        it { should be_a(Fixnum) }
-
-        # the superclass
-        it { should be_kind_of(Integer) }
-        it { should be_a_kind_of(Integer) }
-        it { should be_an(Integer) }
-
-        # an included module
-        it { should be_kind_of(MyModule) }
-        it { should be_a_kind_of(MyModule) }
-        it { should be_a(MyModule) }
-
-        # negative passing case
-        it { should_not be_kind_of(String) }
-        it { should_not be_a_kind_of(String) }
-        it { should_not be_a(String) }
-
-        # deliberate failures
-        it { should_not be_kind_of(Fixnum) }
-        it { should_not be_a_kind_of(Fixnum) }
-        it { should_not be_a(Fixnum) }
-        it { should_not be_kind_of(Integer) }
-        it { should_not be_a_kind_of(Integer) }
-        it { should_not be_an(Integer) }
-        it { should_not be_kind_of(MyModule) }
-        it { should_not be_a_kind_of(MyModule) }
-        it { should_not be_a(MyModule) }
-        it { should be_kind_of(String) }
-        it { should be_a_kind_of(String) }
-        it { should be_a(String) }
-      end
-      """
-    When I run `rspec be_kind_of_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 24 examples, 12 failures                 |
-      | expected 17 not to be a kind of Fixnum   |
-      | expected 17 not to be a kind of Integer  |
-      | expected 17 not to be a kind of MyModule |
-      | expected 17 to be a kind of String       |
-
-  Scenario: be_(an_)instance_of matcher
-    Given a file named "be_instance_of_matcher_spec.rb" with:
-      """ruby
-      module MyModule; end
-
-      class Fixnum
-        include MyModule
-      end
-
-      describe 17 do
-        # the actual class
-        it { should be_instance_of(Fixnum) }
-        it { should be_an_instance_of(Fixnum) }
-
-        # the superclass
-        it { should_not be_instance_of(Integer) }
-        it { should_not be_an_instance_of(Integer) }
-
-        # an included module
-        it { should_not be_instance_of(MyModule) }
-        it { should_not be_an_instance_of(MyModule) }
-
-        # another class with no relation to the subject's hierarchy
-        it { should_not be_instance_of(String) }
-        it { should_not be_an_instance_of(String) }
-
-        # deliberate failures
-        it { should_not be_instance_of(Fixnum) }
-        it { should_not be_an_instance_of(Fixnum) }
-        it { should be_instance_of(Integer) }
-        it { should be_an_instance_of(Integer) }
-        it { should be_instance_of(MyModule) }
-        it { should be_an_instance_of(MyModule) }
-        it { should be_instance_of(String) }
-        it { should be_an_instance_of(String) }
-      end
-      """
-    When I run `rspec be_instance_of_matcher_spec.rb`
-    Then the output should contain all of these:
-      | 16 examples, 8 failures                     |
-      | expected 17 not to be an instance of Fixnum |
-      | expected 17 to be an instance of Integer    |
-      | expected 17 to be an instance of MyModule   |
-      | expected 17 to be an instance of String     |

data/features/built_in_matchers/yield.feature

@@ -1,161 +0,0 @@
-Feature: yield matchers
-
-  There are four related matchers that allow you to specify whether
-  or not a method yields, how many times it yields, whether or not
-  it yields with arguments, and what those arguments are.
-
-    * `yield_control` matches if the method-under-test yields, regardless
-      of whether or not arguments are yielded.
-    * `yield_with_args` matches if the method-under-test yields with
-      arguments. If arguments are provided to this matcher, it will
-      only pass if the actual yielded arguments match the expected ones
-      using `===` or `==`.
-    * `yield_with_no_args` matches if the method-under-test yields with
-      no arguments.
-    * `yield_successive_args` is designed for iterators, and will match
-      if the method-under-test yields the same number of times as arguments
-      passed to this matcher, and all actual yielded arguments match the
-      expected ones using `===` or `==`.
-
-  Note: your expect block _must_ accept an argument that is then passed on to
-  the method-under-test as a block. This acts as a "probe" that allows the matcher
-  to detect whether or not your method yields, and, if so, how many times and what
-  the yielded arguments are.
-
-  Background:
-    Given a file named "my_class.rb" with:
-      """ruby
-      class MyClass
-        def self.yield_once_with(*args)
-          yield *args
-        end
-
-        def self.yield_twice_with(*args)
-          2.times { yield *args }
-        end
-
-        def self.raw_yield
-          yield
-        end
-
-        def self.dont_yield
-        end
-      end
-      """
-
-  Scenario: yield_control matcher
-    Given a file named "yield_control_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_control matcher" do
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control }
-        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_control }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.twice }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.exactly(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_least(1) }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.to yield_control.at_most(3).times }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.not_to yield_control }
-        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_control }
-        specify { expect { |b| MyClass.yield_once_with(1, &b) }.to yield_control.at_least(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.twice }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(2).times }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_least(1) }
-        specify { expect { |b| MyClass.yield_twice_with(1, &b) }.not_to yield_control.at_most(3).times }
-      end
-      """
-    When I run `rspec yield_control_spec.rb`
-    Then the output should contain all of these:
-      | 13 examples, 7 failures                                   |
-      | expected given block to yield control                     |
-      | expected given block not to yield control                 |
-      | expected given block not to yield control at least twice  |
-      | expected given block not to yield control at most 3 times |
-
-  Scenario: yield_with_args matcher
-    Given a file named "yield_with_args_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_with_args matcher" do
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args("foo") }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.to yield_with_args(/oo/) }
-
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args("foo", "bar") }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(String, String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(/fo/, /ar/) }
-
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args(17, "baz") }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args("foo") }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(String) }
-        specify { expect { |b| MyClass.yield_once_with("foo", &b) }.not_to yield_with_args(/oo/) }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.not_to yield_with_args("foo", "bar") }
-        specify { expect { |b| MyClass.yield_once_with("foo", "bar", &b) }.to yield_with_args(17, "baz") }
-      end
-      """
-    When I run `rspec yield_with_args_spec.rb`
-    Then the output should contain all of these:
-      | 14 examples, 6 failures                                                               |
-      | expected given block not to yield with arguments, but did                             |
-      | expected given block not to yield with arguments, but yielded with expected arguments |
-      | expected given block to yield with arguments, but yielded with unexpected arguments   |
-
-  Scenario: yield_with_no_args matcher
-    Given a file named "yield_with_no_args_spec.rb" with:
-      """ruby
-      require './my_class'
-
-      describe "yield_with_no_args matcher" do
-        specify { expect { |b| MyClass.raw_yield(&b) }.to yield_with_no_args }
-        specify { expect { |b| MyClass.dont_yield(&b) }.not_to yield_with_no_args }
-        specify { expect { |b| MyClass.yield_once_with("a", &b) }.not_to yield_with_no_args }
-
-        # deliberate failures
-        specify { expect { |b| MyClass.raw_yield(&b) }.not_to yield_with_no_args }
-        specify { expect { |b| MyClass.dont_yield(&b) }.to yield_with_no_args }
-        specify { expect { |b| MyClass.yield_once_with("a", &b) }.to yield_with_no_args }
-      end
-      """
-    When I run `rspec yield_with_no_args_spec.rb`
-    Then the output should contain all of these:
-      | 6 examples, 3 failures                                                             |
-      | expected given block not to yield with no arguments, but did                       |
-      | expected given block to yield with no arguments, but did not yield                 |
-      | expected given block to yield with no arguments, but yielded with arguments: ["a"] |
-
-  Scenario: yield_successive_args matcher
-    Given a file named "yield_successive_args_spec.rb" with:
-      """ruby
-      def array
-        [1, 2, 3]
-      end
-
-      def array_of_tuples
-        [[:a, :b], [:c, :d]]
-      end
-
-      describe "yield_successive_args matcher" do
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2, 3) }
-        specify { expect { |b| array_of_tuples.each(&b) }.to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(Fixnum, Fixnum, Fixnum) }
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2) }
-
-        # deliberate failures
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2, 3) }
-        specify { expect { |b| array_of_tuples.each(&b) }.not_to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(Fixnum, Fixnum, Fixnum) }
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2) }
-      end
-      """
-    When I run `rspec yield_successive_args_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures                                                                             |
-      | expected given block not to yield successively with arguments, but yielded with expected arguments |
-      | expected given block to yield successively with arguments, but yielded with unexpected arguments   |