mocha 1.9.0 → 1.11.1

data/docs/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Mocha 1.9.0
+    &mdash; Mocha 1.11.1
   
 </title>
 
@@ -108,9 +108,9 @@
 </div>
 
       <div id="footer">
-  Generated on Mon Jun 17 18:38:43 2019 by
+  Generated on Tue Dec 17 12:49:34 2019 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.9.19 (ruby-2.5.3).
+  0.9.20 (ruby-2.6.5).
 </div>
 
     </div>

data/gemfiles/Gemfile.minitest.5.11.3

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec :path=>"../"
+
+group :development do
+  gem "minitest", "5.11.3"
+end

data/init.rb

@@ -1,3 +1 @@
-# Mocha should no longer be loaded at plugin load time
-# You should explicitly load Mocha *after* Test::Unit or MiniTest have been loaded
-# e.g. by adding "require 'mocha'" at the bottom of test/test_helper.rb
+warn 'Mocha deprecation warning: The old-style Rails plugin will not be supported in future versions of Mocha.'

data/lib/mocha.rb

@@ -1 +1,9 @@
 require 'mocha/version'
+require 'mocha/ruby_version'
+require 'mocha/deprecation'
+
+if Mocha::PRE_RUBY_V19
+  Mocha::Deprecation.warning(
+    'Versions of Ruby earlier than v1.9 will not be supported in future versions of Mocha.'
+  )
+end

data/lib/mocha/any_instance_method.rb

@@ -1,36 +1,20 @@
 require 'mocha/ruby_version'
-require 'mocha/class_method'
+require 'mocha/stubbed_method'
 
 module Mocha
-  class AnyInstanceMethod < ClassMethod
-    def mock
-      stubbee.any_instance.mocha
-    end
-
-    def reset_mocha
-      stubbee.any_instance.reset_mocha
-    end
+  class AnyInstanceMethod < StubbedMethod
+    private
 
-    def restore_original_method
-      return if use_prepended_module_for_stub_method?
-      return unless stub_method_overwrites_original_method?
-      original_method_owner.send(:define_method, method_name, original_method)
-      Module.instance_method(original_visibility).bind(original_method_owner).call(method_name)
+    def mock_owner
+      stubbee.any_instance
     end
 
-    private
-
-    def store_original_method
-      @original_method = original_method_owner.instance_method(method_name)
+    def method_body(method)
+      method
     end
 
-    def stub_method_definition
-      method_implementation = <<-CODE
-      def #{method_name}(*args, &block)
-        self.class.any_instance.mocha.method_missing(:#{method_name}, *args, &block)
-      end
-      CODE
-      [method_implementation, __FILE__, __LINE__ - 4]
+    def stubbee_method(method_name)
+      stubbee.instance_method(method_name)
     end
 
     def original_method_owner

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