mocha 1.16.1 → 2.7.1

data/Rakefile

@@ -5,9 +5,14 @@ end
 require 'bundler/setup'
 
 require 'rake/testtask'
+begin
+  # Only available with default Gemfile and in Ruby >= v2.2
+  require 'rubocop/rake_task'
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+end
 
-desc 'Run all tests'
-task 'default' => ['test', 'test:performance']
+desc 'Run all linters and tests'
+task 'default' => ['lint', 'test', 'test:performance']
 
 desc 'Run tests'
 task 'test' do
@@ -37,10 +42,10 @@ namespace 'test' do # rubocop:disable Metrics/BlockLength
   end
 
   namespace 'integration' do
-    desc 'Run MiniTest integration tests (intended to be run in its own process)'
+    desc 'Run Minitest integration tests (intended to be run in its own process)'
     Rake::TestTask.new('minitest') do |t|
       t.libs << 'test'
-      t.test_files = FileList['test/integration/mini_test_test.rb']
+      t.test_files = FileList['test/integration/minitest_test.rb']
       t.verbose = true
       t.warning = true
     end
@@ -76,37 +81,37 @@ namespace 'test' do # rubocop:disable Metrics/BlockLength
   end
 end
 
-begin
-  require 'rubocop/rake_task'
-  if RUBY_VERSION >= '2.2.0' && (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby') && ENV['MOCHA_RUN_INTEGRATION_TESTS'].nil?
+task 'lint' do
+  if defined?(RuboCop::RakeTask)
     RuboCop::RakeTask.new
-    task 'test' => 'rubocop'
+    Rake::Task['rubocop'].invoke
+  else
+    puts 'RuboCop not available - skipping linting'
   end
-rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
 # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 def benchmark_test_case(klass, iterations)
   require 'benchmark'
-  require 'mocha/detection/mini_test'
+  require 'mocha/detection/minitest'
 
-  if defined?(MiniTest)
-    minitest_version = Gem::Version.new(Mocha::Detection::MiniTest.version)
+  if defined?(Minitest)
+    minitest_version = Gem::Version.new(Mocha::Detection::Minitest.version)
     if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
       Minitest.seed = 1
-      result = Benchmark.realtime { iterations.times { |_i| klass.run(MiniTest::CompositeReporter.new) } }
-      MiniTest::Runnable.runnables.delete(klass)
+      result = Benchmark.realtime { iterations.times { |_i| klass.run(Minitest::CompositeReporter.new) } }
+      Minitest::Runnable.runnables.delete(klass)
       result
     else
-      MiniTest::Unit.output = StringIO.new
-      Benchmark.realtime { iterations.times { |_i| MiniTest::Unit.new.run([klass]) } }
+      Minitest::Unit.output = StringIO.new
+      Benchmark.realtime { iterations.times { |_i| Minitest::Unit.new.run([klass]) } }
     end
   else
     load 'test/unit/ui/console/testrunner.rb' unless defined?(Test::Unit::UI::Console::TestRunner)
     unless @silent_option
       begin
         load 'test/unit/ui/console/outputlevel.rb' unless defined?(Test::Unit::UI::Console::OutputLevel::SILENT)
-        @silent_option = { :output_level => Test::Unit::UI::Console::OutputLevel::SILENT }
+        @silent_option = { output_level: Test::Unit::UI::Console::OutputLevel::SILENT }
       rescue LoadError
         @silent_option = Test::Unit::UI::SILENT
       end
@@ -124,14 +129,8 @@ if ENV['MOCHA_GENERATE_DOCS']
     `rm -rf ./docs`
   end
 
-  task 'docs_environment' do
-    unless ENV['GOOGLE_ANALYTICS_WEB_PROPERTY_ID']
-      puts "\nWarning: GOOGLE_ANALYTICS_WEB_PROPERTY_ID was not defined\n\n"
-    end
-  end
-
   desc 'Generate documentation'
-  YARD::Rake::YardocTask.new('yardoc' => 'docs_environment') do |task|
+  YARD::Rake::YardocTask.new('yardoc') do |task|
     task.options = ['--title', "Mocha #{Mocha::VERSION}", '--fail-on-warning']
   end
 

data/lib/mocha/api.rb

@@ -7,7 +7,7 @@ require 'mocha/object_methods'
 require 'mocha/class_methods'
 
 module Mocha
-  # Methods added to +Test::Unit::TestCase+, +MiniTest::Unit::TestCase+ or equivalent.
+  # 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.
@@ -52,7 +52,6 @@ module Mocha
     #
     # @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 = {})
@@ -61,32 +60,14 @@ module Mocha
     #
     # @example Using expected_methods_vs_return_values Hash to setup expectations.
     #   def test_motor_starts_and_stops
-    #     motor = mock('motor', :start => true, :stop => true)
+    #     motor = mock('motor', start: true, stop: true)
     #     assert motor.start
     #     assert motor.stop
     #     # an error will be raised unless both Motor#start and Motor#stop have been called
     #   end
     #
-    def mock(*arguments) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      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
+    def mock(*arguments)
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       mock = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       mock.expects(expectations)
@@ -99,46 +80,26 @@ module Mocha
     #
     # @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.
+    #   @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 Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
     #   def test_motor_starts_and_stops
-    #     motor = stub('motor', :start => true, :stop => true)
+    #     motor = stub('motor', start: true, stop: true)
     #     assert motor.start
     #     assert motor.stop
     #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
     #   end
-    # 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
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       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.
     #
@@ -146,7 +107,6 @@ module Mocha
     #
     # @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 = {})
@@ -155,44 +115,27 @@ module Mocha
     #
     # @example Ignore invocations of irrelevant methods.
     #   def test_motor_stops
-    #     motor = stub_everything('motor', :stop => true)
+    #     motor = stub_everything('motor', stop: true)
     #     assert_nil motor.irrelevant_method_1 # => no error raised
     #     assert_nil motor.irrelevant_method_2 # => no error raised
     #     assert motor.stop
     #   end
-    # 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
+      name = arguments.shift if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       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.
     #
-    # Specify that an expected invocation must occur within a named {Sequence} by using {Expectation#in_sequence}.
+    # Specify that an expected invocation must occur within a named {Sequence} by calling {Expectation#in_sequence}
+    # on each expectation or by passing a block within which all expectations should be constrained by the {Sequence}.
     #
+    # @param [String] name name of sequence
+    # @yield optional block within which expectations should be constrained by the sequence
     # @return [Sequence] a new sequence
     #
     # @see Expectation#in_sequence
@@ -216,8 +159,23 @@ module Mocha
     #
     #   task_one.execute
     #   task_two.execute
+    #
+    # @example Ensure methods on egg are invoked in the correct order using a block.
+    #   egg = mock('egg')
+    #   sequence('breakfast') do
+    #     egg.expects(:crack)
+    #     egg.expects(:fry)
+    #     egg.expects(:eat)
+    #   end
     def sequence(name)
-      Sequence.new(name)
+      Sequence.new(name).tap do |seq|
+        Mockery.instance.sequences.push(seq)
+        begin
+          yield if block_given?
+        ensure
+          Mockery.instance.sequences.pop
+        end
+      end
     end
 
     # Builds a new state machine which can be used to constrain the order in which expectations can occur.
@@ -230,6 +188,7 @@ module Mocha
     #
     # A test can contain multiple state machines.
     #
+    # @param [String] name name of state machine
     # @return [StateMachine] a new state machine
     #
     # @see Expectation#then

data/lib/mocha/backtrace_filter.rb

@@ -3,11 +3,11 @@ module Mocha
     LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..')) + File::SEPARATOR
 
     def initialize(lib_directory = LIB_DIRECTORY)
-      @path_pattern = Regexp.new(lib_directory)
+      @lib_directory = lib_directory
     end
 
     def filtered(backtrace)
-      backtrace.reject { |location| @path_pattern.match(File.expand_path(location)) }
+      backtrace.reject { |location| File.expand_path(location).start_with?(@lib_directory) }
     end
   end
 end

data/lib/mocha/cardinality.rb

@@ -34,6 +34,10 @@ module Mocha
       @invocations.size < maximum
     end
 
+    def invocations_never_allowed?
+      maximum.zero?
+    end
+
     def satisfied?
       @invocations.size >= required
     end

data/lib/mocha/configuration.rb

@@ -1,3 +1,6 @@
+require 'mocha/ruby_version'
+require 'mocha/deprecation'
+
 module Mocha
   # Allows setting of configuration options. See {Configuration} for the available options.
   #
@@ -37,13 +40,13 @@ module Mocha
   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,
-      :display_matching_invocations_on_failure => false,
-      :reinstate_undocumented_behaviour_from_v1_9 => false
+      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,
+      display_matching_invocations_on_failure: false,
+      strict_keyword_argument_matching: false
     }.freeze
 
     attr_reader :options
@@ -204,8 +207,14 @@ module Mocha
     # 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
 
@@ -248,145 +257,54 @@ module Mocha
       @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.
+    # Perform strict keyword argument comparison. Only supported in Ruby >= v2.7.
     #
-    # 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.
+    # 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.
     #
-    # Enabling this configuration option reinstates the previous behaviour, but displays a deprecation warning.
+    # 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}.
     #
-    # @param [Boolean] value +true+ to reinstate undocumented behaviour; disabled by default.
-    # @deprecated Fix deprecation warnings caused by reliance on v1.9 behaviour and remove calls to this method.
+    # Note that +Hash+-related matchers such as {ParameterMatchers#has_value} or {ParameterMatchers#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.
     #
-    # @example Reinstate undocumented behaviour for {API#mock}
-    #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
-    #   end
+    # This configuration option is +false+ by default to enable gradual adoption, but will be +true+ by default in the future.
     #
-    #   foo = mock(:bar)
-    #   foo.inspect # => #<Mock>
+    # @param [Boolean] value +true+ to enable strict keyword argument matching; +false+ by default.
     #
-    #   not all expectations were satisfied
-    #   unsatisfied expectations:
-    #   - expected exactly once, invoked never: #<Mock>.foo
+    # @example Loose keyword argument matching (default)
     #
-    # @example Reinstate undocumented behaviour for {API#stub}
-    #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   class Example
+    #     def foo(a, bar:); end
     #   end
     #
-    #   foo = stub(:bar)
-    #   foo.inspect # => #<Mock>
-    #   foo.bar # => nil
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This passes the test, but would result in an ArgumentError in practice
     #
-    # @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
+    # @example Strict keyword argument matching
     #
     #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #     c.strict_keyword_argument_matching = 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)
-      if value
-        sentence1 = 'Configuration#reinstate_undocumented_behaviour_from_v1_9= will be removed in the future.'
-        sentence2 = 'Fix deprecation warnings caused by reliance on v1.9 behaviour.'
-        sentence3 = 'See docs for API#mock, API#stub, API#stub_everything, Expectation#yields and Expectation#multiple_yields.'
-        Deprecation.warning([sentence1, sentence2, sentence3].join(' '))
-      else
-        sentence1 = 'Configuration#reinstate_undocumented_behaviour_from_v1_9= is unnecessarily being set to false, because this is now the default value.'
-        sentence2 = 'Configuration#reinstate_undocumented_behaviour_from_v1_9= will be removed in the future, so you should avoid calling it.'
-        Deprecation.warning([sentence1, sentence2].join(' '))
-      end
-      @options[:reinstate_undocumented_behaviour_from_v1_9] = value
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
+    #
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # 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
 
     # @private
-    def reinstate_undocumented_behaviour_from_v1_9?
-      @options[:reinstate_undocumented_behaviour_from_v1_9]
+    def strict_keyword_argument_matching?
+      @options[:strict_keyword_argument_matching]
     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.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.warn_when?(action)
-      end
-
-      # 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.prevent?(action)
-      end
-
       # @private
       def reset_configuration
         @configuration = nil

data/lib/mocha/debug.rb

@@ -1,12 +1,9 @@
 module Mocha
   module Debug
-    OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) do |hash, key|
-      hash[key] = true
-      hash
-    end.freeze
+    OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').freeze
 
     def self.puts(message)
-      warn(message) if OPTIONS['debug']
+      warn(message) if OPTIONS.include?('debug')
     end
   end
 end

data/lib/mocha/detection/{mini_test.rb → minitest.rb}

@@ -1,17 +1,17 @@
 module Mocha
   module Detection
-    module MiniTest
+    module Minitest
       def self.testcase
         if defined?(::Minitest::Test)
           ::Minitest::Test
-        elsif defined?(::MiniTest::Unit::TestCase)
-          ::MiniTest::Unit::TestCase
+        elsif defined?(::Minitest::Unit::TestCase)
+          ::Minitest::Unit::TestCase
         end
       end
 
       def self.version
-        if defined?(::MiniTest::Unit::VERSION)
-          ::MiniTest::Unit::VERSION
+        if defined?(::Minitest::Unit::VERSION)
+          ::Minitest::Unit::VERSION
         elsif defined?(::Minitest::VERSION)
           ::Minitest::VERSION
         else

data/lib/mocha/detection/test_unit.rb

@@ -3,8 +3,8 @@ module Mocha
     module TestUnit
       def self.testcase
         if defined?(::Test::Unit::TestCase) &&
-           !(defined?(::MiniTest::Unit::TestCase) && (::Test::Unit::TestCase < ::MiniTest::Unit::TestCase)) &&
-           !(defined?(::MiniTest::Spec) && (::Test::Unit::TestCase < ::MiniTest::Spec))
+           !(defined?(::Minitest::Unit::TestCase) && (::Test::Unit::TestCase < ::Minitest::Unit::TestCase)) &&
+           !(defined?(::Minitest::Spec) && (::Test::Unit::TestCase < ::Minitest::Spec))
           ::Test::Unit::TestCase
         end
       end