rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data/features/message_expectations/call_original.feature

@@ -21,4 +21,3 @@ Feature: Calling the original method
       """
     When I run `rspec call_original_spec.rb`
     Then the examples should all pass
-

data/features/message_expectations/message_chains_using_expect.feature

@@ -0,0 +1,49 @@
+Feature: Message chains in the expect syntax
+
+  You can use `receive_message_chain` to stub nested calls
+  on both partial and pure mock objects.
+
+  Scenario: allow a chained message
+    Given a file named "spec/chained_messages.rb" with:
+      """ruby
+      describe "a chained message expectation" do
+        it "passes if the expected number of calls happen" do
+          d = double
+          allow(d).to receive_message_chain(:to_a, :length)
+
+          d.to_a.length
+        end
+      end
+      """
+    When I run `rspec spec/chained_messages.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: allow a chained message with a return value
+    Given a file named "spec/chained_messages.rb" with:
+      """ruby
+      describe "a chained message expectation" do
+        it "passes if the expected number of calls happen" do
+          d = double
+          allow(d).to receive_message_chain(:to_a, :length).and_return(3)
+
+          expect(d.to_a.length).to eq(3)
+        end
+      end
+      """
+    When I run `rspec spec/chained_messages.rb`
+    Then the output should contain "1 example, 0 failures"
+
+  Scenario: expect a chained message with a return value
+    Given a file named "spec/chained_messages.rb" with:
+      """ruby
+      describe "a chained message expectation" do
+        it "passes if the expected number of calls happen" do
+          d = double
+          expect(d).to receive_message_chain(:to_a, :length).and_return(3)
+
+          expect(d.to_a.length).to eq(3)
+        end
+      end
+      """
+    When I run `rspec spec/chained_messages.rb`
+    Then the output should contain "1 example, 0 failures"

data/features/method_stubs/README.md

@@ -20,7 +20,7 @@ block contents are evaluated lazily when the `obj` receives the
 
     allow(obj).to receive(:message) do |arg1, arg2|
       # set expectations about the args in this block
-      # and/or return  value
+      # and/or return value
     end
 
     obj.stub(:message) do |arg1, arg2|
@@ -49,6 +49,7 @@ You can also use the block format:
 #### 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') { ... }

data/features/method_stubs/{any_instance.feature → allow_any_instance_of.feature}

@@ -1,6 +1,6 @@
 Feature: stub on any instance of a class
 
-  Use `any_instance.stub` on a class to tell any instance of that class to
+  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.
 
@@ -10,12 +10,12 @@ Feature: stub on any instance of a class
   to the object that receives a message in your test. For more information,
   see the message_expectations/allow_any_instance_of feature.
 
-  Scenario: any_instance stub with a single return value
+  Scenario: Stubbing any instance of an object with a single return value
     Given a file named "example_spec.rb" with:
       """ruby
-      describe "any_instance.stub" do
+      describe "stubbing any instance" do
         it "returns the specified value on any instance of the class" do
-          Object.any_instance.stub(:foo).and_return(:return_value)
+          allow_any_instance_of(Object).to receive(:foo).and_return(:return_value)
 
           o = Object.new
           expect(o.foo).to eq(:return_value)
@@ -31,7 +31,7 @@ Feature: stub on any instance of a class
       describe "any_instance.stub" do
         context "with a hash" do
           it "returns the hash values on any instance of the class" do
-            Object.any_instance.stub(:foo => 'foo', :bar => 'bar')
+            allow_any_instance_of(Object).to receive_messages(:foo => 'foo', :bar => 'bar')
 
             o = Object.new
             expect(o.foo).to eq('foo')
@@ -43,14 +43,14 @@ Feature: stub on any instance of a class
     When I run `rspec example_spec.rb`
     Then the examples should all pass
 
-  Scenario: any_instance stub with specific arguments matchers
+  Scenario: Stubbing any instance of an object with specific arguments matchers
     Given a file named "example_spec.rb" with:
       """ruby
-      describe "any_instance.stub" do
+      describe "stubbing any instance" do
         context "with arguments" do
           it "returns the stubbed value when arguments match" do
-            Object.any_instance.stub(:foo).with(:param_one, :param_two).and_return(:result_one)
-            Object.any_instance.stub(:foo).with(:param_three, :param_four).and_return(:result_two)
+            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)
@@ -112,21 +112,21 @@ Feature: stub on any instance of a class
       describe "stubbing a chain of methods" do
         context "given symbols representing methods" do
           it "returns the correct value" do
-            Object.any_instance.stub_chain(:one, :two, :three).and_return(:four)
+            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
-            Object.any_instance.stub_chain(:one, :two, :three => :four)
+            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
-            Object.any_instance.stub_chain("one.two.three").and_return(:four)
+            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

data/features/method_stubs/{stub_chain.feature → receive_message_chain.feature}

@@ -27,21 +27,21 @@ Feature: stub a chain of methods
 
         context "given symbols representing methods" do
           it "returns the correct value" do
-            subject.stub_chain(:one, :two, :three).and_return(:four)
+            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
-            subject.stub_chain(:one, :two, :three => :four)
+            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
-            subject.stub_chain("one.two.three").and_return(:four)
+            allow(subject).to receive_message_chain("one.two.three").and_return(:four)
             expect(subject.one.two.three).to eq(:four)
           end
         end

data/features/method_stubs/to_ary.feature

@@ -18,7 +18,7 @@ Feature: double handling to_ary
       describe "#to_ary" do
         shared_examples "to_ary" do
           it "can be overridden with a stub" do
-            obj.stub(:to_ary) { :non_nil_value }
+            allow(obj).to receive(:to_ary) { :non_nil_value }
             expect(obj.to_ary).to be(:non_nil_value)
           end
 

data/features/mutating_constants/stub_defined_constant.feature

@@ -76,4 +76,3 @@ Feature: Stub Defined Constant
       """
     When I run `rspec stub_const_spec.rb`
     Then the examples should all pass
-

data/features/outside_rspec/standalone.feature

@@ -10,7 +10,7 @@ Feature: standalone
       require "rspec/mocks/standalone"
 
       greeter = double("greeter")
-      greeter.stub(:say_hi) { "Hello!" }
+      allow(greeter).to receive(:say_hi) { "Hello!" }
       puts greeter.say_hi
       """
     When I run `ruby example.rb`

data/features/spies/spy_pure_mock_method.feature

@@ -66,7 +66,7 @@ Feature: Spy on a stubbed method on a pure mock
     Given a file named "spy_message_spec.rb" with:
       """ruby
       describe "have_received" do
-      subject(:invitation) { double('invitation', :deliver => true) }
+        subject(:invitation) { double('invitation', :deliver => true) }
         before { invitation.deliver }
 
         it { should have_received(:deliver) }

data/features/test_frameworks/test_unit.feature

@@ -13,31 +13,42 @@ Feature: Test::Unit integration
       require 'rspec/mocks'
 
       class RSpecMocksTest < Test::Unit::TestCase
+        include RSpec::Mocks::ExampleMethods
+
         def setup
-          RSpec::Mocks.setup(Object)
-          RSpec::Mocks.setup(self)
+          RSpec::Mocks.setup
+        end
+
+        def teardown
+          RSpec::Mocks.verify
+        ensure
+          RSpec::Mocks.teardown
         end
 
-        def test_passing_expectation
+        def test_passing_positive_expectation
           obj = Object.new
           expect(obj).to receive(:message)
           obj.message
         end
 
-        def test_failing_expectation
+        def test_failing_positive_expectation
           obj = Object.new
-          expect(obj).to_not receive(:message)
+          expect(obj).to receive(:message)
           obj.message
         end
 
-        def test_with_deprecation_warning
+        def test_passing_negative_expectation
           obj = Object.new
-          obj.stub(:old_message) { RSpec.deprecate(:old_message, :replacement => :message) }
-          obj.old_message
+          expect(obj).to_not receive(:message)
+        end
+
+        def test_failing_negative_expectation
+          obj = Object.new
+          expect(obj).to_not receive(:message)
+          obj.message
         end
       end
       """
      When I run `ruby rspec_mocks_test.rb`
-     Then the output should contain "3 tests, 0 assertions, 0 failures, 1 errors" or "3 tests, 0 assertions, 1 failures, 0 errors"
+     Then the output should contain "4 tests, 0 assertions, 0 failures, 1 errors" or "4 tests, 0 assertions, 1 failures, 0 errors"
      And the output should contain "expected: 0 times with any arguments"
-     And the output should contain "old_message is deprecated"

data/features/verifying_doubles/README.md

@@ -0,0 +1,17 @@
+## Verifying Doubles
+
+Verifying doubles are a stricter alternative to normal doubles that provide
+guarantees about what is being verified. When using verifying doubles, RSpec
+will check that the methods being stubbed are actually present on the
+underlying object if it is available. Prefer using veryifing doubles over
+normal doubles.
+
+No checking will happen if the underlying object or class is not defined, but
+when run with it present (either as a full spec run or by explicitly preloading
+collaborators) a failure will be triggered if an invalid method is being
+stubbed or a method is called with an invalid number of arguments.
+
+This dual approach allows you to move very quickly and test components in
+isolation, while giving you confidence that your doubles are not a complete
+fiction. Testing in isolation is optional but recommend for classes that do not
+depend on third-party components.

data/features/verifying_doubles/class_doubles.feature

@@ -1,7 +1,7 @@
 Feature: Using a class double
 
   `class_double` is provided as a complement to `instance_double`, with the
-  difference that it verifies class methods on the given class rather than
+  difference that it verifies _class_ methods on the given class rather than
   instance methods.
 
   In addition, it also provides a convenience method `as_stubbed_const` to
@@ -71,18 +71,3 @@ Feature: Using a class double
     When I run `rspec spec/user_spec.rb`
     Then the output should contain "1 example, 1 failure"
     And the output should contain "ConsoleNotifier does not implement:"
-
-  Scenario: adding `color` as a second argument to `ConsoleNotifier.notify`
-    Given a file named "lib/console_notifier.rb" with:
-      """ruby
-      class ConsoleNotifier
-        MAX_WIDTH = 80
-
-        def self.notify(message, color)
-          puts color + message
-        end
-      end
-      """
-    When I run `rspec spec/user_spec.rb`
-    Then the output should contain "1 example, 1 failure"
-     And the output should contain "Wrong number of arguments."

data/features/verifying_doubles/dynamic_classes.feature

@@ -69,4 +69,3 @@ Feature: Dynamic classes
 
     When I run `rspec spec/user_spec.rb`
     Then the examples should all pass
-

data/features/verifying_doubles/{introduction.feature → instance_doubles.feature}

@@ -1,20 +1,13 @@
-Feature: Verifying doubles
+Feature: Using an instance double
 
-  Verifying doubles are a stricter alternative to normal doubles that provide
-  guarantees about what is being verified.  When using verifying doubles, RSpec
-  will check that the methods being stubbed are actually present on the
-  underlying object if it is available. Prefer using veryifing doubles over
-  normal doubles.
+  An `instance_double` is the most common type of verifying double. It takes a
+  class name or object as its first argument, then verifies that any methods
+  being stubbed would be present on an _instance_ of that class. If any
+  argument matchers are specified, it also verifies that the number of
+  arguments is correct.
 
-  No checking will happen if the constant name is not defined, but when run
-  with the constant present (either as a full spec run or by explicitly
-  preloading collaborators) a failure will be triggered if an invalid method is
-  being stubbed.
-
-  This dual approach allows you to move very quickly and test components in
-  isolation, while giving you confidence that your doubles are not a complete
-  fiction. Testing in isolation is optional but recommend for classes that do
-  not depend on third-party components.
+  For methods handled by `method_missing`, see [dynamic
+  objects](./dynamic-objects).
 
   Background:
     Given a file named "app/models/user.rb" with:
@@ -26,13 +19,6 @@ Feature: Verifying doubles
       end
       """
 
-    Given a file named "app/models/console_notifier.rb" with:
-      """ruby
-      class ConsoleNotifier
-        # notify is not defined yet.
-      end
-      """
-
     Given a file named "spec/unit_helper.rb" with:
       """ruby
       $LOAD_PATH.unshift("app/models")
@@ -80,6 +66,38 @@ Feature: Verifying doubles
     When I run `rspec spec/unit/user_spec.rb`
     Then the examples should all pass
 
-  Scenario: spec fails with dependencies loaded
+  Scenario: spec passes with dependencies loaded and method implemented
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        def notify(msg)
+          puts message
+        end
+      end
+      """
+
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the examples should all pass
+
+  Scenario: spec fails with dependencies loaded and method unimplemented
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+      end
+      """
+    When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
+    Then the output should contain "1 example, 1 failure"
+    And the output should contain "ConsoleNotifier does not implement:"
+
+  Scenario: spec fails with dependencies loaded and incorrect arity
+    Given a file named "app/models/console_notifier.rb" with:
+      """ruby
+      class ConsoleNotifier
+        def notify(msg, color)
+          puts color + message
+        end
+      end
+      """
     When I run `rspec -r./spec/spec_helper spec/unit/user_spec.rb`
     Then the output should contain "1 example, 1 failure"
+    And the output should contain "Wrong number of arguments."

data/features/verifying_doubles/partial_doubles.feature

@@ -1,7 +1,7 @@
 Feature: Partial doubles
 
-  When the `verify_partial_doubles` configuration option is set, the same arity
-  and method existince checks that are performed for `object_double` are also
+  When the `verify_partial_doubles` configuration option is set, the same argument
+  and method existence checks that are performed for `object_double` are also
   performed on partial doubles. You should set this unless you have a good
   reason not to. It defaults to off only for backwards compatibility.
 

data/lib/rspec/mocks.rb

@@ -1,100 +1,87 @@
 require 'rspec/mocks/framework'
 require 'rspec/mocks/version'
+require 'rspec/support'
 
 module RSpec
-
+  # Contains top-level utility methods. While this contains a few
+  # public methods, these are not generally meant to be called from
+  # a test or example. They exist primarily for integration with
+  # test frameworks (such as rspec-core).
   module Mocks
-    class << self
-      attr_accessor :space
-
-      def setup(host)
-        (class << host; self; end).class_exec do
-          include RSpec::Mocks::ExampleMethods
-        end
-        self.space ||= RSpec::Mocks::Space.new
-      end
-
-      def verify
-        space.verify_all
-      end
-
-      def teardown
-        space.reset_all
-      end
-
-      def proxy_for(object)
-        space.proxy_for(object)
-      end
+    # Performs per-test/example setup. This should be called before
+    # an test or example begins.
+    def self.setup
+      @space_stack << (@space = space.new_scope)
+    end
 
-      def proxies_of(klass)
-        space.proxies_of(klass)
-      end
+    # Verifies any message expectations that were set during the
+    # test or example. This should be called at the end of an example.
+    def self.verify
+      space.verify_all
+    end
 
-      def any_instance_recorder_for(klass)
-        space.any_instance_recorder_for(klass)
-      end
+    # Cleans up all test double state (including any methods that were
+    # redefined on partial doubles). This _must_ be called after
+    # each example, even if an error was raised during the example.
+    def self.teardown
+      space.reset_all
+      @space_stack.pop
+      @space = @space_stack.last || @root_space
+    end
 
-      # Adds an allowance (stub) on `subject`
-      #
-      # @param subject the subject to which the message will be added
-      # @param message a symbol, representing the message that will be
-      #                added.
-      # @param opts a hash of options, :expected_from is used to set the
-      #             original call site
-      # @param block an optional implementation for the allowance
-      #
-      # @example Defines the implementation of `foo` on `bar`, using the passed block
-      #   x = 0
-      #   RSpec::Mocks.allow_message(bar, :foo) { x += 1 }
-      def allow_message(subject, message, opts={}, &block)
-        orig_caller = opts.fetch(:expected_from) {
-          CallerFilter.first_non_rspec_line
-        }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_stub(orig_caller, message, opts, &block)
-      end
+    # Adds an allowance (stub) on `subject`
+    #
+    # @param subject the subject to which the message will be added
+    # @param message a symbol, representing the message that will be
+    #                added.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @param block an optional implementation for the allowance
+    #
+    # @example Defines the implementation of `foo` on `bar`, using the passed block
+    #   x = 0
+    #   RSpec::Mocks.allow_message(bar, :foo) { x += 1 }
+    def self.allow_message(subject, message, opts={}, &block)
+      orig_caller = opts.fetch(:expected_from) {
+        CallerFilter.first_non_rspec_line
+      }
+      space.proxy_for(subject).add_stub(orig_caller, message, opts, &block)
+    end
 
-      # Sets a message expectation on `subject`.
-      # @param subject the subject on which the message will be expected
-      # @param message a symbol, representing the message that will be
-      #                expected.
-      # @param opts a hash of options, :expected_from is used to set the
-      #             original call site
-      # @param block an optional implementation for the expectation
-      #
-      # @example Expect the message `foo` to receive `bar`, then call it
-      #   RSpec::Mocks.expect_message(bar, :foo)
-      #   bar.foo
-      def expect_message(subject, message, opts={}, &block)
-        orig_caller = opts.fetch(:expected_from) {
-          CallerFilter.first_non_rspec_line
-        }
-        ::RSpec::Mocks.proxy_for(subject).
-          add_message_expectation(orig_caller, message, opts, &block)
-      end
+    # Sets a message expectation on `subject`.
+    # @param subject the subject on which the message will be expected
+    # @param message a symbol, representing the message that will be
+    #                expected.
+    # @param opts a hash of options, :expected_from is used to set the
+    #             original call site
+    # @param block an optional implementation for the expectation
+    #
+    # @example Expect the message `foo` to receive `bar`, then call it
+    #   RSpec::Mocks.expect_message(bar, :foo)
+    #   bar.foo
+    def self.expect_message(subject, message, opts={}, &block)
+      orig_caller = opts.fetch(:expected_from) {
+        CallerFilter.first_non_rspec_line
+      }
+      space.proxy_for(subject).add_message_expectation(orig_caller, message, opts, &block)
+    end
 
-      # @api private
-      KERNEL_METHOD_METHOD = ::Kernel.instance_method(:method)
+    def self.with_temporary_scope
+      setup
 
-      # @api private
-      # Used internally to get a method handle for a particular object
-      # and method name.
-      #
-      # Includes handling for a few special cases:
-      #
-      #   - Objects that redefine #method (e.g. an HTTPRequest struct)
-      #   - BasicObject subclasses that mixin a Kernel dup (e.g. SimpleDelegator)
-      def method_handle_for(object, method_name)
-        if ::Kernel === object
-          KERNEL_METHOD_METHOD.bind(object).call(method_name)
-        else
-          object.method(method_name)
-        end
+      begin
+        yield
+        verify
+      ensure
+        teardown
       end
     end
 
+    class << self; attr_reader :space; end
+    @space_stack = []
+    @root_space  = @space = RSpec::Mocks::RootSpace.new
+
     # @private
     IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
   end
 end
-