mocha 0.12.8 → 0.13.0

data/Rakefile

@@ -2,14 +2,20 @@ require "bundler"
 Bundler::GemHelper.install_tasks
 require "bundler/setup"
 
-require 'yard'
 require 'rake/testtask'
 
 desc "Run all tests"
 task 'default' => ['test', 'test:performance']
 
-desc "Run unit & acceptance tests"
-task 'test' => ['test:units', 'test:acceptance']
+desc "Run tests"
+task 'test' do
+  if test_library = ENV['MOCHA_RUN_INTEGRATION_TESTS']
+    Rake::Task["test:integration:#{test_library}"].invoke
+  else
+    Rake::Task['test:units'].invoke
+    Rake::Task['test:acceptance'].invoke
+  end
+end
 
 namespace 'test' do
 
@@ -38,6 +44,24 @@ namespace 'test' do
     t.warning = true
   end
 
+  namespace 'integration' do
+    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.verbose = true
+      t.warning = true
+    end
+
+    desc "Run Test::Unit integration tests (intended to be run in its own process)"
+    Rake::TestTask.new('test-unit') do |t|
+      t.libs << 'test'
+      t.test_files = FileList['test/integration/test_unit_test.rb']
+      t.verbose = true
+      t.warning = true
+    end
+  end
+
   # require 'rcov/rcovtask'
   # Rcov::RcovTask.new('coverage') do |t|
   #   t.libs << 'test'
@@ -81,43 +105,27 @@ def benchmark_test_case(klass, iterations)
   end
 end
 
-desc 'Remove generated documentation'
-task 'clobber_yardoc' do
-  `rm -rf ./doc`
-end
+unless ENV["MOCHA_NO_DOCS"]
+  require 'yard'
 
-desc 'Generate documentation'
-YARD::Rake::YardocTask.new('yardoc') do |task|
-  task.options = ["--title", "Mocha #{Mocha::VERSION}", "--no-private"]
-  task.files   = [
-    'lib/mocha/api.rb',
-    'lib/mocha/mock.rb',
-    'lib/mocha/expectation.rb',
-    'lib/mocha/object.rb',
-    'lib/mocha/parameter_matchers.rb',
-    'lib/mocha/parameter_matchers',
-    'lib/mocha/state_machine.rb',
-    'lib/mocha/sequence.rb',
-    'lib/mocha/configuration.rb',
-    'lib/mocha/stubbing_error.rb',
-    'lib/mocha/unexpected_invocation.rb',
-    '-',
-    'RELEASE.rdoc',
-    'COPYING.rdoc',
-    'MIT-LICENSE.rdoc',
-    'examples/mocha.rb',
-    'examples/stubba.rb',
-    'examples/misc.rb',
-  ]
-end
+  desc 'Remove generated documentation'
+  task 'clobber_yardoc' do
+    `rm -rf ./doc`
+  end
 
-desc "Generate documentation"
-task 'generate_docs' => ['clobber_yardoc', 'yardoc']
+  desc 'Generate documentation'
+  YARD::Rake::YardocTask.new('yardoc') do |task|
+    task.options = ["--title", "Mocha #{Mocha::VERSION}"]
+  end
+
+  desc "Generate documentation"
+  task 'generate_docs' => ['clobber_yardoc', 'yardoc']
 
-desc "Publish docs to gofreerange.com/docs/mocha"
-task 'publish_docs' => 'generate_docs' do
-  path = "/home/freerange/docs/mocha"
-  system %{ssh gofreerange.com "sudo rm -fr #{path} && mkdir -p #{path}" && scp -r doc/* gofreerange.com:#{path}}
+  desc "Publish docs to gofreerange.com/docs/mocha"
+  task 'publish_docs' => 'generate_docs' do
+    path = "/home/freerange/docs/mocha"
+    system %{ssh gofreerange.com "sudo rm -fr #{path} && mkdir -p #{path}" && scp -r doc/* gofreerange.com:#{path}}
+  end
 end
 
 task 'release' => 'default' do

data/build-matrix.rb

@@ -27,13 +27,14 @@ def with_rbenv(command)
   %{export PATH="$HOME/.rbenv/bin:$PATH"; eval "$(rbenv init -)"; #{command}}
 end
 
-def run(gemfile)
+def run(gemfile, task = "test")
   ENV["BUNDLE_GEMFILE"] = gemfile
   ENV["MOCHA_OPTIONS"] = "debug"
+  ENV["MOCHA_NO_DOCS"] = "true"
   reset_bundle
   execute(
     with_rbenv("bundle install --gemfile=#{gemfile}"),
-    with_rbenv("bundle exec rake test")
+    with_rbenv("bundle exec rake #{task}")
   )
 end
 
@@ -44,14 +45,25 @@ EXCLUDED_RUBY_193_GEMFILES = [
   "gemfiles/Gemfile.minitest.1.4.2"
 ]
 
-["1.8.7-p352", "1.9.3-p125-perf"].each do |ruby_version|
+RUBY_VERSIONS = ["1.8.7-p352", "1.9.3-p125-perf"]
+
+RUBY_VERSIONS.each do |ruby_version|
+  execute("rbenv local #{ruby_version}")
+  reset_bundle
+  run("Gemfile")
+  execute("rbenv local --unset")
+end
+
+RUBY_VERSIONS.each do |ruby_version|
   execute("rbenv local #{ruby_version}")
   ["test-unit", "minitest"].each do |test_library|
     reset_bundle
-    Dir["gemfiles/Gemfile.#{test_library}.*"].each do |gemfile|
+    (Dir["gemfiles/Gemfile.#{test_library}.*"] + ["Gemfile"]).each do |gemfile|
       ruby_version_without_patch = ruby_version.split("-")[0]
       next if (ruby_version_without_patch == "1.9.3") && EXCLUDED_RUBY_193_GEMFILES.include?(gemfile)
+      next if (ruby_version_without_patch == "1.8.7") && (gemfile == "Gemfile") && (test_library == "minitest")
       p [ruby_version_without_patch, test_library, gemfile]
+      ENV['MOCHA_RUN_INTEGRATION_TESTS'] = test_library
       run(gemfile)
     end
   end

data/lib/mocha/api.rb

@@ -1,13 +1,25 @@
 require 'mocha/parameter_matchers'
+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+ or equivalent.
+  # Methods added to +Test::Unit::TestCase+, +MiniTest::Unit::TestCase+ or equivalent.
   module API
 
     include ParameterMatchers
+    include Hooks
+
+    # @private
+    def self.included(mod)
+      Object.send(:include, Mocha::ObjectMethods)
+      Module.send(:include, Mocha::ModuleMethods)
+      Class.send(:include, Mocha::ClassMethods)
+    end
 
     # Builds a new mock object
     #
@@ -159,21 +171,6 @@ module Mocha
       Mockery.instance.new_state_machine(name)
     end
 
-    # @private
-    def mocha_setup
-    end
-
-    # @private
-    def mocha_verify(assertion_counter = nil)
-      Mockery.instance.verify(assertion_counter)
-    end
-
-    # @private
-    def mocha_teardown
-      Mockery.instance.teardown
-      Mockery.reset_instance
-    end
-
   end
 
 end

data/lib/mocha/class_method.rb

@@ -66,9 +66,13 @@ module Mocha
 
     def restore_original_method
       if @original_method && @original_method.owner == stubbee.__metaclass__
-        original_method = @original_method
-        stubbee.__metaclass__.send(:define_method, method) do |*args, &block|
-          original_method.call(*args, &block)
+        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
         stubbee.__metaclass__.send(@original_visibility, method)
       end

data/lib/mocha/class_methods.rb

@@ -0,0 +1,63 @@
+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)
+        @stubba_object = klass
+      end
+
+      def mocha
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      end
+
+      def stubba_method
+        Mocha::AnyInstanceMethod
+      end
+
+      def stubba_object
+        @stubba_object
+      end
+
+      def method_exists?(method, include_public_methods = true)
+        if include_public_methods
+          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+        end
+        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
+        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
+        return false
+      end
+
+    end
+
+    # @return [Mock] a mock object which will detect calls to any instance of this class.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #
+    # @example Return false to invocation of +Product#save+ for any instance of +Product+.
+    #   Product.any_instance.stubs(:save).returns(false)
+    #   product_1 = Product.new
+    #   assert_equal false, product_1.save
+    #   product_2 = Product.new
+    #   assert_equal false, product_2.save
+    def any_instance
+      if frozen?
+        raise StubbingError.new("can't stub method on frozen object: #{mocha_inspect}.any_instance", caller)
+      end
+      @any_instance ||= AnyInstance.new(self)
+    end
+
+  end
+
+end

data/lib/mocha/debug.rb

@@ -0,0 +1,11 @@
+module Mocha
+  module Debug
+    OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) do |hash, key|
+      hash[key] = true; hash
+    end.freeze
+
+    def self.puts(message)
+      $stderr.puts(message) if OPTIONS['debug']
+    end
+  end
+end

data/lib/mocha/deprecation.rb

@@ -8,7 +8,7 @@ module Mocha
 
       def warning(message)
         @messages << message
-        $stderr.puts "Mocha deprecation warning: #{message}" unless mode == :disabled
+        $stderr.puts "\n*** Mocha deprecation warning: #{message}\n\n" unless mode == :disabled
         $stderr.puts caller.join("\n  ") if mode == :debug
       end
 

data/lib/mocha/exception_raiser.rb

@@ -7,7 +7,7 @@ module Mocha
     end
 
     def evaluate
-      raise @exception, @exception.to_s if @exception.is_a?(Module) && @exception.ancestors.include?(Interrupt)
+      raise @exception, @exception.to_s if @exception.is_a?(Module) && (@exception < Interrupt)
       raise @exception, @message if @message
       raise @exception
     end

data/lib/mocha/expectation_error.rb

@@ -1,3 +1,8 @@
 module Mocha
+  # Default exception class raised when an unexpected invocation or an unsatisfied expectation occurs.
+  #
+  # Authors of test libraries may use +Mocha::ExpectationErrorFactory+ to have Mocha raise a different exception.
+  #
+  # @see Mocha::ExpectationErrorFactory
   class ExpectationError < Exception; end
 end

data/lib/mocha/expectation_error_factory.rb

@@ -2,9 +2,28 @@ require 'mocha/backtrace_filter'
 require 'mocha/expectation_error'
 
 module Mocha
+
+  # This factory determines what class of exception should be raised when Mocha detects a test failure.
+  #
+  # This class should only be used by authors of test libraries and not by typical "users" of Mocha.
+  #
+  # For example, it is used by +Mocha::Integration::MiniTest::Adapter+ in order to have Mocha raise a +MiniTest::Assertion+ which can then be sensibly handled by +MiniTest::Unit::TestCase+.
+  #
+  # @see Mocha::Integration::MiniTest::Adapter
   class ExpectationErrorFactory
     class << self
+      # @!attribute exception_class
+      #   Determines what class of exception should be raised when Mocha detects a test failure.
+      #
+      #   This attribute may be set by authors of test libraries in order to have Mocha raise exceptions of a specific class when there is an unexpected invocation or an unsatisfied expectation.
+      #
+      #   By default a +Mocha::ExpectationError+ will be raised.
+      #
+      #   @return [Exception] class of exception to be raised when an expectation error occurs
+      #   @see Mocha::ExpectationError
       attr_accessor :exception_class
+
+      # @private
       def build(message = nil, backtrace = [])
         self.exception_class ||= ExpectationError
         exception = exception_class.new(message)

data/lib/mocha/hooks.rb

@@ -0,0 +1,43 @@
+require 'mocha/mockery'
+
+module Mocha
+
+  # Integration hooks for test library authors.
+  #
+  # The methods in this module should be called from test libraries wishing to integrate with Mocha.
+  #
+  # This module is provided as part of the +Mocha::API+ module and is therefore part of the public API, but should only be used by authors of test libraries and not by typical "users" of Mocha.
+  #
+  # Integration with Test::Unit and MiniTest are provided as part of Mocha, because they are (or were once) part of the Ruby standard library. Integration with other test libraries is not provided as *part* of Mocha, but is supported by means of the methods in this module.
+  #
+  # See the code in the +Adapter+ modules for examples of how to use the methods in this module. +Mocha::ExpectationErrorFactory+ may be used if you want +Mocha+ to raise a different type of exception.
+  #
+  # @see Mocha::Integration::TestUnit::Adapter
+  # @see Mocha::Integration::MiniTest::Adapter
+  # @see Mocha::ExpectationErrorFactory
+  # @see Mocha::API
+  module Hooks
+    # 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
+    end
+
+    # Verifies that all mock expectations have been met (only for use by authors of test libraries).
+    #
+    # 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.instance.verify(assertion_counter)
+    end
+
+    # Resets Mocha after a test (only for use by authors of test libraries).
+    #
+    # This method should be called after each individual test has finished (including after any "teardown" code).
+    def mocha_teardown
+      Mockery.instance.teardown
+      Mockery.reset_instance
+    end
+  end
+end

data/lib/mocha/integration/assertion_counter.rb

@@ -0,0 +1,13 @@
+module Mocha
+  module Integration
+    class AssertionCounter
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def increment
+        @test_case.assert(true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'mocha/api'
+require 'mocha/integration/assertion_counter'
+require 'mocha/expectation_error_factory'
+
+module Mocha
+  module Integration
+    module MiniTest
+
+      # Integrates Mocha into recent versions of MiniTest.
+      #
+      # See the source code for an example of how to integrate Mocha into a test library.
+      module Adapter
+        include Mocha::API
+
+        # @private
+        def self.applicable_to?(mini_test_version)
+          Gem::Requirement.new('>= 3.3.0').satisfied_by?(mini_test_version)
+        end
+
+        # @private
+        def self.description
+          "adapter for MiniTest gem >= v3.3.0"
+        end
+
+        # @private
+        def self.included(mod)
+          Mocha::ExpectationErrorFactory.exception_class = ::MiniTest::Assertion
+        end
+
+        # @private
+        def before_setup
+          mocha_setup
+          super
+        end
+
+        # @private
+        def before_teardown
+          return unless passed?
+          assertion_counter = Integration::AssertionCounter.new(self)
+          mocha_verify(assertion_counter)
+        ensure
+          super
+        end
+
+        # @private
+        def after_teardown
+          super
+          mocha_teardown
+        end
+      end
+    end
+  end
+end
+

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

@@ -1,20 +1,14 @@
 require 'mocha/expectation_error'
 
 module Mocha
-
   module Integration
-
     module MiniTest
-
       def self.translate(exception)
         return exception unless exception.kind_of?(::Mocha::ExpectationError)
         translated_exception = ::MiniTest::Assertion.new(exception.message)
         translated_exception.set_backtrace(exception.backtrace)
         translated_exception
       end
-
     end
-
   end
-
 end

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

@@ -0,0 +1,19 @@
+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,44 +1,51 @@
-require 'mocha/integration/mini_test/assertion_counter'
+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)
-          $stderr.puts "Monkey patching MiniTest v1.3" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run runner
-          assertion_counter = AssertionCounter.new(self)
-          result = '.'
-          begin
+
+        module RunMethodPatch
+          def run runner
+            assertion_counter = AssertionCounter.new(self)
+            result = '.'
             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
+                @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
-          ensure
-            mocha_teardown
+            result
           end
-          result
         end
       end
-
     end
-
   end
-
 end

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

@@ -1,45 +1,51 @@
-require 'mocha/integration/mini_test/assertion_counter'
-require 'mocha/expectation_error'
+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)
-          $stderr.puts "Monkey patching MiniTest v1.4.0" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run runner
-          assertion_counter = AssertionCounter.new(self)
-          result = '.'
-          begin
+
+        module RunMethodPatch
+          def run runner
+            assertion_counter = AssertionCounter.new(self)
+            result = '.'
             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
+                @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
-          ensure
-            mocha_teardown
+            result
           end
-          result
         end
       end
-
     end
-
   end
-
 end