rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/features/message_expectations/warn_when_expectation_is_set_on_nil.feature

@@ -1,50 +0,0 @@
-Feature: warn when expectation is set on nil
-
-  Scenario: nil instance variable
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something" do
-          expect(@i_do_not_exist).to receive(:foo)
-          @i_do_not_exist.foo
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "An expectation of :foo was set on nil"
-
-  Scenario: allow
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something" do
-          allow_message_expectations_on_nil
-          expect(nil).to receive(:foo)
-          nil.foo
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "An expectation"
-
-  Scenario: allow in one example, but not on another
-    Given a file named "example_spec.rb" with:
-      """ruby
-      RSpec.configure {|c| c.mock_with :rspec}
-      describe "something" do
-        it "does something (foo)" do
-          allow_message_expectations_on_nil
-          nil.should_receive(:foo)
-          nil.foo
-        end
-        it "does something (bar)" do
-          expect(nil).to receive(:bar)
-          nil.bar
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain "An expectation of :bar"
-    And  the output should not contain "An expectation of :foo"

data/features/method_stubs/README.md

@@ -1,77 +0,0 @@
-### Stub return values
-
-    # create a double
-    obj = double()
-
-    # specify a return value using `:expect` syntax
-    allow(obj).to receive(:message) { :value }
-    allow(obj).to receive(:message).and_return(:value)
-
-    # specify a return value using `:should` syntax
-    obj.stub(:message) { :value }
-    obj.stub(:message => :value)
-    obj.stub(:message).and_return(:value)
-
-These forms are somewhat interchangeable. The difference is that the
-block contents are evaluated lazily when the `obj` receives the
-`message` message, whereas the others are evaluated as they are read.
-
-### Fake implementation
-
-    allow(obj).to receive(:message) do |arg1, arg2|
-      # set expectations about the args in this block
-      # and/or return value
-    end
-
-    obj.stub(:message) do |arg1, arg2|
-      # set expectations about the args in this block
-      # and/or return a value
-    end
-
-### Raising/Throwing
-
-    allow(obj).to receive(:message).and_raise("this error")
-    allow(obj).to receive(:message).and_throw(:this_symbol)
-
-    obj.stub(:message).and_raise("this error")
-    obj.stub(:message).and_throw(:this_symbol)
-
-You can also use the block format:
-
-    allow(obj).to receive(:message) { raise "this error" }
-    allow(obj).to receive(:message) { throw :this_symbol }
-
-    obj.stub(:message) { raise "this error" }
-    obj.stub(:message) { throw :this_symbol }
-
-### Argument constraints
-
-#### Explicit arguments
-
-    allow(obj).to receive(:message).with('an argument') { ... }
-    allow(obj).to receive(:message).with('more than', 'an argument') { ... }
-
-    obj.stub(:message).with('an argument') { ... }
-    obj.stub(:message).with('more_than', 'one_argument') { ... }
-
-#### Argument matchers
-
-    allow(obj).to receive(:message).with(anything()) { ... }
-    allow(obj).to receive(:message).with(an_instance_of(Money)) { ... }
-    allow(obj).to receive(:message).with(hash_including(:a => 'b')) { ... }
-    allow(obj).to receive(:message).with(array_including(1,2,3)) { ... }
-    # or
-    allow(obj).to receive(:message).with(array_including([1,2,3])) { ... }
-
-    obj.stub(:message).with(anything()) { ... }
-    obj.stub(:message).with(an_instance_of(Money)) { ... }
-    obj.stub(:message).with(hash_including(:a => 'b')) { ... }
-    obj.stub(:message).with(array_including(1,2,3)) { ... }
-    # or
-    obj.stub(:message).with(array_including([1,2,3])) { ... }
-
-#### Regular expressions
-
-    allow(obj).to receive(:message).with(/abc/) { ... }
-
-    obj.stub(:message).with(/abc/) { ... }

data/features/method_stubs/allow_any_instance_of.feature

@@ -1,136 +0,0 @@
-Feature: stub on any instance of a class
-
-  Use `allow_any_instance_of` on a class to tell any instance of that class to
-  return a value (or values) in response to a given message.  If no instance
-  receives the message, nothing happens.
-
-  Messages can be stubbed on any class, including those in Ruby's core library.
-
-  Note: You can use `allow_any_instance_of` when you don't have a reference
-  to the object that receives a message in your test. For more information,
-  see the message_expectations/allow_any_instance_of feature.
-
-  Scenario: Stubbing any instance of an object with a single return value
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "stubbing any instance" do
-        it "returns the specified value on any instance of the class" do
-          allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)
-
-          o = Object.new
-          expect(o.foo).to eq(:return_value)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: any_instance stub with a hash
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "any_instance.stub" do
-        context "with a hash" do
-          it "returns the hash values on any instance of the class" do
-            allow_any_instance_of(Object).to receive_messages(:foo => 'foo', :bar => 'bar')
-
-            o = Object.new
-            expect(o.foo).to eq('foo')
-            expect(o.bar).to eq('bar')
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Stubbing any instance of an object with specific arguments matchers
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "stubbing any instance" do
-        context "with arguments" do
-          it "returns the stubbed value when arguments match" do
-            allow_any_instance_of(Object).to receive(:foo).with(:param_one, :param_two).and_return(:result_one)
-            allow_any_instance_of(Object).to receive(:foo).with(:param_three, :param_four).and_return(:result_two)
-
-            o = Object.new
-            expect(o.foo(:param_one, :param_two)).to eq(:result_one)
-            expect(o.foo(:param_three, :param_four)).to eq(:result_two)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: any_instance unstub
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "any_instance.unstub" do
-        it "unstubs a stubbed method" do
-          class Object
-            def foo
-              :foo
-            end
-          end
-
-          Object.any_instance.stub(:foo)
-          Object.any_instance.unstub(:foo)
-
-          expect(Object.new.foo).to eq(:foo)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: any_instance unstub
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "any_instance.unstub" do
-        context "with both an expectation and a stub already set" do
-          it "only removes the stub" do
-            class Object
-              def foo
-                :foo
-              end
-            end
-            expect_any_instance_of(Object).to receive(:foo).and_return(:bar)
-            Object.any_instance.stub(:foo)
-            Object.any_instance.unstub(:foo)
-
-            expect(Object.new.foo).to eq(:bar)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: stub a chain of methods an any instance
-    Given a file named "stub_chain_spec.rb" with:
-      """ruby
-      describe "stubbing a chain of methods" do
-        context "given symbols representing methods" do
-          it "returns the correct value" do
-            allow_any_instance_of(Object).to receive_message_chain(:one, :two, :three).and_return(:four)
-            expect(Object.new.one.two.three).to eq(:four)
-          end
-        end
-
-        context "given a hash at the end" do
-          it "returns the correct value" do
-            allow_any_instance_of(Object).to receive_message_chain(:one, :two, :three=> :four)
-            expect(Object.new.one.two.three).to eq(:four)
-          end
-        end
-
-        context "given a string of methods separated by dots" do
-          it "returns the correct value" do
-            allow_any_instance_of(Object).to receive_message_chain("one.two.three").and_return(:four)
-            expect(Object.new.one.two.three).to eq(:four)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_chain_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/as_null_object.feature

@@ -1,40 +0,0 @@
-Feature: as_null_object
-
-  Use the `as_null_object` method to ignore any messages that aren't explicitly
-  set as stubs or message expectations.
-
-  EXCEPTION: `to_ary` will raise a NoMethodError unless explicitly stubbed in
-  order to support `flatten` on an Array containing a double.
-
-  Scenario: double acting as_null_object
-    Given a file named "as_null_object_spec.rb" with:
-      """ruby
-      describe "a double with as_null_object called" do
-        let(:null_object) { double('null object').as_null_object }
-
-        it "responds to any method that is not defined" do
-          expect(null_object).to respond_to(:an_undefined_method)
-        end
-
-        it "allows explicit stubs using expect syntax" do
-          allow(null_object).to receive(:foo) { "bar" }
-          expect(null_object.foo).to eq("bar")
-        end
-
-        it "allows explicit stubs using should syntax" do
-          null_object.stub(:foo) { "bar" }
-          expect(null_object.foo).to eq("bar")
-        end
-
-        it "allows explicit expectations" do
-          expect(null_object).to receive(:something)
-          null_object.something
-        end
-
-        it "supports Array#flatten" do
-          expect([null_object].flatten).to eq([null_object])
-        end
-      end
-      """
-    When I run `rspec as_null_object_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/receive_message_chain.feature

@@ -1,51 +0,0 @@
-Feature: stub a chain of methods
-
-  Use the `stub_chain` method to stub a chain of two or more methods in one
-  statement.  Method chains are considered a design smell, but it's not really
-  the method chain itself that is the problem - it's the dependency chain
-  represented by a chain of messages to different objects:
-
-      foo.get_bar.get_baz
-
-  This is a Law of Demeter violation if `get_bar` returns an object other than
-  `foo`, and `get_baz` returns yet another object.
-
-  Fluent interfaces look similar from a caller's perspective, but don't
-  represent a dependency chain (the caller depends only on the object it is
-  calling). Consider this common example from Ruby on Rails:
-
-      Article.recent.by(current_user)
-
-  The `recent` and `by` methods return the same object, so this is not a Law of
-  Demeter violation.
-
-  Scenario: stub a chain of methods
-    Given a file named "stub_chain_spec.rb" with:
-      """ruby
-      describe "stubbing a chain of methods" do
-        subject { Object.new }
-
-        context "given symbols representing methods" do
-          it "returns the correct value" do
-            allow(subject).to receive_message_chain(:one, :two, :three).and_return(:four)
-            expect(subject.one.two.three).to eq(:four)
-          end
-        end
-
-        context "given a hash at the end" do
-          it "returns the correct value" do
-            allow(subject).to receive_message_chain(:one, :two, :three => :four)
-            expect(subject.one.two.three).to eq(:four)
-          end
-        end
-
-        context "given a string of methods separated by dots" do
-          it "returns the correct value" do
-            allow(subject).to receive_message_chain("one.two.three").and_return(:four)
-            expect(subject.one.two.three).to eq(:four)
-          end
-        end
-      end
-      """
-    When I run `rspec stub_chain_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/simple_return_value_with_allow.feature

@@ -1,44 +0,0 @@
-Feature: allow with a simple return value
-
-  Use the `allow` method with the `receive` matcher on a test double or a real
-  object to tell the object to return a value (or values) in response to a given
-  message. Nothing happens if the message is never received.
-
-  Scenario: stub with no return value
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a stub with no return value specified" do
-        let(:collaborator) { double("collaborator") }
-
-        it "returns nil" do
-          allow(collaborator).to receive(:message)
-          expect(collaborator.message).to be(nil)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: stubs with return values
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a stub with a return value" do
-        context "specified in a block" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            allow(collaborator).to receive(:message) { :value }
-            expect(collaborator.message).to eq(:value)
-          end
-        end
-
-        context "specified with #and_return" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            allow(collaborator).to receive(:message).and_return(:value)
-            expect(collaborator.message).to eq(:value)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass

data/features/method_stubs/simple_return_value_with_stub.feature

@@ -1,64 +0,0 @@
-Feature: stub with a simple return value
-
-  Use the `stub` method on a test double or a real object to tell the object to
-  return a value (or values) in response to a given message. Nothing happens if
-  the message is never received.
-
-  Scenario: stub with no return value
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a stub with no return value specified" do
-        let(:collaborator) { double("collaborator") }
-
-        it "returns nil" do
-          collaborator.stub(:message)
-          expect(collaborator.message).to be(nil)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass
-
-  Scenario: stubs with return values
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a stub with a return value" do
-        context "specified in a block" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message) { :value }
-            expect(collaborator.message).to eq(:value)
-          end
-        end
-
-        context "specified with #and_return" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message).and_return(:value)
-            expect(collaborator.message).to eq(:value)
-          end
-        end
-
-        context "specified with a hash passed to #stub" do
-          it "returns the specified value" do
-            collaborator = double("collaborator")
-            collaborator.stub(:message_1 => :value_1, :message_2 => :value_2)
-            expect(collaborator.message_1).to eq(:value_1)
-            expect(collaborator.message_2).to eq(:value_2)
-          end
-        end
-
-        context "specified with a hash passed to #double" do
-          it "returns the specified value" do
-            collaborator = double("collaborator",
-              :message_1 => :value_1,
-              :message_2 => :value_2
-            )
-            expect(collaborator.message_1).to eq(:value_1)
-            expect(collaborator.message_2).to eq(:value_2)
-          end
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the examples should all pass