mocha 0.9.2 → 0.9.3

data/README

@@ -2,7 +2,7 @@
 
 Mocha is a library for mocking and stubbing using a syntax like that of JMock[http://www.jmock.org].
 
-It can be used with many testing frameworks e.g. Test::Unit[http://www.ruby-doc.org/core/classes/Test/Unit.html], RSpec[http://rspec.info/], test/spec[http://chneukirchen.org/repos/testspec/README], expectations[http://expectations.rubyforge.org/], Dust[http://dust.rubyforge.org/] and even JtestR[http://jtestr.codehaus.org/].
+It can be used with many testing frameworks e.g. Test::Unit[http://www.ruby-doc.org/core/classes/Test/Unit.html], RSpec[http://rspec.info/], test/spec[http://chneukirchen.org/repos/testspec/README], expectations[http://expectations.rubyforge.org/], Dust[http://dust.rubyforge.org/], MiniTest[http://rubyforge.org/projects/bfts] and even JtestR[http://jtestr.codehaus.org/].
 
 Mocha provides a unified, simple and readable syntax for both traditional mocking and partial mocking.
 
@@ -26,7 +26,7 @@ Or download Mocha from here - http://rubyforge.org/projects/mocha
 * Traditional mocking - {Star Trek Example}[link:examples/mocha.html]
 * Setting expectations on real classes - {Order Example}[link:examples/stubba.html]
 * More examples on {Floehopper's Blog}[http://blog.floehopper.org]
-* {Mailing List Archives}[http://rubyforge.org/pipermail/mocha-developer/]
+* {Mailing List Archives}[http://groups.google.com/group/mocha-developer]
 
 == License
 

data/RELEASE

@@ -1,3 +1,9 @@
+= 0.9.3 (8219bb2d2881c8529c93fc21e97a11d01203c759)
+* Added support for MiniTest thanks to sprsquish.
+* Fixed a possible bug with some of the non-default Configuration options relating to the argument to Object#respond_to?
+* As per Jay Fields recommendations [1] and with further impetus from a talk at Ruby Manor, any methods added to core classes are now added by including a module. This means that Mocha is a better citizen of the Ruby world and it's behaviour is more easily extended. [1] http://blog.jayfields.com/2008/07/ruby-underuse-of-modules.html & http://blog.jayfields.com/2008/07/ruby-redefine-method-behavior.html
+* Removed deprecated gem autorequire.
+
 = 0.9.2 (r355)
 * Improved documentation to address [#22530] 'Mock methods with multiple return values not possible?'
 * respond_with parameter matcher was not available in tests.

data/Rakefile

@@ -5,7 +5,7 @@ require 'rake/testtask'
 require 'rake/contrib/sshpublisher'
 
 module Mocha
-  VERSION = "0.9.2"
+  VERSION = "0.9.3"
 end
 
 desc "Run all tests"
@@ -148,7 +148,6 @@ specification = Gem::Specification.new do |s|
   s.extra_rdoc_files = ['README', 'COPYING']
   s.rdoc_options << '--title' << 'Mocha' << '--main' << 'README' << '--line-numbers'
                          
-  s.autorequire = 'mocha'
   s.add_dependency('rake')
   s.files = FileList['{lib,test,examples}/**/*.rb', '[A-Z]*'].exclude('TODO').to_a
 end

data/lib/mocha.rb

@@ -1,20 +1,47 @@
 require 'mocha_standalone'
-require 'mocha/test_case_adapter'
 require 'mocha/configuration'
 
+if RUBY_VERSION < '1.9'
+  begin
+    require 'rubygems'
+    begin
+      gem 'minitest', '>=1.3'
+      require 'minitest/unit'
+    rescue Gem::LoadError
+      # Compatible version of MiniTest gem not available
+    end
+  rescue LoadError
+    # RubyGems not available
+  end
+else
+  begin
+    require 'minitest/unit'
+  rescue LoadError
+    # MiniTest not available
+  end
+end
+
+if defined?(MiniTest)
+  require 'mocha/mini_test_adapter'
+
+  module MiniTest
+    class Unit
+      class TestCase
+        include Mocha::Standalone
+        include Mocha::MiniTestCaseAdapter
+      end
+    end
+  end
+end
+
+require 'mocha/test_case_adapter'
 require 'test/unit/testcase'
 
 module Test
-
   module Unit
-
     class TestCase
-  
       include Mocha::Standalone
       include Mocha::TestCaseAdapter
-      
     end
-
   end
-
-end
+end

data/lib/mocha/inspect.rb

@@ -1,39 +1,67 @@
 require 'date'
 
-class Object
-  def mocha_inspect
-    address = self.__id__ * 2
-    address += 0x100000000 if address < 0
-    inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+module Mocha
+  
+  module ObjectMethods
+    def mocha_inspect
+      address = self.__id__ * 2
+      address += 0x100000000 if address < 0
+      inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+    end
+  end
+  
+  module StringMethods
+    def mocha_inspect
+      inspect.gsub(/\"/, "'")
+    end
+  end
+  
+  module ArrayMethods
+    def mocha_inspect
+      "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+    end
+  end
+  
+  module HashMethods
+    def mocha_inspect
+      "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+    end
   end
+  
+  module TimeMethods
+    def mocha_inspect
+      "#{inspect} (#{to_f} secs)"
+    end
+  end
+  
+  module DateMethods
+    def mocha_inspect
+      to_s
+    end
+  end
+  
+end
+
+class Object
+  include Mocha::ObjectMethods
 end
 
 class String
-  def mocha_inspect
-    inspect.gsub(/\"/, "'")
-  end
+  include Mocha::StringMethods
 end
 
 class Array
-  def mocha_inspect
-    "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
-  end
+  include Mocha::ArrayMethods
 end
 
 class Hash
-  def mocha_inspect
-    "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
-  end
+  include Mocha::HashMethods
 end
 
 class Time
-  def mocha_inspect
-    "#{inspect} (#{to_f} secs)"
-  end
+  include Mocha::TimeMethods
 end
 
 class Date
-  def mocha_inspect
-    to_s
-  end
+  include Mocha::DateMethods
 end

data/lib/mocha/metaclass.rb

@@ -1,7 +1,13 @@
-class Object
+module Mocha
   
-  def __metaclass__
-    class << self; self; end
+  module ObjectMethods
+    def __metaclass__
+      class << self; self; end
+    end
   end
+  
+end
 
+class Object
+  include Mocha::ObjectMethods
 end

data/lib/mocha/mini_test_adapter.rb

@@ -0,0 +1,50 @@
+module Mocha
+
+  module MiniTestCaseAdapter
+
+    class AssertionCounter
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def increment
+        @test_case._assertions += 1
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+
+        alias_method :run_before_mocha_mini_test_adapter, :run
+
+        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, e)
+            ensure
+              begin
+                self.teardown
+              rescue Exception => e
+                result = runner.puke(self.class, self.name, e)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result
+        end
+
+      end
+    end
+
+  end
+end

data/lib/mocha/object.rb

@@ -4,131 +4,147 @@ require 'mocha/class_method'
 require 'mocha/module_method'
 require 'mocha/any_instance_method'
 
-# Methods added all objects to allow mocking and stubbing on real objects.
-#
-# Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
-class Object
+module Mocha
   
-  def mocha # :nodoc:
-    @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
-  end
+  # Methods added all objects to allow mocking and stubbing on real objects.
+  #
+  # Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
+  module ObjectMethods
   
-  def reset_mocha # :nodoc:
-    @mocha = nil
-  end
+    def mocha # :nodoc:
+      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+    end
   
-  def stubba_method # :nodoc:
-    Mocha::InstanceMethod
-  end
+    def reset_mocha # :nodoc:
+      @mocha = nil
+    end
   
-  def stubba_object # :nodoc:
-    self
-  end
+    def stubba_method # :nodoc:
+      Mocha::InstanceMethod
+    end
   
-  # :call-seq: expects(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.expects(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def expects(symbol)
-    mockery = Mocha::Mockery.instance
-    mockery.on_stubbing(self, symbol)
-    method = stubba_method.new(stubba_object, symbol)
-    mockery.stubba.stub(method)
-    mocha.expects(symbol, caller)
-  end
+    def stubba_object # :nodoc:
+      self
+    end
   
-  # :call-seq: stubs(symbol) -> expectation
-  #
-  # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
-  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
-  #   product = Product.new
-  #   product.stubs(:save).returns(true)
-  #   assert_equal false, product.save
-  #
-  # The original implementation of <tt>Product#save</tt> is replaced temporarily.
-  #
-  # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def stubs(symbol)
-    mockery = Mocha::Mockery.instance
-    mockery.on_stubbing(self, symbol)
-    method = stubba_method.new(stubba_object, symbol)
-    mockery.stubba.stub(method)
-    mocha.stubs(symbol, caller)
-  end
+    # :call-seq: expects(symbol) -> expectation
+    #
+    # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   product = Product.new
+    #   product.expects(:save).returns(true)
+    #   assert_equal false, product.save
+    #
+    # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+    #
+    # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+    def expects(symbol)
+      mockery = Mocha::Mockery.instance
+      mockery.on_stubbing(self, symbol)
+      method = stubba_method.new(stubba_object, symbol)
+      mockery.stubba.stub(method)
+      mocha.expects(symbol, caller)
+    end
   
-  def method_exists?(method, include_public_methods = true)
-    if include_public_methods
-      return true if public_methods(include_superclass_methods = true).include?(method)
-      return true if respond_to?(method)
+    # :call-seq: stubs(symbol) -> expectation
+    #
+    # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   product = Product.new
+    #   product.stubs(:save).returns(true)
+    #   assert_equal false, product.save
+    #
+    # The original implementation of <tt>Product#save</tt> is replaced temporarily.
+    #
+    # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
+    def stubs(symbol)
+      mockery = Mocha::Mockery.instance
+      mockery.on_stubbing(self, symbol)
+      method = stubba_method.new(stubba_object, symbol)
+      mockery.stubba.stub(method)
+      mocha.stubs(symbol, caller)
     end
-    return true if protected_methods(include_superclass_methods = true).include?(method)
-    return true if private_methods(include_superclass_methods = true).include?(method)
-    return false
-  end
   
-end
-
-class Module # :nodoc:
+    def method_exists?(method, include_public_methods = true) # :nodoc:
+      if include_public_methods
+        return true if public_methods(include_superclass_methods = true).include?(method)
+        return true if respond_to?(method.to_sym)
+      end
+      return true if protected_methods(include_superclass_methods = true).include?(method)
+      return true if private_methods(include_superclass_methods = true).include?(method)
+      return false
+    end
   
-  def stubba_method
-    Mocha::ModuleMethod
   end
-    
-end
-  
-class Class
   
-  def stubba_method # :nodoc:
-    Mocha::ClassMethod
-  end
-
-  class AnyInstance # :nodoc:
+  module ModuleMethods # :nodoc:
     
-    def initialize(klass)
-      @stubba_object = klass
+    def stubba_method
+      Mocha::ModuleMethod
     end
     
-    def mocha
-      @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+  end
+  
+  # Methods added all classes to allow mocking and stubbing on real objects.
+  module ClassMethods
+    
+    def stubba_method # :nodoc:
+      Mocha::ClassMethod
     end
 
-    def stubba_method
-      Mocha::AnyInstanceMethod
-    end
+    class AnyInstance # :nodoc:
     
-    def stubba_object
-      @stubba_object
-    end
+      def initialize(klass)
+        @stubba_object = klass
+      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)
+      def mocha
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      end
+
+      def stubba_method
+        Mocha::AnyInstanceMethod
       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
+      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
+  
+    # :call-seq: any_instance -> mock object
+    #
+    # Returns a mock object which will detect calls to any instance of this class.
+    #   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
+      @any_instance ||= AnyInstance.new(self)
+    end
   
-  # :call-seq: any_instance -> mock object
-  #
-  # Returns a mock object which will detect calls to any instance of this class.
-  #   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
-    @any_instance ||= AnyInstance.new(self)
   end
   
 end
 
+class Object # :nodoc:
+  include Mocha::ObjectMethods
+end
+
+class Module # :nodoc:
+  include Mocha::ModuleMethods
+end
+
+class Class # :nodoc:
+  include Mocha::ClassMethods
+end

data/lib/mocha/parameter_matchers/object.rb

@@ -1,9 +1,15 @@
 require 'mocha/parameter_matchers/equals'
 
-class Object
+module Mocha
   
-  def to_matcher # :nodoc:
-    Mocha::ParameterMatchers::Equals.new(self)
+  module ObjectMethods
+    def to_matcher # :nodoc:
+      Mocha::ParameterMatchers::Equals.new(self)
+    end
   end
   
 end
+
+class Object
+  include Mocha::ObjectMethods
+end

data/test/acceptance/bug_21465_test.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), "acceptance_test_helper")
 require 'mocha'
 
-class Bug21563Test < Test::Unit::TestCase
+class Bug21465Test < Test::Unit::TestCase
   
   include AcceptanceTest
   

data/test/acceptance/minitest_test.rb

@@ -0,0 +1,130 @@
+require File.join(File.dirname(__FILE__), "acceptance_test_helper")
+require 'mocha'
+
+if defined?(MiniTest)
+
+  class MiniTestSampleTest < MiniTest::Unit::TestCase
+  
+    def test_mocha_with_fulfilled_expectation
+      mockee = mock()
+      mockee.expects(:blah)
+      mockee.blah
+    end
+  
+    def test_mocha_with_unfulfilled_expectation
+      mockee = mock()
+      mockee.expects(:blah)
+    end
+  
+    def test_mocha_with_unexpected_invocation
+      mockee = mock()
+      mockee.blah
+    end
+  
+    def test_stubba_with_fulfilled_expectation
+      stubbee = Class.new { define_method(:blah) {} }.new
+      stubbee.expects(:blah)
+      stubbee.blah
+    end
+  
+    def test_stubba_with_unfulfilled_expectation
+      stubbee = Class.new { define_method(:blah) {} }.new
+      stubbee.expects(:blah)
+    end
+  
+    def test_mocha_with_matching_parameter
+      mockee = mock()
+      mockee.expects(:blah).with(has_key(:wibble))
+      mockee.blah(:wibble => 1)
+    end
+  
+    def test_mocha_with_non_matching_parameter
+      mockee = mock()
+      mockee.expects(:blah).with(has_key(:wibble))
+      mockee.blah(:wobble => 2)
+    end
+  
+  end
+
+  class MiniTestAdapterTest < Test::Unit::TestCase
+  
+    def setup
+      @output = StringIO.new
+      MiniTest::Unit.output = @output
+      @runner = MiniTest::Unit.new
+    end
+  
+    attr_reader :runner
+  
+    def test_should_pass_mocha_test
+      runner.run(%w(-n test_mocha_with_fulfilled_expectation))
+    
+      assert_equal 0, runner.errors
+      assert_equal 1, runner.assertion_count
+    end
+
+    def test_should_fail_mocha_test_due_to_unfulfilled_expectation
+      runner.run(%w(-n test_mocha_with_unfulfilled_expectation))
+    
+      assert_equal 1, runner.errors
+      assert_equal 1, runner.assertion_count
+      assert_not_all_expectation_were_satisfied
+    end
+  
+    def test_should_fail_mocha_test_due_to_unexpected_invocation
+      runner.run(%w(-n test_mocha_with_unexpected_invocation))
+    
+      assert_equal 1, runner.errors
+      assert_equal 0, runner.assertion_count
+      assert_unexpected_invocation
+    end
+  
+    def test_should_pass_stubba_test
+      runner.run(%w(-n test_stubba_with_fulfilled_expectation))
+    
+      assert_equal 0, runner.errors
+      assert_equal 1, runner.assertion_count
+    end
+  
+    def test_should_fail_stubba_test_due_to_unfulfilled_expectation
+      runner.run(%w(-n test_stubba_with_unfulfilled_expectation))
+    
+      assert_equal 1, runner.errors
+      assert_equal 1, runner.assertion_count
+      assert_match Regexp.new('not all expectations were satisfied'), output
+    end
+  
+    def test_should_pass_mocha_test_with_matching_parameter
+      runner.run(%w(-n test_mocha_with_matching_parameter))
+    
+      assert_equal 0, runner.errors
+      assert_equal 1, runner.assertion_count
+    end
+  
+    def test_should_fail_mocha_test_with_non_matching_parameter
+      runner.run(%w(-n test_mocha_with_non_matching_parameter))
+    
+      assert_equal 1, runner.errors
+      assert_unexpected_invocation
+    end
+  
+    private
+  
+    def output
+      @output.rewind
+      @output.read
+    end
+  
+    def assert_unexpected_invocation
+      assert_match Regexp.new('unexpected invocation'), output, "MiniTest output:\n#{output}"
+    end
+  
+    def assert_not_all_expectation_were_satisfied
+      assert_match Regexp.new('not all expectations were satisfied'), output, "MiniTest output:\n#{output}"
+    end
+  
+  end
+  
+else
+  warn "MiniTest is not available, so MiniTestAdapterTest has not been run."
+end

data/test/acceptance/stubbing_non_existent_class_method_test.rb

@@ -70,7 +70,9 @@ class StubbingNonExistentClassMethodTest < Test::Unit::TestCase
     Mocha::Configuration.prevent(:stubbing_non_existent_method)
     klass = Class.new do
       class << self
-        def respond_to?(method, include_private = false); true; end
+        def respond_to?(method, include_private = false)
+          (method == :method_to_which_class_responds)
+        end
       end
     end
     test_result = run_test do

data/test/acceptance/stubbing_non_existent_instance_method_test.rb

@@ -68,7 +68,9 @@ class StubbingNonExistentInstanceMethodTest < Test::Unit::TestCase
   def test_should_allow_stubbing_method_to_which_instance_responds
     Mocha::Configuration.prevent(:stubbing_non_existent_method)
     klass = Class.new do
-      def respond_to?(method, include_private = false); true; end
+      def respond_to?(method, include_private = false)
+        (method == :method_to_which_instance_responds)
+      end
     end
     instance = klass.new
     test_result = run_test do

data/test/acceptance/stubbing_non_public_class_method_test.rb

@@ -149,7 +149,9 @@ class StubbingNonPublicClassMethodTest < Test::Unit::TestCase
     Mocha::Configuration.prevent(:stubbing_non_public_method)
     klass = Class.new do
       class << self
-        def respond_to?(method, include_private_methods = false); true; end
+        def respond_to?(method, include_private_methods = false)
+          (method == :method_to_which_class_responds)
+        end
       end
     end
     test_result = run_test do

data/test/acceptance/stubbing_non_public_instance_method_test.rb

@@ -130,7 +130,9 @@ class StubbingNonPublicInstanceMethodTest < Test::Unit::TestCase
   def test_should_allow_stubbing_method_to_which_instance_responds
     Mocha::Configuration.prevent(:stubbing_non_public_method)
     instance = Class.new do
-      def respond_to?(method, include_private_methods = false); true; end
+      def respond_to?(method, include_private_methods = false)
+        (method == :method_to_which_instance_responds)
+      end
     end.new
     test_result = run_test do
       instance.stubs(:method_to_which_instance_responds)

data/test/method_definer.rb

@@ -1,18 +1,24 @@
 require 'mocha/metaclass'
 
-class Object
+module Mocha
   
-  def define_instance_method(method_symbol, &block)
-    __metaclass__.send(:define_method, method_symbol, block)
-  end
+  module ObjectMethods
+    def define_instance_method(method_symbol, &block)
+      __metaclass__.send(:define_method, method_symbol, block)
+    end
 
-  def replace_instance_method(method_symbol, &block)
-    raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless self.respond_to?(method_symbol)
-    define_instance_method(method_symbol, &block)
-  end
+    def replace_instance_method(method_symbol, &block)
+      raise "Cannot replace #{method_symbol} as #{self} does not respond to it." unless self.respond_to?(method_symbol)
+      define_instance_method(method_symbol, &block)
+    end
 
-  def define_instance_accessor(*symbols)
-    symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
+    def define_instance_accessor(*symbols)
+      symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
+    end
   end
+  
+end
 
+class Object
+  include Mocha::ObjectMethods
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: mocha
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - James Mead
-autorequire: mocha
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-11-03 00:00:00 +00:00
+date: 2008-11-27 00:00:00 +00:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,6 +51,7 @@ files:
 - lib/mocha/logger.rb
 - lib/mocha/metaclass.rb
 - lib/mocha/method_matcher.rb
+- lib/mocha/mini_test_adapter.rb
 - lib/mocha/mock.rb
 - lib/mocha/mockery.rb
 - lib/mocha/module_method.rb
@@ -100,6 +101,7 @@ files:
 - test/acceptance/bug_21563_test.rb
 - test/acceptance/expected_invocation_count_test.rb
 - test/acceptance/failure_messages_test.rb
+- test/acceptance/minitest_test.rb
 - test/acceptance/mocha_example_test.rb
 - test/acceptance/mocha_test_result_test.rb
 - test/acceptance/mock_test.rb