mocha 2.8.0 → 3.0.0.pre.rc.2

data/lib/mocha/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mocha/ruby_version'
 require 'mocha/deprecation'
 
@@ -14,7 +16,6 @@ module Mocha
   #   Mocha.configure do |c|
   #     c.stubbing_method_unnecessarily = :prevent
   #     c.stubbing_method_on_non_mock_object = :warn
-  #     c.stubbing_method_on_nil = :allow
   #   end
   #
   def self.configure
@@ -34,7 +35,6 @@ module Mocha
   #   Mocha.configure do |c|
   #     c.stubbing_method_unnecessarily = :prevent
   #     c.stubbing_method_on_non_mock_object = :warn
-  #     c.stubbing_method_on_nil = :allow
   #   end
   #
   class Configuration
@@ -44,9 +44,8 @@ module Mocha
       stubbing_method_on_non_mock_object: :allow,
       stubbing_non_existent_method: :allow,
       stubbing_non_public_method: :allow,
-      stubbing_method_on_nil: :prevent,
       display_matching_invocations_on_failure: false,
-      strict_keyword_argument_matching: false
+      strict_keyword_argument_matching: Mocha::RUBY_V30_PLUS
     }.freeze
 
     attr_reader :options
@@ -196,33 +195,6 @@ module Mocha
       @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+.
-    # @deprecated This method is deprecated and will be removed in a future release. +nil+ is frozen in Ruby >= v2.2 and Mocha will be dropping support for Ruby v2.1. At that point it won't be possible to stub methods on +nil+ any more.
-    #
-    def stubbing_method_on_nil=(value)
-      Deprecation.warning([
-        '`Mocha::Configuration#stubbing_method_on_nil=` is deprecated and will be removed in a future release.',
-        '`nil` is frozen in Ruby >= v2.2 and Mocha will be dropping support for Ruby v2.1.',
-        "At that point it won't be possible to stub methods on `nil` any more."
-      ].join(' '))
-      @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.
@@ -259,17 +231,21 @@ module Mocha
 
     # Perform strict keyword argument comparison. Only supported in Ruby >= v2.7.
     #
-    # When this option is set to +false+ a positional +Hash+ and a set of keyword arguments are treated the same during comparison, which can lead to misleading passing tests in Ruby >= v3.0 (see examples below). However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa. This is because {#strict_keyword_argument_matching=} will default to +true+ in the future.
+    # When this option is set to +false+ a positional +Hash+ and a set of keyword arguments are treated the same during comparison, which can lead to misleading passing tests in Ruby >= v3.0 (see examples below). However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa.
     #
     # For more details on keyword arguments in Ruby v3, refer to {https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0 this article}.
     #
     # Note that +Hash+-related matchers such as {ParameterMatchers::Methods#has_value} or {ParameterMatchers::Methods#has_key} will still treat a positional +Hash+ and a set of keyword arguments the same, so misleading passing tests are still possible when they are used.
     #
-    # This configuration option is +false+ by default to enable gradual adoption, but will be +true+ by default in the future.
+    # This configuration option is +false+ by default in Ruby v2.7 to enable gradual adoption, but +true+ by default in Ruby >= v3.0.
     #
-    # @param [Boolean] value +true+ to enable strict keyword argument matching; +false+ by default.
+    # @param [Boolean] value +true+ to enable strict keyword argument matching.
     #
-    # @example Loose keyword argument matching (default)
+    # @example Loose keyword argument matching (default in Ruby v2.7)
+    #
+    #   Mocha.configure do |c|
+    #     c.strict_keyword_argument_matching = false
+    #   end
     #
     #   class Example
     #     def foo(a, bar:); end
@@ -280,7 +256,7 @@ module Mocha
     #   example.foo('a', { bar: 'b' })
     #   # This passes the test, but would result in an ArgumentError in practice
     #
-    # @example Strict keyword argument matching
+    # @example Strict keyword argument matching (default in Ruby >= v3.0)
     #
     #   Mocha.configure do |c|
     #     c.strict_keyword_argument_matching = true
@@ -296,6 +272,7 @@ module Mocha
     #   # This now fails as expected
     def strict_keyword_argument_matching=(value)
       raise 'Strict keyword argument matching requires Ruby 2.7 and above.' unless Mocha::RUBY_V27_PLUS
+
       @options[:strict_keyword_argument_matching] = value
     end
 
@@ -318,9 +295,9 @@ module Mocha
       # @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)
+      # @example Temporarily prevent stubbing of non-mock object
+      #   Mocha::Configuration.override(stubbing_method_on_non_mock_object: :prevent) do
+      #     123.stubs(:to_s).returns('456')
       #   end
       def override(temporary_options)
         original_configuration = configuration
@@ -342,7 +319,7 @@ module Mocha
         if block_given?
           temporarily_change_config action, new_value, &block
         else
-          configuration.send("#{action}=".to_sym, new_value)
+          configuration.send(:"#{action}=", new_value)
         end
       end
 
@@ -350,7 +327,7 @@ module Mocha
       def temporarily_change_config(action, new_value)
         original_configuration = configuration
         new_configuration = configuration.dup
-        new_configuration.send("#{action}=".to_sym, new_value)
+        new_configuration.send(:"#{action}=", new_value)
         @configuration = new_configuration
         yield
       ensure

data/lib/mocha/default_name.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mocha
+  class DefaultName
+    def initialize(mock)
+      @mock = mock
+    end
+
+    def mocha_inspect
+      address = @mock.__id__ * 2
+      address += 0x100000000 if address < 0
+      "#<Mock:0x#{format('%<address>x', address: address)}>"
+    end
+  end
+end

data/lib/mocha/default_receiver.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class DefaultReceiver
+    def initialize(mock)
+      @mock = mock
+    end
+
+    def mocks
+      [@mock]
+    end
+  end
+end

data/lib/mocha/deprecation.rb

@@ -1,21 +1,27 @@
+# frozen_string_literal: true
+
 require 'mocha/backtrace_filter'
 
 module Mocha
   class Deprecation
-    class << self
-      attr_accessor :mode, :messages
-
-      def warning(*messages)
-        message = messages.join
-        @messages << message
-        return if mode == :disabled
+    class Logger
+      def warning(message)
         filter = BacktraceFilter.new
         location = filter.filtered(caller)[0]
         warn "Mocha deprecation warning at #{location}: #{message}"
       end
     end
 
-    self.mode = :enabled
-    self.messages = []
+    class << self
+      attr_writer :logger
+
+      def warning(message)
+        logger.call(message)
+      end
+
+      def logger
+        @logger ||= Logger.new
+      end
+    end
   end
 end

data/lib/mocha/detection/minitest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   module Detection
     module Minitest

data/lib/mocha/detection/test_unit.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   module Detection
     module TestUnit
@@ -14,7 +16,8 @@ module Mocha
         if testcase
           begin
             require 'test/unit/version'
-          rescue LoadError # rubocop:disable Lint/HandleExceptions
+          rescue LoadError
+            warn "Unable to load 'test/unit/version', but continuing anyway" if $DEBUG
           end
           if defined?(::Test::Unit::VERSION)
             version = ::Test::Unit::VERSION

data/lib/mocha/error_with_filtered_backtrace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mocha/backtrace_filter'
 
 module Mocha

data/lib/mocha/exception_raiser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   class ExceptionRaiser
     def initialize(exception, message)
@@ -9,6 +11,7 @@ module Mocha
       invocation.raised(@exception)
       raise @exception, @exception.to_s if @exception.is_a?(Module) && (@exception < Interrupt)
       raise @exception, @message if @message
+
       raise @exception
     end
   end

data/lib/mocha/expectation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ruby2_keywords'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
@@ -6,23 +8,22 @@ require 'mocha/return_values'
 require 'mocha/exception_raiser'
 require 'mocha/thrower'
 require 'mocha/yield_parameters'
-require 'mocha/is_a'
 require 'mocha/in_state_ordering_constraint'
 require 'mocha/change_state_side_effect'
 require 'mocha/cardinality'
 require 'mocha/configuration'
-require 'mocha/block_matcher'
+require 'mocha/block_matchers'
 require 'mocha/backtrace_filter'
 
 module Mocha
   # Methods on expectations returned from {Mock#expects}, {Mock#stubs}, {ObjectMethods#expects} and {ObjectMethods#stubs}.
   class Expectation
-    # Modifies expectation so that the number of calls to the expected method must be within a specific +range+.
+    # Modifies expectation so that the number of invocations of the expected method must be within a specified range or exactly equal to a specified number.
     #
-    # @param [Range,Integer] range specifies the allowable range in the number of expected invocations.
+    # @param [Range,Integer] range_or_number specifies the allowable range for the number of expected invocations or the specified number of expected invocations.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
-    # @example Specifying a specific number of expected invocations.
+    # @example Specifying an exact number of expected invocations.
     #   object = mock()
     #   object.expects(:expected_method).times(3)
     #   3.times { object.expected_method }
@@ -33,7 +34,7 @@ module Mocha
     #   2.times { object.expected_method }
     #   # => verify fails
     #
-    # @example Specifying a range in the number of expected invocations.
+    # @example Specifying a range for the number of expected invocations.
     #   object = mock()
     #   object.expects(:expected_method).times(2..4)
     #   3.times { object.expected_method }
@@ -43,12 +44,41 @@ module Mocha
     #   object.expects(:expected_method).times(2..4)
     #   object.expected_method
     #   # => verify fails
-    def times(range)
-      @cardinality.times(range)
+    def times(range_or_number)
+      @cardinality.times(range_or_number)
+      self
+    end
+
+    # Modifies expectation so that the expected method must be called exactly three times. This is equivalent to calling {#times} with an argument of +3+.
+    #
+    # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
+    #
+    # @example Expected method must be invoked exactly three times.
+    #   object = mock()
+    #   object.expects(:expected_method).thrice
+    #   object.expected_method
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).thrice
+    #   object.expected_method
+    #   object.expected_method
+    #   object.expected_method
+    #   object.expected_method # => unexpected invocation
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).thrice
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify fails
+    def thrice
+      @cardinality.exactly(3)
       self
     end
 
-    # Modifies expectation so that the expected method must be called exactly twice.
+    # Modifies expectation so that the expected method must be called exactly twice. This is equivalent to calling {#times} with an argument of +2+.
     #
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
@@ -74,7 +104,7 @@ module Mocha
       self
     end
 
-    # Modifies expectation so that the expected method must be called exactly once.
+    # Modifies expectation so that the expected method must be called exactly once. This is equivalent to calling {#times} with an argument of +1+.
     #
     # Note that this is the default behaviour for an expectation, but you may wish to use it for clarity/emphasis.
     #
@@ -136,7 +166,7 @@ module Mocha
       self
     end
 
-    # Modifies expectation so that the expected method must be called at least once.
+    # Modifies expectation so that the expected method must be called at least once. This is equivalent to calling {#at_least} with an argument of +1+.
     #
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
@@ -172,7 +202,7 @@ module Mocha
       self
     end
 
-    # Modifies expectation so that the expected method must be called at most once.
+    # Modifies expectation so that the expected method must be called at most once. This is equivalent to calling {#at_most} with an argument of +1+.
     #
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
@@ -200,9 +230,9 @@ module Mocha
     #
     # Positional arguments were separated from keyword arguments in Ruby v3 (see {https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0 this article}). In relation to this a new configuration option ({Configuration#strict_keyword_argument_matching=}) is available in Ruby >= 2.7.
     #
-    # When {Configuration#strict_keyword_argument_matching=} is set to +false+ (which is currently the default), a positional +Hash+ and a set of keyword arguments passed to {#with} are treated the same for the purposes of parameter matching. However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa. This is because {Configuration#strict_keyword_argument_matching=} will default to +true+ in the future.
+    # When {Configuration#strict_keyword_argument_matching=} is set to +false+ (which is the default in Ruby v2.7), a positional +Hash+ and a set of keyword arguments passed to {#with} are treated the same for the purposes of parameter matching. However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa.
     #
-    # When {Configuration#strict_keyword_argument_matching=} is set to +true+, an actual positional +Hash+ will not match an expected set of keyword arguments; and vice versa, an actual set of keyword arguments will not match an expected positional +Hash+, i.e. the parameter matching is stricter.
+    # When {Configuration#strict_keyword_argument_matching=} is set to +true+ (which is the default in Ruby >= v3.0), an actual positional +Hash+ will not match an expected set of keyword arguments; and vice versa, an actual set of keyword arguments will not match an expected positional +Hash+, i.e. the parameter matching is stricter.
     #
     # @see ParameterMatchers
     # @see Configuration#strict_keyword_argument_matching=
@@ -235,7 +265,11 @@ module Mocha
     #   object.expected_method(['string1'], 'any-old-value')
     #   # => verify fails
     #
-    # @example Loose keyword argument matching (default)
+    # @example Loose keyword argument matching (default in Ruby v2.7).
+    #
+    #   Mocha.configure do |c|
+    #     c.strict_keyword_argument_matching = false
+    #   end
     #
     #   class Example
     #     def foo(a, bar:); end
@@ -246,7 +280,7 @@ module Mocha
     #   example.foo('a', { bar: 'b' })
     #   # This passes the test, but would result in an ArgumentError in practice
     #
-    # @example Strict keyword argument matching
+    # @example Strict keyword argument matching (default in Ruby >= 3.0).
     #
     #   Mocha.configure do |c|
     #     c.strict_keyword_argument_matching = true
@@ -711,19 +745,19 @@ module Mocha
 
     # @private
     def mocha_inspect
-      message = "#{@cardinality.anticipated_times}, #{@cardinality.invoked_times}: #{method_signature}"
-      message << "; #{@ordering_constraints.map(&:mocha_inspect).join('; ')}" unless @ordering_constraints.empty?
+      strings = ["#{@cardinality.anticipated_times}, #{@cardinality.invoked_times}: #{method_signature}"]
+      strings << "; #{@ordering_constraints.map(&:mocha_inspect).join('; ')}" unless @ordering_constraints.empty?
       if Mocha.configuration.display_matching_invocations_on_failure?
-        message << @cardinality.actual_invocations
+        strings << @cardinality.actual_invocations
       end
-      message
+      strings.join
     end
 
     # @private
     def method_signature
-      signature = "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
-      signature << " #{@block_matcher.mocha_inspect}" if @block_matcher.mocha_inspect
-      signature
+      strings = ["#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"]
+      strings << " #{@block_matcher.mocha_inspect}" if @block_matcher.mocha_inspect
+      strings.join
     end
 
     # @private

data/lib/mocha/expectation_error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   # Default exception class raised when an unexpected invocation or an unsatisfied expectation occurs.
   #

data/lib/mocha/expectation_error_factory.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mocha/backtrace_filter'
 require 'mocha/expectation_error'
 

data/lib/mocha/expectation_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   class ExpectationList
     def initialize(expectations = [])
@@ -29,7 +31,7 @@ module Mocha
       matching_expectations(invocation).detect(&:invocations_never_allowed?)
     end
 
-    def verified?(assertion_counter = nil)
+    def verified?(assertion_counter)
       @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
     end
 

data/lib/mocha/hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mocha/mockery'
 
 module Mocha
@@ -19,8 +21,8 @@ module Mocha
     # Prepares Mocha before a test (only for use by authors of test libraries).
     #
     # This method should be called before each individual test starts (including before any "setup" code).
-    def mocha_setup
-      Mockery.setup
+    def mocha_setup(assertion_counter)
+      Mockery.setup(assertion_counter)
     end
 
     # Verifies that all mock expectations have been met (only for use by authors of test libraries).
@@ -28,8 +30,8 @@ module Mocha
     # This is equivalent to a series of "assertions".
     #
     # This method should be called at the end of each individual test, before it has been determined whether or not the test has passed.
-    def mocha_verify(assertion_counter = nil)
-      Mockery.verify(assertion_counter)
+    def mocha_verify
+      Mockery.verify
     end
 
     # Resets Mocha after a test (only for use by authors of test libraries).

data/lib/mocha/ignoring_warning.rb

@@ -0,0 +1,20 @@
+module Mocha
+  # @private
+  module IgnoringWarning
+    def ignoring_warning(pattern, if_: true)
+      return yield unless if_
+
+      begin
+        original_warn = Warning.method(:warn)
+        Warning.singleton_class.define_method(:warn) do |message|
+          original_warn.call(message) unless message =~ pattern
+        end
+
+        yield
+      ensure
+        Warning.singleton_class.undef_method(:warn)
+        Warning.singleton_class.define_method(:warn, original_warn)
+      end
+    end
+  end
+end

data/lib/mocha/impersonating_any_instance_name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ImpersonatingAnyInstanceName
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def mocha_inspect
+      "#<AnyInstance:#{@klass.mocha_inspect}>"
+    end
+  end
+end

data/lib/mocha/impersonating_name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ImpersonatingName
+    def initialize(object)
+      @object = object
+    end
+
+    def mocha_inspect
+      @object.mocha_inspect
+    end
+  end
+end

data/lib/mocha/in_state_ordering_constraint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   class InStateOrderingConstraint
     def initialize(state_predicate)

data/lib/mocha/inspect.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'date'
 
 module Mocha
@@ -11,7 +13,7 @@ module Mocha
     end
 
     module ArrayMethods
-      def mocha_inspect(wrapped = true)
+      def mocha_inspect(wrapped: true)
         unwrapped = collect(&:mocha_inspect).join(', ')
         wrapped ? "[#{unwrapped}]" : unwrapped
       end
@@ -19,17 +21,18 @@ module Mocha
 
     module HashMethods
       def mocha_inspect
+        unwrapped = collect do |key, value|
+          case key
+          when Symbol
+            "#{key}: #{value.mocha_inspect}"
+          else
+            "#{key.mocha_inspect} => #{value.mocha_inspect}"
+          end
+        end.join(', ')
+
         if Hash.ruby2_keywords_hash?(self)
-          collect do |key, value|
-            case key
-            when Symbol
-              "#{key}: #{value.mocha_inspect}"
-            else
-              "#{key.mocha_inspect} => #{value.mocha_inspect}"
-            end
-          end.join(', ')
+          empty? ? '**{}' : unwrapped
         else
-          unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
           "{#{unwrapped}}"
         end
       end

data/lib/mocha/instance_method.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 require 'mocha/stubbed_method'
 
 module Mocha
   class InstanceMethod < StubbedMethod
     private
 
-    def mock_owner
-      stubbee
+    def stubbee
+      stubba_object
     end
 
     def stubbee_method(method_name)
-      stubbee._method(method_name)
+      stubba_object._method(method_name)
     end
 
     def original_method_owner
-      stubbee.singleton_class
+      stubba_object.singleton_class
     end
   end
 end

data/lib/mocha/integration/assertion_counter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Mocha
   module Integration
     class AssertionCounter

data/lib/mocha/integration/minitest/adapter.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'mocha/api'
 require 'mocha/integration/assertion_counter'
 require 'mocha/expectation_error_factory'
 
 module Mocha
   module Integration
+    # Contains {Adapter} that integrates Mocha into recent versions of Minitest.
     module Minitest
       # Integrates Mocha into recent versions of Minitest.
       #
@@ -28,15 +31,16 @@ module Mocha
 
         # @private
         def before_setup
-          mocha_setup
+          assertion_counter = Integration::AssertionCounter.new(self)
+          mocha_setup(assertion_counter)
           super
         end
 
         # @private
         def before_teardown
           return unless passed?
-          assertion_counter = Integration::AssertionCounter.new(self)
-          mocha_verify(assertion_counter)
+
+          mocha_verify
         ensure
           super
         end