mocha 0.10.5 → 0.11.0

data/test/acceptance/throw_test.rb

@@ -42,4 +42,4 @@ class ThrowTest < Test::Unit::TestCase
     assert_passed(test_result)
   end
 
-end
+end

data/test/deprecation_disabler.rb

@@ -12,4 +12,4 @@ module DeprecationDisabler
     end
   end
 
-end
+end

data/test/execution_point.rb

@@ -1,20 +1,20 @@
 class ExecutionPoint
-  
+
   attr_reader :backtrace
 
   def self.current
     new(caller)
   end
-  
+
   def initialize(backtrace)
     @backtrace = backtrace
   end
-  
+
   def file_name
     return "unknown" unless @backtrace && @backtrace.first
     /\A(.*?):\d+/.match(@backtrace.first)[1]
   end
-  
+
   def line_number
     return "unknown" unless @backtrace && @backtrace.first
     Integer(/\A.*?:(\d+)/.match(@backtrace.first)[1])
@@ -24,13 +24,13 @@ class ExecutionPoint
     return false unless other.is_a?(ExecutionPoint)
     (file_name == other.file_name) and (line_number == other.line_number)
   end
-  
+
   def to_s
     "file: #{file_name}; line: #{line_number}"
   end
-  
+
   def inspect
     to_s
   end
-  
+
 end

data/test/method_definer.rb

@@ -21,4 +21,4 @@ end
 
 class Object
   include Mocha::ObjectMethods
-end
+end

data/test/mini_test_result.rb

@@ -3,30 +3,30 @@ require 'test/unit/testcase'
 require 'minitest/unit'
 
 class MiniTestResult
-  
+
   FAILURE_PATTERN = %r{(Failure)\:\n([^\(]+)\(([^\)]+)\) \[([^\]]+)\]\:\n(.*)\n}m
   ERROR_PATTERN   = %r{(Error)\:\n([^\(]+)\(([^\)]+)\)\:\n(.+?)\n}m
-  
+
   def self.parse_failure(raw)
     matches = FAILURE_PATTERN.match(raw)
     return nil unless matches
     Failure.new(matches[2], matches[3], [matches[4]], matches[5])
   end
-  
+
   def self.parse_error(raw)
     matches = ERROR_PATTERN.match(raw)
     return nil unless matches
     backtrace = raw.gsub(ERROR_PATTERN, '').split("\n").map(&:strip)
     Error.new(matches[2], matches[3], matches[4], backtrace)
   end
-  
+
   class Failure
     attr_reader :method, :test_case, :location, :message
     def initialize(method, test_case, location, message)
       @method, @test_case, @location, @message = method, test_case, location, message
     end
   end
-  
+
   class Error
     class Exception
       attr_reader :message, :backtrace
@@ -34,50 +34,50 @@ class MiniTestResult
         @message, @backtrace = message, location
       end
     end
-    
+
     attr_reader :method, :test_case, :exception
     def initialize(method, test_case, message, backtrace)
       @method, @test_case, @exception = method, test_case, Exception.new(message, backtrace)
     end
   end
-  
-  def initialize(runner, test)
-    @runner, @test = runner, test
+
+  def initialize(runner, tests)
+    @runner, @tests = runner, tests
   end
-  
+
   def failure_count
     @runner.failures
   end
-  
+
   def assertion_count
-    @test._assertions
+    @tests.inject(0) { |total, test| total + test._assertions }
   end
-  
+
   def error_count
     @runner.errors
   end
-  
+
   def passed?
-    @test.passed?
+    @tests.all?(&:passed?)
   end
-  
+
   def failures
     @runner.report.map { |puked| MiniTestResult.parse_failure(puked) }.compact
   end
-  
+
   def errors
     @runner.report.map { |puked| MiniTestResult.parse_error(puked) }.compact
   end
-  
+
   def failure_messages
     failures.map(&:message)
   end
-  
+
   def failure_message_lines
     failure_messages.map { |message| message.split("\n") }.flatten
   end
-  
+
   def error_messages
     errors.map { |e| e.exception.message }
   end
-end
+end

data/test/simple_counter.rb

@@ -1,13 +1,13 @@
 class SimpleCounter
-  
+
   attr_reader :count
-  
+
   def initialize
     @count = 0
   end
-  
+
   def increment
     @count += 1
   end
-  
-end
+
+end

data/test/test_helper.rb

@@ -8,4 +8,4 @@ $:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
 
-require 'test/unit'
+require 'test/unit'

data/test/test_runner.rb

@@ -4,40 +4,38 @@ if defined?(MiniTest)
   require 'mocha/integration/mini_test'
   require File.expand_path('../mini_test_result', __FILE__)
 else
-  require 'test/unit/testresult'
+  require File.expand_path('../test_unit_result', __FILE__)
 end
 
 module TestRunner
-  def run_as_test(test_result = nil, &block)
-    test_class = Class.new(Test::Unit::TestCase) do
-      define_method(:test_me, &block)
+  def run_as_test(&block)
+    run_as_tests(block)
+  end
+
+  def run_as_tests(*procs)
+    tests = procs.map do |proc|
+      test_class = Class.new(Test::Unit::TestCase) do
+        define_method(:test_me, proc)
+      end
+      test_class.new(:test_me)
     end
-    test = test_class.new(:test_me)
-    
+
     if defined?(Test::Unit::TestResult)
-      test_result ||= Test::Unit::TestResult.new
-      test.run(test_result) {}
-      class << test_result
-        attr_reader :failures, :errors
-        def failure_messages
-          failures.map { |failure| failure.message }
-        end
-        def failure_message_lines
-          failure_messages.map { |message| message.split("\n") }.flatten
-        end
-        def error_messages
-          errors.map { |error| error.message }
-        end
+      test_result = TestUnitResult.build_test_result
+      tests.each do |test|
+        test.run(test_result) {}
       end
     else
       runner = MiniTest::Unit.new
-      test.run(runner)
-      test_result = MiniTestResult.new(runner, test)
+      tests.each do |test|
+        test.run(runner)
+      end
+      test_result = MiniTestResult.new(runner, tests)
     end
-    
+
     test_result
   end
-  
+
   def assert_passed(test_result)
     flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
     flunk "Test failed unexpectedly with message: #{test_result.errors}" if test_result.error_count > 0
@@ -47,4 +45,4 @@ module TestRunner
     flunk "Test passed unexpectedly" if test_result.passed?
   end
 
-end
+end

data/test/test_unit_result.rb

@@ -0,0 +1,20 @@
+require 'test/unit/testresult'
+
+class TestUnitResult
+  def self.build_test_result
+    test_result = Test::Unit::TestResult.new
+    class << test_result
+      attr_reader :failures, :errors
+      def failure_messages
+        failures.map { |failure| failure.message }
+      end
+      def failure_message_lines
+        failure_messages.map { |message| message.split("\n") }.flatten
+      end
+      def error_messages
+        errors.map { |error| error.message }
+      end
+    end
+    test_result
+  end
+end

data/test/unit/any_instance_method_test.rb

@@ -4,70 +4,66 @@ require 'mocha/mock'
 require 'mocha/any_instance_method'
 
 class AnyInstanceMethodTest < Test::Unit::TestCase
-  
+
   include Mocha
-  
+
   def test_should_hide_original_method
     klass = Class.new { def method_x; end }
     method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    
+
     method.hide_original_method
-    
-    assert klass.method_defined?(hidden_method_x)
+
+    assert_equal false, klass.method_defined?(:method_x)
   end
-  
-  def test_should_not_hide_original_method_if_it_is_not_defined
+
+  def test_should_not_raise_error_hiding_method_that_isnt_defined
     klass = Class.new
     method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    
-    method.hide_original_method
-    
-    assert_equal false, klass.method_defined?(hidden_method_x)
+
+    assert_nothing_raised { method.hide_original_method }
   end
-  
+
   def test_should_define_a_new_method
-    klass = Class.new { def method_x; end } 
+    klass = Class.new { def method_x; end }
     method = AnyInstanceMethod.new(klass, :method_x)
     mocha = build_mock
     mocha.expects(:method_x).with(:param1, :param2).returns(:result)
     any_instance = Object.new
     any_instance.define_instance_method(:mocha) { mocha }
     klass.define_instance_method(:any_instance) { any_instance }
-    
+
     method.hide_original_method
     method.define_new_method
 
     instance = klass.new
     result = instance.method_x(:param1, :param2)
-        
+
     assert_equal :result, result
     assert mocha.__verified__?
   end
 
   def test_should_restore_original_method
-    klass = Class.new { def method_x; end }
+    klass = Class.new { def method_x; :original_result; end }
     method = AnyInstanceMethod.new(klass, :method_x)
-    hidden_method_x = method.hidden_method.to_sym
-    klass.send(:define_method, hidden_method_x, Proc.new { :original_result }) 
-    
+
+    method.hide_original_method
+    method.define_new_method
     method.remove_new_method
     method.restore_original_method
-    
+
     instance = klass.new
-    assert_equal :original_result, instance.method_x 
-    assert !klass.method_defined?(hidden_method_x)
+    assert instance.respond_to?(:method_x)
+    assert_equal :original_result, instance.method_x
   end
 
-  def test_should_not_restore_original_method_if_hidden_method_not_defined
+  def test_should_not_restore_original_method_if_none_was_defined_in_first_place
     klass = Class.new { def method_x; :new_result; end }
     method = AnyInstanceMethod.new(klass, :method_x)
-    
+
     method.restore_original_method
-    
+
     instance = klass.new
-    assert_equal :new_result, instance.method_x 
+    assert_equal :new_result, instance.method_x
   end
 
   def test_should_call_remove_new_method
@@ -80,9 +76,9 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     method.replace_instance_method(:restore_original_method) { }
     method.define_instance_accessor(:remove_called)
     method.replace_instance_method(:remove_new_method) { self.remove_called = true }
-    
+
     method.unstub
-    
+
     assert method.remove_called
   end
 
@@ -96,9 +92,9 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     method.replace_instance_method(:remove_new_method) { }
     method.define_instance_accessor(:restore_called)
     method.replace_instance_method(:restore_original_method) { self.restore_called = true }
-    
+
     method.unstub
-    
+
     assert method.restore_called
   end
 

data/test/unit/array_inspect_test.rb

@@ -2,15 +2,15 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/inspect'
 
 class ArrayInspectTest < Test::Unit::TestCase
-  
+
   def test_should_use_inspect
     array = [1, 2]
     assert_equal array.inspect, array.mocha_inspect
   end
-  
+
   def test_should_use_mocha_inspect_on_each_item
     array = [1, 2, "chris"]
     assert_equal "[1, 2, 'chris']", array.mocha_inspect
   end
-  
+
 end

data/test/unit/backtrace_filter_test.rb

@@ -2,9 +2,9 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/backtrace_filter'
 
 class BacktraceFilterTest < Test::Unit::TestCase
-  
+
   include Mocha
-  
+
   def test_should_exclude_mocha_locations_from_backtrace
     mocha_lib = "/username/workspace/mocha_wibble/lib/"
     backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
@@ -15,5 +15,5 @@ class BacktraceFilterTest < Test::Unit::TestCase
   def test_should_determine_path_for_mocha_lib_directory
     assert_match Regexp.new("/lib/$"), BacktraceFilter::LIB_DIRECTORY
   end
-  
+
 end

data/test/unit/cardinality_test.rb

@@ -2,9 +2,9 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/cardinality'
 
 class CardinalityTest < Test::Unit::TestCase
-  
+
   include Mocha
-  
+
   def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
     cardinality = Cardinality.new(2, 3)
     assert cardinality.invocations_allowed?(0)
@@ -12,7 +12,7 @@ class CardinalityTest < Test::Unit::TestCase
     assert cardinality.invocations_allowed?(2)
     assert !cardinality.invocations_allowed?(3)
   end
-  
+
   def test_should_be_satisfied_if_invocations_so_far_have_reached_required_threshold
     cardinality = Cardinality.new(2, 3)
     assert !cardinality.satisfied?(0)
@@ -20,27 +20,27 @@ class CardinalityTest < Test::Unit::TestCase
     assert cardinality.satisfied?(2)
     assert cardinality.satisfied?(3)
   end
-  
+
   def test_should_describe_cardinality
     assert_equal 'allowed any number of times', Cardinality.at_least(0).mocha_inspect
-    
+
     assert_equal 'expected at most once', Cardinality.at_most(1).mocha_inspect
     assert_equal 'expected at most twice', Cardinality.at_most(2).mocha_inspect
     assert_equal 'expected at most 3 times', Cardinality.at_most(3).mocha_inspect
-    
+
     assert_equal 'expected at least once', Cardinality.at_least(1).mocha_inspect
     assert_equal 'expected at least twice', Cardinality.at_least(2).mocha_inspect
     assert_equal 'expected at least 3 times', Cardinality.at_least(3).mocha_inspect
-    
+
     assert_equal 'expected never', Cardinality.exactly(0).mocha_inspect
     assert_equal 'expected exactly once', Cardinality.exactly(1).mocha_inspect
     assert_equal 'expected exactly twice', Cardinality.exactly(2).mocha_inspect
     assert_equal 'expected exactly 3 times', Cardinality.times(3).mocha_inspect
-    
+
     assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).mocha_inspect
     assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).mocha_inspect
   end
-  
+
   def test_should_need_verifying
     assert Cardinality.exactly(2).needs_verifying?
     assert Cardinality.at_least(3).needs_verifying?
@@ -48,9 +48,9 @@ class CardinalityTest < Test::Unit::TestCase
     assert Cardinality.times(4).needs_verifying?
     assert Cardinality.times(2..4).needs_verifying?
   end
-  
+
   def test_should_not_need_verifying
     assert_equal false, Cardinality.at_least(0).needs_verifying?
   end
-  
-end
+
+end