rspec-expectations 2.13.0 → 3.0.0

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:
-
-    * `obj.should 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.
-    * `obj.should 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
-    obj.should be_a_kind_of(type)      # same as obj.should be_kind_of(type)
-    obj.should be_a(type)              # same as obj.should be_kind_of(type)
-    obj.should be_an(type)             # same as obj.should be_kind_of(type)
-    obj.should be_an_instance_of(type) # same as obj.should 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,146 +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.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 }
-
-        # 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 }
-      end
-      """
-    When I run `rspec yield_control_spec.rb`
-    Then the output should contain all of these:
-      | 4 examples, 2 failures                      |
-      | expected given block to yield control       |
-      | expected given block not to yield control   |
-
-  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   |

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
-          "foo".should 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
-          "foo".should 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"