mocha 0.10.5 → 1.13.0

data/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb

@@ -1,53 +1,63 @@
-require 'test/unit/testcase'
-require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
 require 'mocha/expectation_error'
 
 module Mocha
-  
   module Integration
-    
     module TestUnit
-      
       module RubyVersion186AndAbove
+        def self.applicable_to?(test_unit_version, ruby_version)
+          Gem::Requirement.new('<= 1.2.3').satisfied_by?(test_unit_version) && Gem::Requirement.new('>= 1.8.6').satisfied_by?(ruby_version)
+        end
+
+        def self.description
+          'monkey patch for standard library Test::Unit in Ruby >= v1.8.6'
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit for Ruby >= v1.8.6" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-          begin
+
+        module RunMethodPatch
+          # rubocop:disable all
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
             begin
-              setup
-              __send__(@method_name)
-              mocha_verify(assertion_counter)
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue Exception
-              raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
-              add_error($!)
-            ensure
               begin
-                teardown
+                mocha_setup
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
               rescue Test::Unit::AssertionFailedError => e
                 add_failure(e.message, e.backtrace)
               rescue Exception
                 raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
                 add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Mocha::ExpectationError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Exception
+                  raise if Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS.include? $!.class
+                  add_error($!)
+                end
               end
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
           end
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end

data/lib/mocha/integration/test_unit.rb

@@ -1,57 +1,51 @@
-require 'mocha/api'
-require 'mocha/options'
-
-if !Test::Unit::TestCase.ancestors.include?(Mocha::API)
-
-  require 'mocha/integration/test_unit/gem_version_200'
-  require 'mocha/integration/test_unit/gem_version_201_to_202'
-  require 'mocha/integration/test_unit/gem_version_203_to_220'
-  require 'mocha/integration/test_unit/gem_version_230_to_240'
-  require 'mocha/integration/test_unit/ruby_version_185_and_below'
-  require 'mocha/integration/test_unit/ruby_version_186_and_above'
-
-  module Test
-    module Unit
-      class TestCase
-
-        include Mocha::API
-
-        alias_method :run_before_mocha, :run
-        remove_method :run
-
-        test_unit_version = begin
-          load 'test/unit/version.rb'
-          Gem::Version.new(Test::Unit::VERSION)
-        rescue LoadError
-          Gem::Version.new('1.x')
-        end
-
-        if $mocha_options['debug']
-          $stderr.puts "Detected Ruby version: #{RUBY_VERSION}"
-          $stderr.puts "Detected Test::Unit version: #{test_unit_version}"
-        end
-
-        if (test_unit_version == Gem::Version.new('1.x')) || (test_unit_version == Gem::Version.new('1.2.3'))
-          if RUBY_VERSION < '1.8.6'
-            include Mocha::Integration::TestUnit::RubyVersion185AndBelow
-          else
-            include Mocha::Integration::TestUnit::RubyVersion186AndAbove
+require 'mocha/debug'
+
+require 'mocha/detection/test_unit'
+
+require 'mocha/integration/test_unit/nothing'
+require 'mocha/integration/test_unit/ruby_version_185_and_below'
+require 'mocha/integration/test_unit/ruby_version_186_and_above'
+require 'mocha/integration/test_unit/gem_version_200'
+require 'mocha/integration/test_unit/gem_version_201_to_202'
+require 'mocha/integration/test_unit/gem_version_203_to_220'
+require 'mocha/integration/test_unit/gem_version_230_to_250'
+require 'mocha/integration/test_unit/adapter'
+
+require 'mocha/deprecation'
+
+module Mocha
+  module Integration
+    module TestUnit
+      def self.activate
+        return false unless Detection::TestUnit.testcase
+        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
+        ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+
+        Debug.puts "Detected Ruby version: #{ruby_version}"
+        Debug.puts "Detected Test::Unit version: #{test_unit_version}"
+
+        integration_module = [
+          TestUnit::Adapter,
+          TestUnit::GemVersion230To250,
+          TestUnit::GemVersion203To220,
+          TestUnit::GemVersion201To202,
+          TestUnit::GemVersion200,
+          TestUnit::RubyVersion186AndAbove,
+          TestUnit::RubyVersion185AndBelow,
+          TestUnit::Nothing
+        ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
+
+        unless ::Test::Unit::TestCase < integration_module
+          unless integration_module == TestUnit::Adapter
+            Deprecation.warning(
+              'Versions of test-unit earlier than v2.5.1 will not be supported in future versions of Mocha.'
+            )
           end
-        elsif Gem::Requirement.new('2.0.0').satisfied_by?(test_unit_version)
-          include Mocha::Integration::TestUnit::GemVersion200
-        elsif Gem::Requirement.new('>= 2.0.1', '<= 2.0.2').satisfied_by?(test_unit_version)
-          include Mocha::Integration::TestUnit::GemVersion201To202
-        elsif Gem::Requirement.new('>= 2.0.3', '<= 2.2.0').satisfied_by?(test_unit_version)
-          include Mocha::Integration::TestUnit::GemVersion203To220
-        elsif Gem::Requirement.new('>= 2.3.0').satisfied_by?(test_unit_version)
-          $stderr.puts "*** Test::Unit integration has not been verified but patching anyway ***" if (Gem::Requirement.new('> 2.4.0').satisfied_by?(test_unit_version)) && $mocha_options['debug']
-          include Mocha::Integration::TestUnit::GemVersion230To240
-        else
-          $stderr.puts "*** No Mocha integration for Test::Unit version ***" if $mocha_options['debug']
+          Debug.puts "Applying #{integration_module.description}"
+          ::Test::Unit::TestCase.send(:include, integration_module)
         end
-
+        true
       end
     end
   end
-
 end

data/lib/mocha/integration.rb

@@ -1,38 +1,11 @@
+require 'mocha/integration/test_unit'
+require 'mocha/integration/mini_test'
+
 module Mocha
-  
   module Integration
-    
-    class << self
-    
-      def monkey_patches
-        patches = []
-        if test_unit_testcase_defined? && !test_unit_testcase_inherits_from_miniunit_testcase?
-          patches << 'mocha/integration/test_unit'
-        end
-        if mini_unit_testcase_defined?
-          patches << 'mocha/integration/mini_test'
-        end
-        patches
-      end
-      
-      def test_unit_testcase_defined?
-        defined?(Test) && defined?(Test::Unit) && defined?(Test::Unit::TestCase)
-      end
-      
-      def mini_unit_testcase_defined?
-        defined?(MiniTest) && defined?(MiniTest::Unit) && defined?(MiniTest::Unit::TestCase)
-      end
-      
-      def test_unit_testcase_inherits_from_miniunit_testcase?
-        test_unit_testcase_defined? && mini_unit_testcase_defined? && Test::Unit::TestCase.ancestors.include?(MiniTest::Unit::TestCase)
-      end
-      
+    def self.activate
+      return unless [Integration::TestUnit, Integration::MiniTest].map(&:activate).none?
+      raise "Test::Unit or Minitest must be loaded *before* `require 'mocha/setup'`."
     end
-    
   end
-  
-end
-
-Mocha::Integration.monkey_patches.each do |patch|
-  require patch
 end

data/lib/mocha/invocation.rb

@@ -0,0 +1,77 @@
+require 'mocha/parameters_matcher'
+require 'mocha/raised_exception'
+require 'mocha/return_values'
+require 'mocha/thrown_object'
+require 'mocha/yield_parameters'
+require 'mocha/configuration'
+require 'mocha/deprecation'
+
+module Mocha
+  class Invocation
+    attr_reader :method_name, :block
+
+    def initialize(mock, method_name, *arguments, &block)
+      @mock = mock
+      @method_name = method_name
+      @arguments = arguments
+      @block = block
+      @yields = []
+      @result = nil
+    end
+
+    def call(yield_parameters = YieldParameters.new, return_values = ReturnValues.new)
+      yield_parameters.next_invocation.each do |yield_args|
+        @yields << ParametersMatcher.new(yield_args)
+        if @block
+          @block.call(*yield_args)
+        else
+          raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
+          yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
+          Deprecation.warning(
+            "Stubbed method was instructed to yield #{yield_args_description}, but no block was given by invocation: #{call_description}.",
+            ' This will raise a LocalJumpError in the future.',
+            ' Use Expectation#with_block_given to constrain this expectation to match invocations supplying a block.',
+            ' And, if necessary, add another expectation to match invocations not supplying a block.'
+          )
+        end
+      end
+      return_values.next(self)
+    end
+
+    def returned(value)
+      @result = value
+    end
+
+    def raised(exception)
+      @result = RaisedException.new(exception)
+    end
+
+    def threw(tag, value)
+      @result = ThrownObject.new(tag, value)
+    end
+
+    def arguments
+      @arguments.dup
+    end
+
+    def call_description
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description << ' { ... }' unless @block.nil?
+      description
+    end
+
+    def short_call_description
+      "#{@method_name}(#{@arguments.join(', ')})"
+    end
+
+    def result_description
+      desc = "# => #{@result.mocha_inspect}"
+      desc << " after yielding #{@yields.map(&:mocha_inspect).join(', then ')}" if @yields.any?
+      desc
+    end
+
+    def full_description
+      "\n  - #{call_description} #{result_description}"
+    end
+  end
+end

data/lib/mocha/is_a.rb

@@ -1,9 +1,7 @@
 class Object
-
   # :stopdoc:
 
   alias_method :__is_a__, :is_a?
 
   # :startdoc:
-  
 end

data/lib/mocha/logger.rb

@@ -1,15 +1,11 @@
 module Mocha
-  
   class Logger
-    
     def initialize(io)
       @io = io
     end
-    
+
     def warn(message)
       @io.puts "WARNING: #{message}"
     end
-    
   end
-  
-end
+end

data/lib/mocha/macos_version.rb

@@ -0,0 +1,5 @@
+module Mocha
+  MACOS = /darwin/.match(RUBY_PLATFORM)
+  MACOS_VERSION = MACOS && /darwin(\d+)/.match(RUBY_PLATFORM)[1].to_i
+  MACOS_MOJAVE_VERSION = 18
+end

data/lib/mocha/method_matcher.rb

@@ -1,21 +1,17 @@
 module Mocha
-  
   class MethodMatcher
-    
     attr_reader :expected_method_name
-    
+
     def initialize(expected_method_name)
       @expected_method_name = expected_method_name
     end
-    
+
     def match?(actual_method_name)
-      @expected_method_name == actual_method_name
+      @expected_method_name == actual_method_name.to_sym
     end
-    
+
     def mocha_inspect
-      "#{@expected_method_name}"
+      @expected_method_name.to_s
     end
-    
   end
-
-end
+end

data/lib/mocha/minitest.rb

@@ -0,0 +1,8 @@
+require 'mocha/integration/mini_test'
+require 'mocha/deprecation'
+
+unless Mocha::Integration::MiniTest.activate
+  Mocha::Deprecation.warning(
+    "MiniTest must be loaded *before* `require 'mocha/minitest'`."
+  )
+end