rspec-mocks 2.13.1 → 2.14.0.rc1

data/features/method_stubs/as_null_object.feature

@@ -6,7 +6,7 @@ Feature: as_null_object
   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 
+  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

data/features/method_stubs/stub_implementation.feature

@@ -2,7 +2,7 @@ Feature: stub with substitute implementation
 
   You can stub an implementation of a method (a.k.a. fake) by passing a block
   to the `stub` method.
-  
+
   Scenario: stub implementation
     Given a file named "stub_implementation_spec.rb" with:
       """ruby
@@ -16,7 +16,7 @@ Feature: stub with substitute implementation
               "got that"
             end
           end
-          
+
           object.foo(:this).should eq("got this")
           object.foo(:that).should eq("got that")
         end

data/features/outside_rspec/configuration.feature

@@ -15,10 +15,6 @@ Feature: configure any test framework to use rspec-mocks
       should_receive
       should_not_receive
       stub
-      
-  In order to give control to the consuming framework, none of these facilities
-  are added until RSpec::Mocks::setup(self) is called. Simply requiring
-  'rspec/mocks' is not sufficient. 
 
   NOTICE: the stub() method that is added to the object passed to setup is not
   the same stub() method that is added to every other object.
@@ -64,19 +60,3 @@ Feature: configure any test framework to use rspec-mocks
     Then the output should contain "true"
     But  the output should not contain "false"
 
-  Scenario: require "rspec/mocks" does not add methods to Object
-    Given a file named "foo.rb" with:
-      """ruby
-      require 'rspec/mocks'
-
-      obj = Object.new
-
-      puts obj.respond_to?(:should_receive)
-      puts obj.respond_to?(:should_not_receive)
-      puts obj.respond_to?(:stub)
-      """
-
-    When I run `ruby foo.rb`
-    Then the output should contain "false"
-    But  the output should not contain "true"
-

data/features/spies/spy_partial_mock_method.feature

@@ -0,0 +1,34 @@
+Feature: Spy on a stubbed method on a partial mock
+
+  You can also use `have_received` to verify that a stubbed method was invoked
+  on a partial mock.
+
+  Scenario: verify a stubbed method
+    Given a file named "verified_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = Object.new
+          invitation.stub(:deliver => true)
+          invitation.deliver
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec verified_spy_spec.rb`
+    Then the examples should all pass
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the expectation is not met" do
+          invitation = Object.new
+          invitation.stub(:deliver => true)
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "expected: 1 time"
+     And the output should contain "received: 0 times"

data/features/spies/spy_pure_mock_method.feature

@@ -0,0 +1,76 @@
+Feature: Spy on a stubbed method on a pure mock
+
+  You can use `have_received` to verify that a stubbed method was invoked,
+  rather than setting an expectation for it to be invoked beforehand.
+
+  Scenario: verify a stubbed method
+    Given a file named "verified_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = double('invitation', :deliver => true)
+          invitation.deliver
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec verified_spy_spec.rb`
+    Then the examples should all pass
+
+  Scenario: verify a stubbed method with message expectations
+    Given a file named "verified_message_expectations_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "passes when the expectation is met" do
+          invitation = double('invitation', :deliver => true)
+          2.times { invitation.deliver(:expected, :arguments) }
+          invitation.should have_received(:deliver).
+            with(:expected, :arguments).
+            twice
+        end
+      end
+      """
+    When I run `rspec verified_message_expectations_spec.rb`
+    Then the examples should all pass
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the expectation is not met" do
+          invitation = double('invitation', :deliver => true)
+          invitation.should have_received(:deliver)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "expected: 1 time"
+     And the output should contain "received: 0 times"
+
+  Scenario: fail to verify message expectations
+    Given a file named "failed_message_expectations_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "fails when the arguments are different" do
+          invitation = double('invitation', :deliver => true)
+          invitation.deliver(:unexpected)
+          invitation.should have_received(:deliver).with(:expected, :arguments)
+        end
+      end
+      """
+    When I run `rspec failed_message_expectations_spec.rb`
+    Then the output should contain "expected: (:expected, :arguments)"
+    And the output should contain "got: (:unexpected)"
+
+  Scenario: generate a spy message
+    Given a file named "spy_message_spec.rb" with:
+      """ruby
+      describe "have_received" do
+      subject(:invitation) { double('invitation', :deliver => true) }
+        before { invitation.deliver }
+
+        it { should have_received(:deliver) }
+      end
+      """
+    When I run `rspec --format documentation spy_message_spec.rb`
+    Then the output should contain "should have received deliver"

data/features/spies/spy_unstubbed_method.feature

@@ -0,0 +1,18 @@
+Feature: Spy on an unstubbed method
+
+  Using have_received on an unstubbed method will never pass, so rspec-mocks
+  issues a helpful error message.
+
+  Scenario: fail to verify a stubbed method
+    Given a file named "failed_spy_spec.rb" with:
+      """ruby
+      describe "have_received" do
+        it "raises a helpful error for unstubbed methods" do
+          object = Object.new
+          object.object_id
+          object.should have_received(:object_id)
+        end
+      end
+      """
+    When I run `rspec failed_spy_spec.rb`
+    Then the output should contain "that method has not been stubbed"

data/features/step_definitions/additional_cli_steps.rb

@@ -2,3 +2,10 @@ Then /^the example(?:s)? should(?: all)? pass$/ do
   step %q{the output should contain "0 failures"}
   step %q{the exit status should be 0}
 end
+
+# Useful for when the output is slightly different on different versions of ruby
+Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
+  unless [string1, string2].any? { |s| all_output =~ regexp(s) }
+    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{all_output}}
+  end
+end

data/features/test_frameworks/test_unit.feature

@@ -0,0 +1,43 @@
+Feature: Test::Unit integration
+
+  rspec-mocks is a stand-alone gem that can be used without the rest of
+  RSpec. If you like the way Test::Unit (or MiniTest) organizes tests, but
+  prefer RSpec's approach to mocking/stubbing/doubles etc, you can have both.
+
+  The one downside is that failures are reported as errors with MiniTest.
+
+  Scenario: use rspec/mocks with Test::Unit
+    Given a file named "rspec_mocks_test.rb" with:
+      """ruby
+      require 'test/unit'
+      require 'rspec/mocks'
+
+      class RSpecMocksTest < Test::Unit::TestCase
+        def setup
+          RSpec::Mocks.setup(Object)
+          RSpec::Mocks.setup(self)
+        end
+
+        def test_passing_expectation
+          obj = Object.new
+          expect(obj).to receive(:message)
+          obj.message
+        end
+
+        def test_failing_expectation
+          obj = Object.new
+          expect(obj).to_not receive(:message)
+          obj.message
+        end
+
+        def test_with_deprecation_warning
+          obj = Object.new
+          obj.stub(:old_message) { RSpec.deprecate(:old_message, :replacement => :message) }
+          obj.old_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"
+     And the output should contain "expected: 0 times with any arguments"
+     And the output should contain "old_message is deprecated. Use message instead."

data/lib/rspec/mocks.rb

@@ -1,14 +1,13 @@
 require 'rspec/mocks/framework'
 require 'rspec/mocks/version'
-require 'rspec/mocks/example_methods'
 
 module RSpec
+
   module Mocks
     class << self
       attr_accessor :space
 
       def setup(host)
-        add_extensions unless extensions_added?
         (class << host; self; end).class_eval do
           include RSpec::Mocks::ExampleMethods
         end
@@ -23,16 +22,12 @@ module RSpec
         space.reset_all
       end
 
-      def configuration
-        @configuration ||= Configuration.new
+      def proxy_for(object)
+        space.proxy_for(object)
       end
 
-      # @api private
-      # Used internally by RSpec to display custom deprecation warnings.  This
-      # is also defined in rspec-core, but we can't assume it's loaded since
-      # rspec-expectations should be usable w/o rspec-core.
-      def warn_deprecation(message)
-        warn(message)
+      def any_instance_recorder_for(klass)
+        space.any_instance_recorder_for(klass)
       end
 
       # @api private
@@ -53,30 +48,10 @@ module RSpec
           object.method(method_name)
         end
       end
-
-    private
-
-      def add_extensions
-        method_host.class_eval { include RSpec::Mocks::Methods }
-        Class.class_eval  { include RSpec::Mocks::AnyInstance }
-        $_rspec_mocks_extensions_added = true
-      end
-
-      def extensions_added?
-        defined?($_rspec_mocks_extensions_added)
-      end
-
-      def method_host
-        # On 1.8.7, Object.ancestors.last == Kernel but
-        # things blow up if we include `RSpec::Mocks::Methods`
-        # into Kernel...not sure why.
-        return Object unless defined?(::BasicObject)
-
-        # MacRuby has BasicObject but it's not the root class.
-        return Object unless Object.ancestors.last == ::BasicObject
-
-        ::BasicObject
-      end
     end
+
+    # @private
+    IGNORED_BACKTRACE_LINE = 'this backtrace line is ignored'
   end
 end
+

data/lib/rspec/mocks/any_instance/chain.rb

@@ -2,6 +2,11 @@ module RSpec
   module Mocks
     module AnyInstance
       class Chain
+        def initialize(*args, &block)
+          @expectation_args  = args
+          @expectation_block = block
+        end
+
         class << self
           private
 
@@ -38,8 +43,9 @@ module RSpec
 
         # @private
         def playback!(instance)
-          messages.inject(instance) do |_instance, message|
-            _instance.__send__(*message.first, &message.last)
+          message_expectation = create_message_expectation_on(instance)
+          messages.inject(message_expectation) do |object, message|
+            object.__send__(*message.first, &message.last)
           end
         end
 

data/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -8,8 +8,8 @@ module RSpec
         end
 
         def initialize(*args, &block)
-          record(*args, &block)
           @expectation_fulfilled = false
+          super
         end
 
         private
@@ -19,28 +19,26 @@ module RSpec
 
       # @api private
       class PositiveExpectationChain < ExpectationChain
-        def initialize(*args, &block)
-          super(:should_receive, *args, &block)
-        end
 
         private
 
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
+        end
+
         def invocation_order
           @invocation_order ||= {
-            :should_receive => [nil],
-            :with => [:should_receive],
-            :and_return => [:with, :should_receive],
-            :and_raise => [:with, :should_receive]
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil]
           }
         end
       end
 
       # @api private
       class NegativeExpectationChain < ExpectationChain
-        def initialize(*args, &block)
-          super(:should_not_receive, *args, &block)
-        end
-
         # `should_not_receive` causes a failure at the point in time the
         # message is wrongly received, rather than during `rspec_verify`
         # at the end of an example. Thus, we should always consider a
@@ -52,12 +50,17 @@ module RSpec
 
         private
 
+        def create_message_expectation_on(instance)
+          proxy = ::RSpec::Mocks.proxy_for(instance)
+          expected_from = IGNORED_BACKTRACE_LINE
+          proxy.add_negative_message_expectation(expected_from, *@expectation_args, &@expectation_block)
+        end
+
         def invocation_order
           @invocation_order ||= {
-            :should_not_receive => [nil],
-            :with => [:should_receive],
-            :and_return => [:with, :should_receive],
-            :and_raise => [:with, :should_receive]
+            :with => [nil],
+            :and_return => [:with, nil],
+            :and_raise => [:with, nil]
           }
         end
       end

data/lib/rspec/mocks/any_instance/recorder.rb

@@ -84,6 +84,9 @@ module RSpec
           if @expectation_set && !message_chains.all_expectations_fulfilled?
             raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
           end
+        ensure
+          stop_all_observation!
+          ::RSpec::Mocks.space.remove_any_instance_recorder_for(@klass)
         end
 
         # @private
@@ -103,7 +106,7 @@ module RSpec
 
         # @private
         def playback!(instance, method_name)
-          RSpec::Mocks::space.add(instance)
+          RSpec::Mocks.space.ensure_registered(instance)
           message_chains.playback!(instance, method_name)
           @played_methods[method_name] = instance
           received_expected_message!(method_name) if message_chains.has_expectation?(method_name)
@@ -181,7 +184,7 @@ module RSpec
           @klass.class_eval(<<-EOM, __FILE__, __LINE__ + 1)
             def #{method_name}(*args, &blk)
               klass = ::RSpec::Mocks.method_handle_for(self, :#{method_name}).owner
-              klass.__recorder.playback!(self, :#{method_name})
+              ::RSpec::Mocks.any_instance_recorder_for(klass).playback!(self, :#{method_name})
               self.__send__(:#{method_name}, *args, &blk)
             end
           EOM
@@ -193,7 +196,7 @@ module RSpec
             def #{method_name}(*args, &blk)
               method_name = :#{method_name}
               klass = ::RSpec::Mocks.method_handle_for(self, :#{method_name}).owner
-              invoked_instance = klass.__recorder.instance_that_received(method_name)
+              invoked_instance = ::RSpec::Mocks.any_instance_recorder_for(klass).instance_that_received(method_name)
               raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by \#{self.inspect} but has already been received by \#{invoked_instance}"
             end
           EOM