mocha 1.1.0 → 2.1.0

data/lib/mocha/class_method.rb

@@ -1,127 +0,0 @@
-require 'metaclass'
-
-module Mocha
-
-  class ClassMethod
-
-    PrependedModule = Class.new(Module)
-
-    attr_reader :stubbee, :method
-
-    def initialize(stubbee, method)
-      @stubbee = stubbee
-      @original_method, @original_visibility = nil, nil
-      @method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
-    end
-
-    def stub
-      hide_original_method
-      define_new_method
-    end
-
-    def unstub
-      remove_new_method
-      restore_original_method
-      mock.unstub(method.to_sym)
-      unless mock.any_expectations?
-        reset_mocha
-      end
-    end
-
-    def mock
-      stubbee.mocha
-    end
-
-    def reset_mocha
-      stubbee.reset_mocha
-    end
-
-    def hide_original_method
-      if method_exists?(method)
-        begin
-          @original_method = stubbee._method(method)
-          @original_visibility = :public
-          if stubbee.__metaclass__.protected_instance_methods.include?(method)
-            @original_visibility = :protected
-          elsif stubbee.__metaclass__.private_instance_methods.include?(method)
-            @original_visibility = :private
-          end
-          if @original_method && @original_method.owner == stubbee.__metaclass__
-            stubbee.__metaclass__.send(:remove_method, method)
-          end
-
-          include_prepended_module if RUBY_VERSION >= '2.0'
-        rescue NameError
-          # deal with nasties like ActiveRecord::Associations::AssociationProxy
-        end
-      end
-    end
-
-    def define_new_method
-      definition_target.class_eval(<<-CODE, __FILE__, __LINE__ + 1)
-        def #{method}(*args, &block)
-          mocha.method_missing(:#{method}, *args, &block)
-        end
-      CODE
-      if @original_visibility
-        Module.instance_method(@original_visibility).bind(definition_target).call(method)
-      end
-    end
-
-    def remove_new_method
-      definition_target.send(:remove_method, method)
-    end
-
-    def restore_original_method
-      if @original_method && @original_method.owner == stubbee.__metaclass__
-        if RUBY_VERSION < '1.9'
-          original_method = @original_method
-          stubbee.__metaclass__.send(:define_method, method) do |*args, &block|
-            original_method.call(*args, &block)
-          end
-        else
-          stubbee.__metaclass__.send(:define_method, method, @original_method)
-        end
-      end
-      if @original_visibility
-        Module.instance_method(@original_visibility).bind(stubbee.__metaclass__).call(method)
-      end
-    end
-
-    def matches?(other)
-      return false unless (other.class == self.class)
-      (stubbee.object_id == other.stubbee.object_id) and (method == other.method)
-    end
-
-    alias_method :==, :eql?
-
-    def to_s
-      "#{stubbee}.#{method}"
-    end
-
-    def method_exists?(method)
-      symbol = method.to_sym
-      __metaclass__ = stubbee.__metaclass__
-      __metaclass__.public_method_defined?(symbol) || __metaclass__.protected_method_defined?(symbol) || __metaclass__.private_method_defined?(symbol)
-    end
-
-    private
-
-    def include_prepended_module
-      possible_prepended_modules = stubbee.__metaclass__.ancestors.take_while do |mod|
-        !(Class === mod)
-      end
-
-      if possible_prepended_modules.any?
-        @definition_target = PrependedModule.new
-        stubbee.__metaclass__.__send__ :prepend, @definition_target
-      end
-    end
-
-    def definition_target
-      @definition_target ||= stubbee.__metaclass__
-    end
-
-  end
-
-end

data/lib/mocha/integration/mini_test/nothing.rb

@@ -1,19 +0,0 @@
-module Mocha
-  module Integration
-    module MiniTest
-      module Nothing
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
-          true
-        end
-
-        def self.description
-          "nothing (no MiniTest integration available)"
-        end
-
-        def self.included(mod)
-          raise "No MiniTest integration available"
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_13.rb

@@ -1,51 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version13
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('>= 1.3.0', '<= 1.3.1').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem v1.3"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            assertion_counter = AssertionCounter.new(self)
-            result = '.'
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.name
-                mocha_verify(assertion_counter)
-                @passed = true
-              rescue Exception => e
-                @passed = false
-                result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
-              ensure
-                begin
-                  self.teardown
-                rescue Exception => e
-                  result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
-                end
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_140.rb

@@ -1,51 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version140
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('1.4.0').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem v1.4.0"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            assertion_counter = AssertionCounter.new(self)
-            result = '.'
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.__name__
-                mocha_verify(assertion_counter)
-                @passed = true
-              rescue Exception => e
-                @passed = false
-                result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-              ensure
-                begin
-                  self.teardown
-                rescue Exception => e
-                  result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-                end
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_141.rb

@@ -1,62 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version141
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('1.4.1').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem v1.4.1"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap 'INFO' do
-              warn '%s#%s %.2fs' % [self.class, self.__name__,
-                (Time.now - runner.start_time)]
-              runner.status $stderr
-            end
-
-            assertion_counter = AssertionCounter.new(self)
-            result = '.'
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.__name__
-                mocha_verify(assertion_counter)
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-              ensure
-                begin
-                  self.teardown
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-                end
-                trap 'INFO', 'DEFAULT'
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_142_to_172.rb

@@ -1,62 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version142To172
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('>= 1.4.2', '<= 1.7.2').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem >= v1.4.2 and <= v1.7.2"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap 'INFO' do
-              warn '%s#%s %.2fs' % [self.class, self.__name__,
-                (Time.now - runner.start_time)]
-              runner.status $stderr
-            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-
-            assertion_counter = AssertionCounter.new(self)
-            result = '.'
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.__name__
-                mocha_verify(assertion_counter)
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-              ensure
-                begin
-                  self.teardown
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-                end
-                trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_200.rb

@@ -1,63 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version200
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('2.0.0').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem v2.0.0"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap 'INFO' do
-              time = Time.now - runner.start_time
-              warn "%s#%s %.2fs" % [self.class, self.__name__, time]
-              runner.status $stderr
-            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-
-            assertion_counter = AssertionCounter.new(self)
-            result = ""
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.__name__
-                mocha_verify(assertion_counter)
-                result = "." unless io?
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-              ensure
-                begin
-                  self.teardown
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                end
-                trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_201_to_222.rb

@@ -1,63 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version201To222
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('>= 2.0.1', '<= 2.2.2').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem >= v2.0.1 <= v2.2.2"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap 'INFO' do
-              time = runner.start_time ? Time.now - runner.start_time : 0
-              warn "%s#%s %.2fs" % [self.class, self.__name__, time]
-              runner.status $stderr
-            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-
-            assertion_counter = AssertionCounter.new(self)
-            result = ""
-            begin
-              begin
-                @passed = nil
-                self.setup
-                self.__send__ self.__name__
-                mocha_verify(assertion_counter)
-                result = "." unless io?
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-              ensure
-                begin
-                  self.teardown
-                rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                  raise
-                rescue Exception => e
-                  result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                end
-                trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_2110_to_2111.rb

@@ -1,67 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version2110To2111
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('>= 2.11.0', '<= 2.11.1').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem >= v2.11.0 <= v2.11.1"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap 'INFO' do
-              time = runner.start_time ? Time.now - runner.start_time : 0
-              warn "%s#%s %.2fs" % [self.class, self.__name__, time]
-              runner.status $stderr
-            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-
-            assertion_counter = AssertionCounter.new(self)
-            result = ""
-            begin
-              begin
-                @passed = nil
-                self.before_setup
-                self.setup
-                self.after_setup
-                self.run_test self.__name__
-                mocha_verify(assertion_counter)
-                result = "." unless io?
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-              ensure
-                %w{ before_teardown teardown after_teardown }.each do |hook|
-                  begin
-                    self.send hook
-                  rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                    raise
-                  rescue Exception => e
-                    result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                  end
-                end
-                trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mocha/integration/mini_test/version_2112_to_320.rb

@@ -1,70 +0,0 @@
-require 'mocha/integration/assertion_counter'
-require 'mocha/integration/monkey_patcher'
-require 'mocha/integration/mini_test/exception_translation'
-
-module Mocha
-  module Integration
-    module MiniTest
-      module Version2112To320
-        def self.applicable_to?(mini_test_version)
-          Gem::Requirement.new('>= 2.11.2', '<= 3.2.0').satisfied_by?(mini_test_version)
-        end
-
-        def self.description
-          "monkey patch for MiniTest gem >= v2.11.2 <= v3.2.0"
-        end
-
-        def self.included(mod)
-          MonkeyPatcher.apply(mod, RunMethodPatch)
-        end
-
-        module RunMethodPatch
-          def run runner
-            trap "INFO" do
-              runner.report.each_with_index do |msg, i|
-                warn "\n%3d) %s" % [i + 1, msg]
-              end
-              warn ''
-              time = runner.start_time ? Time.now - runner.start_time : 0
-              warn "Current Test: %s#%s %.2fs" % [self.class, self.__name__, time]
-              runner.status $stderr
-            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-            assertion_counter = AssertionCounter.new(self)
-            result = ""
-            begin
-              begin
-                @passed = nil
-                self.before_setup
-                self.setup
-                self.after_setup
-                self.run_test self.__name__
-                mocha_verify(assertion_counter)
-                result = "." unless io?
-                @passed = true
-              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                raise
-              rescue Exception => e
-                @passed = false
-                result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-              ensure
-                %w{ before_teardown teardown after_teardown }.each do |hook|
-                  begin
-                    self.send hook
-                  rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
-                    raise
-                  rescue Exception => e
-                    result = runner.puke self.class, self.__name__, Mocha::Integration::MiniTest.translate(e)
-                  end
-                end
-                trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
-              end
-            ensure
-              mocha_teardown
-            end
-            result
-          end
-        end
-      end
-    end
-  end
-end