mocha 1.8.0 → 1.11.0

data/lib/mocha/api.rb

@@ -3,11 +3,33 @@ require 'mocha/hooks'
 require 'mocha/mockery'
 require 'mocha/sequence'
 require 'mocha/object_methods'
-require 'mocha/module_methods'
 require 'mocha/class_methods'
 
 module Mocha
   # Methods added to +Test::Unit::TestCase+, +MiniTest::Unit::TestCase+ or equivalent.
+  # The mock creation methods are {#mock}, {#stub} and {#stub_everything}, all of which return a #{Mock}
+  # which can be further modified by {Mock#responds_like} and {Mock#responds_like_instance_of} methods,
+  # both of which return a {Mock}, too, and can therefore, be chained to the original creation methods.
+  #
+  # {Mock#responds_like} and {Mock#responds_like_instance_of} force the mock to indicate what it is
+  # supposed to be mocking, thus making it a safer verifying mock. They check that the underlying +responder+
+  # will actually respond to the methods being stubbed, throwing a +NoMethodError+ upon invocation otherwise.
+  #
+  # @example Verifying mock using {Mock#responds_like_instance_of}
+  #   class Sheep
+  #     def initialize
+  #       raise "some awkward code we don't want to call"
+  #     end
+  #     def chew(grass); end
+  #   end
+  #
+  #   sheep = mock('sheep').responds_like_instance_of(Sheep)
+  #   sheep.expects(:chew)
+  #   sheep.expects(:foo)
+  #   sheep.respond_to?(:chew) # => true
+  #   sheep.respond_to?(:foo) # => false
+  #   sheep.chew
+  #   sheep.foo # => raises NoMethodError exception
   module API
     include ParameterMatchers
     include Hooks
@@ -15,22 +37,26 @@ module Mocha
     # @private
     def self.included(_mod)
       Object.send(:include, Mocha::ObjectMethods)
-      Module.send(:include, Mocha::ModuleMethods)
       Class.send(:include, Mocha::ClassMethods)
     end
 
+    # @private
+    def self.extended(mod)
+      included(mod)
+    end
+
     # Builds a new mock object
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
-    # @yield optional block to be evaluated in the context of the mock object instance, giving an alternative way to setup stubbed methods.
-    # @yield note that the block is evaulated by calling Mock#instance_eval and so things like instance variables declared in the test will not be available within the block.
-    # @yield deprecated: use Object#tap or define stubs/expectations with an explicit receiver instead.
     # @return [Mock] a new mock object
     #
-    # @overload def mock(name, &block)
-    # @overload def mock(expected_methods_vs_return_values = {}, &block)
-    # @overload def mock(name, expected_methods_vs_return_values = {}, &block)
+    # @overload def mock(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that expected the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def mock(expected_methods_vs_return_values = {})
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
+    # @overload def mock(name, expected_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
     #
     # @example Using expected_methods_vs_return_values Hash to setup expectations.
     #   def test_motor_starts_and_stops
@@ -39,36 +65,45 @@ module Mocha
     #     assert motor.stop
     #     # an error will be raised unless both Motor#start and Motor#stop have been called
     #   end
-    # @example Using the optional block to setup expectations & stubbed methods [deprecated].
-    #   def test_motor_starts_and_stops
-    #     motor = mock('motor') do
-    #       expects(:start).with(100.rpm).returns(true)
-    #       stubs(:stop).returns(true)
-    #     end
-    #     assert motor.start(100.rpm)
-    #     assert motor.stop
-    #     # an error will only be raised if Motor#start(100.rpm) has not been called
-    #   end
-    def mock(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def mock(*arguments)
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of expected methods vs return values,",
+            " e.g. `mock(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `mock(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of expected methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      mock = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      mock = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       mock.expects(expectations)
       mock
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a new mock object
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
-    # @yield optional block to be evaluated in the context of the mock object instance, giving an alternative way to setup stubbed methods.
-    # @yield note that the block is evaulated by calling Mock#instance_eval and so things like instance variables declared in the test will not be available within the block.
-    # @yield deprecated: use Object#tap or define stubs/expectations with an explicit receiver instead.
     # @return [Mock] a new mock object
     #
-    # @overload def stub(name, &block)
-    # @overload def stub(stubbed_methods_vs_return_values = {}, &block)
-    # @overload def stub(name, stubbed_methods_vs_return_values = {}, &block)
+    # @overload def stub(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def stub(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
     #
     # @example Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
     #   def test_motor_starts_and_stops
@@ -77,37 +112,46 @@ module Mocha
     #     assert motor.stop
     #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
     #   end
-    #
-    # @example Using the optional block to setup expectations & stubbed methods [deprecated].
-    #   def test_motor_starts_and_stops
-    #     motor = stub('motor') do
-    #       expects(:start).with(100.rpm).returns(true)
-    #       stubs(:stop).returns(true)
-    #     end
-    #     assert motor.start(100.rpm)
-    #     assert motor.stop
-    #     # an error will only be raised if Motor#start(100.rpm) has not been called
-    #   end
-    def stub(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def stub(*arguments)
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
+            " e.g. `stub(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `stub(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of stubbed methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stubs(expectations)
       stub
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a mock object that accepts calls to any method. By default it will return +nil+ for any method call.
     #
-    # @param [String] name identifies mock object in error messages.
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
-    # @yield optional block to be evaluated in the context of the mock object instance, giving an alternative way to setup stubbed methods.
-    # @yield note that the block is evaulated by calling Mock#instance_eval and so things like instance variables declared in the test will not be available within the block.
-    # @yield deprecated: use Object#tap or define stubs/expectations with an explicit receiver instead.
     # @return [Mock] a new mock object
     #
-    # @overload def stub_everything(name, &block)
-    # @overload def stub_everything(stubbed_methods_vs_return_values = {}, &block)
-    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {}, &block)
+    # @overload def stub_everything(name)
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
+    # @overload def stub_everything(stubbed_methods_vs_return_values = {})
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
+    # @overload def stub_everything(name, stubbed_methods_vs_return_values = {})
+    #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
     #
     # @example Ignore invocations of irrelevant methods.
     #   def test_motor_stops
@@ -116,14 +160,34 @@ module Mocha
     #     assert_nil motor.irrelevant_method_2 # => no error raised
     #     assert motor.stop
     #   end
-    def stub_everything(*arguments, &block)
-      name = arguments.shift if arguments.first.is_a?(String)
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def stub_everything(*arguments)
+      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+        if arguments.first.is_a?(Symbol)
+          method_name = arguments[0]
+          Deprecation.warning(
+            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
+            " e.g. `stub_everything(:#{method_name} => nil)`."
+          )
+          if arguments[1]
+            Deprecation.warning(
+              "In this case the 2nd argument for `stub_everything(:##{method_name}, ...)` is ignored,",
+              ' but in the future a Hash of stubbed methods vs return values will be respected.'
+            )
+          end
+        elsif arguments.first.is_a?(String)
+          name = arguments.shift
+        end
+      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
+        name = arguments.shift
+      end
       expectations = arguments.shift || {}
-      stub = name ? Mockery.instance.named_mock(name, &block) : Mockery.instance.unnamed_mock(&block)
+      stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stub_everything
       stub.stubs(expectations)
       stub
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a new sequence which can be used to constrain the order in which expectations can occur.
     #

data/lib/mocha/block_matcher.rb

@@ -0,0 +1,31 @@
+module Mocha
+  module BlockMatchers
+    class OptionalBlock
+      def match?(_actual_block)
+        true
+      end
+
+      def mocha_inspect; end
+    end
+
+    class BlockGiven
+      def match?(actual_block)
+        !actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with block given'
+      end
+    end
+
+    class NoBlockGiven
+      def match?(actual_block)
+        actual_block.nil?
+      end
+
+      def mocha_inspect
+        'with no block given'
+      end
+    end
+  end
+end

data/lib/mocha/cardinality.rb

@@ -26,37 +26,43 @@ module Mocha
     def initialize(required, maximum)
       @required = required
       @maximum = maximum
+      @invocations = []
     end
 
-    def invocations_allowed?(invocation_count)
-      invocation_count < maximum
+    def <<(invocation)
+      @invocations << invocation
     end
 
-    def satisfied?(invocations_so_far)
-      invocations_so_far >= required
+    def invocations_allowed?
+      @invocations.size < maximum
+    end
+
+    def satisfied?
+      @invocations.size >= required
     end
 
     def needs_verifying?
       !allowed_any_number_of_times?
     end
 
-    def verified?(invocation_count)
-      (invocation_count >= required) && (invocation_count <= maximum)
+    def verified?
+      (@invocations.size >= required) && (@invocations.size <= maximum)
     end
 
     def allowed_any_number_of_times?
       required.zero? && infinite?(maximum)
     end
 
-    def used?(invocation_count)
-      (invocation_count > 0) || maximum.zero?
+    def used?
+      @invocations.any? || maximum.zero?
     end
 
-    def mocha_inspect
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def anticipated_times
       if allowed_any_number_of_times?
         'allowed any number of times'
       elsif required.zero? && maximum.zero?
-        'expected never'
+        "expected #{times(maximum)}"
       elsif required == maximum
         "expected exactly #{times(required)}"
       elsif infinite?(maximum)
@@ -67,6 +73,15 @@ module Mocha
         "expected between #{required} and #{times(maximum)}"
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+    def invoked_times
+      "invoked #{times(@invocations.size)}"
+    end
+
+    def actual_invocations
+      @invocations.map(&:full_description).join
+    end
 
     protected
 
@@ -74,7 +89,7 @@ module Mocha
 
     def times(number)
       case number
-      when 0 then 'no times'
+      when 0 then 'never'
       when 1 then 'once'
       when 2 then 'twice'
       else "#{number} times"

data/lib/mocha/class_methods.rb

@@ -1,15 +1,9 @@
 require 'mocha/mockery'
-require 'mocha/class_method'
 require 'mocha/any_instance_method'
 
 module Mocha
   # Methods added to all classes to allow mocking and stubbing on real (i.e. non-mock) objects.
   module ClassMethods
-    # @private
-    def stubba_method
-      Mocha::ClassMethod
-    end
-
     # @private
     class AnyInstance
       def initialize(klass)
@@ -28,17 +22,15 @@ module Mocha
         Mocha::AnyInstanceMethod
       end
 
-      attr_reader :stubba_object
+      def stubba_class
+        @stubba_object
+      end
 
-      def method_exists?(method, include_public_methods = true)
-        if include_public_methods
-          return true if @stubba_object.public_instance_methods(true).include?(method)
-          return true if @stubba_object.allocate.respond_to?(method.to_sym)
-        end
-        return true if @stubba_object.protected_instance_methods(true).include?(method)
-        return true if @stubba_object.private_instance_methods(true).include?(method)
-        false
+      def respond_to?(method)
+        @stubba_object.allocate.respond_to?(method.to_sym)
       end
+
+      attr_reader :stubba_object
     end
 
     # @return [Mock] a mock object which will detect calls to any instance of this class.
@@ -56,5 +48,15 @@ module Mocha
       end
       @any_instance ||= AnyInstance.new(self)
     end
+
+    # @private
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def __method_visibility__(method, include_public_methods = true)
+      (include_public_methods && public_method_defined?(method) && :public) ||
+        (protected_method_defined?(method) && :protected) ||
+        (private_method_defined?(method) && :private)
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    alias_method :__method_exists__?, :__method_visibility__
   end
 end

data/lib/mocha/configuration.rb

@@ -1,117 +1,379 @@
 module Mocha
-  # This class allows you to determine what should happen under certain circumstances. In each scenario, Mocha can be configured to {.allow do nothing}, {.warn_when display a warning message}, or {.prevent raise an exception}. The relevant scenario is identified using one of the following symbols:
+  # Allows setting of configuration options. See {Configuration} for the available options.
   #
-  # * +:stubbing_method_unnecessarily+ This is useful for identifying unused stubs. Unused stubs are often accidentally introduced when code is {http://martinfowler.com/bliki/DefinitionOfRefactoring.html refactored}. Allowed by default.
-  # * +:stubbing_non_existent_method+ - This is useful if you want to ensure that methods you're mocking really exist. A common criticism of unit tests with mock objects is that such a test may (incorrectly) pass when an equivalent non-mocking test would (correctly) fail. While you should always have some integration tests, particularly for critical business functionality, this Mocha configuration setting should catch scenarios when mocked methods and real methods have become misaligned. Allowed by default.
-  # * +:stubbing_non_public_method+ - Many people think that it's good practice only to mock public methods. This is one way to prevent your tests being too tightly coupled to the internal implementation of a class. Such tests tend to be very brittle and not much use when refactoring. Allowed by default.
-  # * +:stubbing_method_on_non_mock_object+ - If you like the idea of {http://www.jmock.org/oopsla2004.pdf mocking roles not objects} and {http://www.mockobjects.com/2007/04/test-smell-mocking-concrete-classes.html you don't like stubbing concrete classes}, this is the setting for you. However, while this restriction makes a lot of sense in Java with its {http://java.sun.com/docs/books/tutorial/java/concepts/interface.html explicit interfaces}, it may be moot in Ruby where roles are probably best represented as Modules. Allowed by default.
-  # * +:stubbing_method_on_nil+ - This is usually done accidentally, but there might be rare cases where it is intended. Prevented by default.
+  # Typically the configuration is set globally in a +test_helper.rb+ or +spec_helper.rb+ file.
   #
-  # @example Preventing unnecessary stubbing of a method
-  #   Mocha::Configuration.prevent(:stubbing_method_unnecessarily)
+  # @see Configuration
   #
-  #   example = mock('example')
-  #   example.stubs(:unused_stub)
-  #   # => Mocha::StubbingError: stubbing method unnecessarily:
-  #   # =>   #<Mock:example>.unused_stub(any_parameters)
+  # @yieldparam configuration [Configuration] the configuration for modification
   #
-  # @example Preventing stubbing of a method on a non-mock object
-  #   Mocha::Configuration.prevent(:stubbing_method_on_non_mock_object)
-  #
-  #   class Example
-  #     def example_method; end
-  #   end
-  #
-  #   example = Example.new
-  #   example.stubs(:example_method)
-  #   # => Mocha::StubbingError: stubbing method on non-mock object:
-  #   # =>   #<Example:0x593620>.example_method
-  #
-  # @example Preventing stubbing of a non-existent method
-  #
-  #   Mocha::Configuration.prevent(:stubbing_non_existent_method)
-  #
-  #   class Example
-  #   end
-  #
-  #   example = Example.new
-  #   example.stubs(:method_that_doesnt_exist)
-  #   # => Mocha::StubbingError: stubbing non-existent method:
-  #   # =>   #<Example:0x593760>.method_that_doesnt_exist
-  #
-  # @example Preventing stubbing of a non-public method
-  #   Mocha::Configuration.prevent(:stubbing_non_public_method)
-  #
-  #   class Example
-  #     def internal_method; end
-  #     private :internal_method
+  # @example Setting multiple configuration options
+  #   Mocha.configure do |c|
+  #     c.stubbing_method_unnecessarily = :prevent
+  #     c.stubbing_method_on_non_mock_object = :warn
+  #     c.stubbing_method_on_nil = :allow
   #   end
   #
-  #   example = Example.new
-  #   example.stubs(:internal_method)
-  #   # => Mocha::StubbingError: stubbing non-public method:
-  #   # =>   #<Example:0x593530>.internal_method
-  #
-  # Typically the configuration would be set globally in a +test_helper.rb+ or +spec_helper.rb+ file. However, it can also be temporarily overridden locally using the block syntax of the relevant method. In the latter case, the original configuration settings are restored when the block is exited.
+  def self.configure
+    yield configuration
+  end
+
+  # @private
+  def self.configuration
+    Configuration.configuration
+  end
+
+  # This class provides a number of ways to configure the library.
   #
-  # @example Temporarily allowing stubbing of a non-existent method
-  #   Mocha::Configuration.prevent(:stubbing_non_public_method)
+  # Typically the configuration is set globally in a +test_helper.rb+ or +spec_helper.rb+ file.
   #
-  #   class Example
+  # @example Setting multiple configuration options
+  #   Mocha.configure do |c|
+  #     c.stubbing_method_unnecessarily = :prevent
+  #     c.stubbing_method_on_non_mock_object = :warn
+  #     c.stubbing_method_on_nil = :allow
   #   end
   #
-  #   Mocha::Configuration.allow(:stubbing_non_existent_method) do
-  #     example = Example.new
-  #     example.stubs(:method_that_doesnt_exist)
-  #     # => no exception raised
-  #   end
   class Configuration
+    # @private
     DEFAULTS = {
       :stubbing_method_unnecessarily => :allow,
       :stubbing_method_on_non_mock_object => :allow,
       :stubbing_non_existent_method => :allow,
       :stubbing_non_public_method => :allow,
-      :stubbing_method_on_nil => :prevent
+      :stubbing_method_on_nil => :prevent,
+      :display_matching_invocations_on_failure => false,
+      :reinstate_undocumented_behaviour_from_v1_9 => false
     }.freeze
 
+    attr_reader :options
+    protected :options
+
+    # @private
+    def initialize(options = {})
+      @options = DEFAULTS.merge(options)
+    end
+
+    # @private
+    def initialize_copy(other)
+      @options = other.options.dup
+    end
+
+    # @private
+    def merge(other)
+      self.class.new(@options.merge(other.options))
+    end
+
+    # Configure whether stubbing methods unnecessarily is allowed.
+    #
+    # This is useful for identifying unused stubs. Unused stubs are often accidentally introduced when code is {http://martinfowler.com/bliki/DefinitionOfRefactoring.html refactored}.
+    #
+    # When +value+ is +:allow+, do nothing. This is the default.
+    # When +value+ is +:warn+, display a warning.
+    # When +value+ is +:prevent+, raise a {StubbingError}.
+    #
+    # @param [Symbol] value one of +:allow+, +:warn+, +:prevent+.
+    #
+    # @example Preventing unnecessary stubbing of a method
+    #   Mocha.configure do |c|
+    #     c.stubbing_method_unnecessarily = :prevent
+    #   end
+    #
+    #   example = mock('example')
+    #   example.stubs(:unused_stub)
+    #   # => Mocha::StubbingError: stubbing method unnecessarily:
+    #   # =>   #<Mock:example>.unused_stub(any_parameters)
+    #
+    def stubbing_method_unnecessarily=(value)
+      @options[:stubbing_method_unnecessarily] = value
+    end
+
+    # @private
+    def stubbing_method_unnecessarily
+      @options[:stubbing_method_unnecessarily]
+    end
+
+    # Configure whether stubbing methods on non-mock objects is allowed.
+    #
+    # If you like the idea of {http://www.jmock.org/oopsla2004.pdf mocking roles not objects} and {http://www.mockobjects.com/2007/04/test-smell-mocking-concrete-classes.html you don't like stubbing concrete classes}, this is the setting for you. However, while this restriction makes a lot of sense in Java with its {http://java.sun.com/docs/books/tutorial/java/concepts/interface.html explicit interfaces}, it may be moot in Ruby where roles are probably best represented as Modules.
+    #
+    # When +value+ is +:allow+, do nothing. This is the default.
+    # When +value+ is +:warn+, display a warning.
+    # When +value+ is +:prevent+, raise a {StubbingError}.
+    #
+    # @param [Symbol] value one of +:allow+, +:warn+, +:prevent+.
+    #
+    # @example Preventing stubbing of a method on a non-mock object
+    #   Mocha.configure do |c|
+    #     c.stubbing_method_on_non_mock_object = :prevent
+    #   end
+    #
+    #   class Example
+    #     def example_method; end
+    #   end
+    #
+    #   example = Example.new
+    #   example.stubs(:example_method)
+    #   # => Mocha::StubbingError: stubbing method on non-mock object:
+    #   # =>   #<Example:0x593620>.example_method
+    #
+    def stubbing_method_on_non_mock_object=(value)
+      @options[:stubbing_method_on_non_mock_object] = value
+    end
+
+    # @private
+    def stubbing_method_on_non_mock_object
+      @options[:stubbing_method_on_non_mock_object]
+    end
+
+    # Configure whether stubbing of non-existent methods is allowed.
+    #
+    # This is useful if you want to ensure that methods you're mocking really exist. A common criticism of unit tests with mock objects is that such a test may (incorrectly) pass when an equivalent non-mocking test would (correctly) fail. While you should always have some integration tests, particularly for critical business functionality, this Mocha configuration setting should catch scenarios when mocked methods and real methods have become misaligned.
+    #
+    # When +value+ is +:allow+, do nothing. This is the default.
+    # When +value+ is +:warn+, display a warning.
+    # When +value+ is +:prevent+, raise a {StubbingError}.
+    #
+    # @param [Symbol] value one of +:allow+, +:warn+, +:prevent+.
+    #
+    # @example Preventing stubbing of a non-existent method
+    #
+    #   Mocha.configure do |c|
+    #     c.stubbing_non_existent_method = :prevent
+    #   end
+    #
+    #   class Example
+    #   end
+    #
+    #   example = Example.new
+    #   example.stubs(:method_that_doesnt_exist)
+    #   # => Mocha::StubbingError: stubbing non-existent method:
+    #   # =>   #<Example:0x593760>.method_that_doesnt_exist
+    #
+    def stubbing_non_existent_method=(value)
+      @options[:stubbing_non_existent_method] = value
+    end
+
+    # @private
+    def stubbing_non_existent_method
+      @options[:stubbing_non_existent_method]
+    end
+
+    # Configure whether stubbing of non-public methods is allowed.
+    #
+    # Many people think that it's good practice only to mock public methods. This is one way to prevent your tests being too tightly coupled to the internal implementation of a class. Such tests tend to be very brittle and not much use when refactoring.
+    #
+    # When +value+ is +:allow+, do nothing. This is the default.
+    # When +value+ is +:warn+, display a warning.
+    # When +value+ is +:prevent+, raise a {StubbingError}.
+    #
+    # @param [Symbol] value one of +:allow+, +:warn+, +:prevent+.
+    #
+    # @example Preventing stubbing of a non-public method
+    #   Mocha.configure do |c|
+    #     c.stubbing_non_public_method = :prevent
+    #   end
+    #
+    #   class Example
+    #     def internal_method; end
+    #     private :internal_method
+    #   end
+    #
+    #   example = Example.new
+    #   example.stubs(:internal_method)
+    #   # => Mocha::StubbingError: stubbing non-public method:
+    #   # =>   #<Example:0x593530>.internal_method
+    #
+    def stubbing_non_public_method=(value)
+      @options[:stubbing_non_public_method] = value
+    end
+
+    # @private
+    def stubbing_non_public_method
+      @options[:stubbing_non_public_method]
+    end
+
+    # Configure whether stubbing methods on the +nil+ object is allowed.
+    #
+    # This is usually done accidentally, but there might be rare cases where it is intended.
+    #
+    # This option only works for Ruby < v2.2.0. In later versions of Ruby +nil+ is frozen and so a {StubbingError} will be raised if you attempt to stub a method on +nil+.
+    #
+    # When +value+ is +:allow+, do nothing.
+    # When +value+ is +:warn+, display a warning.
+    # When +value+ is +:prevent+, raise a {StubbingError}. This is the default.
+    #
+    # @param [Symbol] value one of +:allow+, +:warn+, +:prevent+.
+    #
+    def stubbing_method_on_nil=(value)
+      @options[:stubbing_method_on_nil] = value
+    end
+
+    # @private
+    def stubbing_method_on_nil
+      @options[:stubbing_method_on_nil]
+    end
+
+    # Display matching invocations alongside expectations on Mocha-related test failure.
+    #
+    # @param [Boolean] value +true+ to enable display of matching invocations; disabled by default.
+    #
+    # @example Enable display of matching invocations
+    #   Mocha.configure do |c|
+    #     c.display_matching_invocations_on_failure = true
+    #   end
+    #
+    #   foo = mock('foo')
+    #   foo.expects(:bar)
+    #   foo.stubs(:baz).returns('baz').raises(RuntimeError).throws(:tag, 'value')
+    #
+    #   foo.baz(1, 2)
+    #   assert_raises(RuntimeError) { foo.baz(3, 4) }
+    #   assert_throws(:tag) { foo.baz(5, 6) }
+    #
+    #   not all expectations were satisfied
+    #   unsatisfied expectations:
+    #   - expected exactly once, invoked never: #<Mock:foo>.bar
+    #   satisfied expectations:
+    #   - allowed any number of times, invoked 3 times: #<Mock:foo>.baz(any_parameters)
+    #     - #<Mock:foo>.baz(1, 2) # => "baz"
+    #     - #<Mock:foo>.baz(3, 4) # => raised RuntimeError
+    #     - #<Mock:foo>.baz(5, 6) # => threw (:tag, "value")
+    def display_matching_invocations_on_failure=(value)
+      @options[:display_matching_invocations_on_failure] = value
+    end
+
+    # @private
+    def display_matching_invocations_on_failure?
+      @options[:display_matching_invocations_on_failure]
+    end
+
+    # Reinstate undocumented behaviour from v1.9
+    #
+    # Previously when {API#mock}, {API#stub}, or {API#stub_everything} were called with the first argument being a symbol, they built an *unnamed* mock object *and* expected or stubbed the method identified by the symbol argument; subsequent arguments were ignored.
+    # Now these methods build a *named* mock with the name specified by the symbol argument; *no* methods are expected or stubbed and subsequent arguments *are* taken into account.
+    #
+    # Previously if {Expectation#yields} or {Expectation#multiple_yields} was called on an expectation, but no block was given when the method was invoked, the instruction to yield was ignored.
+    # Now a +LocalJumpError+ is raised.
+    #
+    # Enabling this configuration option reinstates the previous behaviour, but displays a deprecation warning.
+    #
+    # @param [Boolean] value +true+ to reinstate undocumented behaviour; disabled by default.
+    #
+    # @example Reinstate undocumented behaviour for {API#mock}
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = mock(:bar)
+    #   foo.inspect # => #<Mock>
+    #
+    #   not all expectations were satisfied
+    #   unsatisfied expectations:
+    #   - expected exactly once, invoked never: #<Mock>.foo
+    #
+    # @example Reinstate undocumented behaviour for {API#stub}
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = stub(:bar)
+    #   foo.inspect # => #<Mock>
+    #   foo.bar # => nil
+    #
+    # @example Reinstate undocumented behaviour for {Expectation#yields}
+    #   foo = mock('foo')
+    #   foo.stubs(:my_method).yields(1, 2)
+    #   foo.my_method # => raises LocalJumpError when no block is supplied
+    #
+    #   Mocha.configure do |c|
+    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   end
+    #
+    #   foo = mock('foo')
+    #   foo.stubs(:my_method).yields(1, 2)
+    #   foo.my_method # => does *not* raise LocalJumpError when no block is supplied
+    #
+    def reinstate_undocumented_behaviour_from_v1_9=(value)
+      @options[:reinstate_undocumented_behaviour_from_v1_9] = value
+    end
+
+    # @private
+    def reinstate_undocumented_behaviour_from_v1_9?
+      @options[:reinstate_undocumented_behaviour_from_v1_9]
+    end
+
     class << self
       # Allow the specified +action+.
       #
       # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
       # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
+      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:allow+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:allow+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
+      #   * {#stubbing_method_unnecessarily=}
+      #   * {#stubbing_method_on_non_mock_object=}
+      #   * {#stubbing_non_existent_method=}
+      #   * {#stubbing_non_public_method=}
+      #   * {#stubbing_method_on_nil=}
       def allow(action, &block)
+        if block_given?
+          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :allow) with the same block")
+        else
+          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :allow }")
+        end
         change_config action, :allow, &block
       end
 
       # @private
       def allow?(action)
-        configuration[action] == :allow
+        configuration.allow?(action)
       end
 
       # Warn if the specified +action+ is attempted.
       #
       # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
       # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
+      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:warn+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:warn+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
+      #   * {#stubbing_method_unnecessarily=}
+      #   * {#stubbing_method_on_non_mock_object=}
+      #   * {#stubbing_non_existent_method=}
+      #   * {#stubbing_non_public_method=}
+      #   * {#stubbing_method_on_nil=}
       def warn_when(action, &block)
+        if block_given?
+          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :warn) with the same block")
+        else
+          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :warn }")
+        end
         change_config action, :warn, &block
       end
 
       # @private
       def warn_when?(action)
-        configuration[action] == :warn
+        configuration.warn_when?(action)
       end
 
-      # Raise a {StubbingError} if if the specified +action+ is attempted.
+      # Raise a {StubbingError} if the specified +action+ is attempted.
       #
       # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
       # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
+      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:prevent+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:prevent+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
+      #   * {#stubbing_method_unnecessarily=}
+      #   * {#stubbing_method_on_non_mock_object=}
+      #   * {#stubbing_non_existent_method=}
+      #   * {#stubbing_non_public_method=}
+      #   * {#stubbing_method_on_nil=}
       def prevent(action, &block)
+        if block_given?
+          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :prevent) with the same block")
+        else
+          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :prevent }")
+        end
         change_config action, :prevent, &block
       end
 
       # @private
       def prevent?(action)
-        configuration[action] == :prevent
+        configuration.prevent?(action)
       end
 
       # @private
@@ -119,29 +381,51 @@ module Mocha
         @configuration = nil
       end
 
-      private
+      # Temporarily modify {Configuration} options.
+      #
+      # The supplied +temporary_options+ will override the current configuration for the duration of the supplied block.
+      # The configuration will be returned to its original state when the block returns.
+      #
+      # @param [Hash] temporary_options the configuration options to apply for the duration of the block.
+      # @yield block during which the configuration change will be in force.
+      #
+      # @example Temporarily allow stubbing of +nil+
+      #   Mocha::Configuration.override(stubbing_method_on_nil: :allow) do
+      #     nil.stubs(:foo)
+      #   end
+      def override(temporary_options)
+        original_configuration = configuration
+        @configuration = configuration.merge(new(temporary_options))
+        yield
+      ensure
+        @configuration = original_configuration
+      end
 
       # @private
       def configuration
-        @configuration ||= DEFAULTS.dup
+        @configuration ||= new
       end
 
+      private
+
       # @private
       def change_config(action, new_value, &block)
         if block_given?
           temporarily_change_config action, new_value, &block
         else
-          configuration[action] = new_value
+          configuration.send("#{action}=".to_sym, new_value)
         end
       end
 
       # @private
       def temporarily_change_config(action, new_value)
-        original_value = configuration[action]
-        configuration[action] = new_value
+        original_configuration = configuration
+        new_configuration = configuration.dup
+        new_configuration.send("#{action}=".to_sym, new_value)
+        @configuration = new_configuration
         yield
       ensure
-        configuration[action] = original_value
+        @configuration = original_configuration
       end
     end
   end