mocha 1.5.0 → 1.10.0

data/test/minitest_result.rb

@@ -1,7 +1,6 @@
 require 'forwardable'
 
 class MinitestResult
-
   class Failure
     extend Forwardable
     def_delegators :@failure, :message, :backtrace

data/test/simple_counter.rb

@@ -1,5 +1,4 @@
 class SimpleCounter
-
   attr_reader :count
 
   def initialize
@@ -9,5 +8,4 @@ class SimpleCounter
   def increment
     @count += 1
   end
-
 end

data/test/test_helper.rb

@@ -2,22 +2,26 @@ unless defined?(STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS)
   STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS = Object.instance_methods + Object.private_instance_methods
 end
 
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$:.unshift File.expand_path(File.join(File.dirname(__FILE__)))
-$:.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'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__)))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'unit', 'parameter_matchers'))
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'acceptance'))
 
 require 'mocha/detection/mini_test'
 
 begin
   require 'minitest'
+# rubocop:disable Lint/HandleExceptions
 rescue LoadError
 end
+# rubocop:enable Lint/HandleExceptions
 begin
   require 'minitest/unit'
+# rubocop:disable Lint/HandleExceptions
 rescue LoadError
 end
+# rubocop:enable Lint/HandleExceptions
 
 module Mocha; end
 
@@ -27,6 +31,7 @@ if (minitest_testcase = Mocha::Detection::MiniTest.testcase) && (ENV['MOCHA_RUN_
   rescue LoadError
     MiniTest::Unit.autorun
   end
+  # rubocop:disable Style/ClassAndModuleChildren
   class Mocha::TestCase < minitest_testcase
     def assert_nothing_raised(exception = StandardError)
       yield
@@ -39,12 +44,15 @@ if (minitest_testcase = Mocha::Detection::MiniTest.testcase) && (ENV['MOCHA_RUN_
     alias_method :assert_not_same, :refute_same
     alias_method :assert_no_match, :refute_match
   end
+  # rubocop:enable Style/ClassAndModuleChildren
 else
   require 'test/unit'
+  # rubocop:disable Style/ClassAndModuleChildren
   class Mocha::TestCase < Test::Unit::TestCase
     def test_dummy
       # Some versions (?) of Test::Unit try to run this base class as a test case
       # and it fails because it has no test methods, so I'm adding a dummy test.
     end
   end
+  # rubocop:enable Style/ClassAndModuleChildren
 end

data/test/test_runner.rb

@@ -7,6 +7,7 @@ module TestRunner
     run_as_tests(:test_me => block)
   end
 
+  # rubocop:disable Metrics/AbcSize
   def run_as_tests(methods = {})
     base_class = Mocha::TestCase
     test_class = Class.new(base_class) do
@@ -23,9 +24,7 @@ module TestRunner
       minitest_version = Gem::Version.new(Mocha::Detection::MiniTest.version)
       if Gem::Requirement.new('>= 5.0.0').satisfied_by?(minitest_version)
         require File.expand_path('../minitest_result', __FILE__)
-        tests.each do |test|
-          test.run
-        end
+        tests.each(&:run)
         Minitest::Runnable.runnables.delete(test_class)
         test_result = MinitestResult.new(tests)
       elsif Gem::Requirement.new('> 0.0.0', '< 5.0.0').satisfied_by?(minitest_version)
@@ -46,6 +45,7 @@ module TestRunner
 
     test_result
   end
+  # rubocop:enable Metrics/AbcSize
 
   def assert_passed(test_result)
     flunk "Test failed unexpectedly with message: #{test_result.failures}" if test_result.failure_count > 0
@@ -53,6 +53,6 @@ module TestRunner
   end
 
   def assert_failed(test_result)
-    flunk "Test passed unexpectedly" unless test_result.failure_count + test_result.error_count > 0
+    flunk 'Test passed unexpectedly' unless test_result.failure_count + test_result.error_count > 0
   end
 end

data/test/test_unit_result.rb

@@ -6,13 +6,15 @@ class TestUnitResult
     class << test_result
       attr_reader :failures, :errors
       def failure_messages
-        failures.map { |failure| failure.message }
+        failures.map(&:message)
       end
+
       def failure_message_lines
         failure_messages.map { |message| message.split("\n") }.flatten
       end
+
       def error_messages
-        errors.map { |error| error.message }
+        errors.map(&:message)
       end
     end
     test_result

data/test/unit/any_instance_method_test.rb

@@ -1,38 +1,46 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'method_definer'
+require 'mocha/class_methods'
 require 'mocha/mock'
 require 'mocha/any_instance_method'
 
 class AnyInstanceMethodTest < Mocha::TestCase
-
+  include MethodDefiner
   include Mocha
 
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def method_x; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
+  def class_with_method(method, result = nil)
+    Class.new do
+      extend ClassMethods
+      define_method(method) { result } if method
+    end
+  end
 
-    method.hide_original_method
+  unless RUBY_V2_PLUS
+    def test_should_hide_original_method
+      klass = class_with_method(:method_x)
+      method = AnyInstanceMethod.new(klass, :method_x)
+
+      method.hide_original_method
 
-    assert_equal false, klass.method_defined?(:method_x)
+      assert_equal false, klass.method_defined?(:method_x)
+    end
   end
-end
 
   def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = Class.new
+    klass = class_with_method(:irrelevant)
     method = AnyInstanceMethod.new(klass, :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_with_method(:method_x)
     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 }
+    define_instance_method(any_instance, :mocha) { mocha }
+    define_instance_method(klass, :any_instance) { any_instance }
 
     method.hide_original_method
     method.define_new_method
@@ -44,8 +52,32 @@ end
     assert mocha.__verified__?
   end
 
+  def test_should_include_the_filename_and_line_number_in_exceptions
+    klass = class_with_method(:method_x)
+    method = AnyInstanceMethod.new(klass, :method_x)
+    mocha = build_mock
+    mocha.stubs(:method_x).raises(Exception)
+    any_instance = Object.new
+    define_instance_method(any_instance, :mocha) { mocha }
+    define_instance_method(klass, :any_instance) { any_instance }
+
+    method.hide_original_method
+    method.define_new_method
+
+    expected_filename = 'stubbed_method.rb'
+    expected_line_number = 61
+
+    exception = assert_raises(Exception) { klass.new.method_x }
+    matching_line = exception.backtrace.find do |line|
+      filename, line_number, _context = line.split(':')
+      filename.include?(expected_filename) && line_number.to_i == expected_line_number
+    end
+
+    assert_not_nil matching_line, "Expected to find #{expected_filename}:#{expected_line_number} in the backtrace:\n #{exception.backtrace.join("\n")}"
+  end
+
   def test_should_restore_original_method
-    klass = Class.new { def method_x; :original_result; end }
+    klass = class_with_method(:method_x, :original_result)
     method = AnyInstanceMethod.new(klass, :method_x)
 
     method.hide_original_method
@@ -59,7 +91,7 @@ end
   end
 
   def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def method_x; :new_result; end }
+    klass = class_with_method(:method_x, :new_result)
     method = AnyInstanceMethod.new(klass, :method_x)
 
     method.restore_original_method
@@ -69,16 +101,16 @@ end
   end
 
   def test_should_call_remove_new_method
-    klass = Class.new { def method_x; end }
+    klass = class_with_method(:method_x)
     any_instance = build_mock
     any_instance_mocha = build_mock
     any_instance.stubs(:mocha).returns(any_instance_mocha)
-    klass.define_instance_method(:any_instance) { any_instance }
+    define_instance_method(klass, :any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:restore_original_method) { }
-    method.replace_instance_method(:reset_mocha) { }
-    method.define_instance_accessor(:remove_called)
-    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
+    replace_instance_method(method, :restore_original_method) {}
+    replace_instance_method(method, :reset_mocha) {}
+    define_instance_accessor(method, :remove_called)
+    replace_instance_method(method, :remove_new_method) { self.remove_called = true }
 
     method.unstub
 
@@ -86,16 +118,16 @@ end
   end
 
   def test_should_call_restore_original_method
-    klass = Class.new { def method_x; end }
+    klass = class_with_method(:method_x)
     any_instance = build_mock
     any_instance_mocha = build_mock
     any_instance.stubs(:mocha).returns(any_instance_mocha)
-    klass.define_instance_method(:any_instance) { any_instance }
+    define_instance_method(klass, :any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:reset_mocha) { }
-    method.define_instance_accessor(:restore_called)
-    method.replace_instance_method(:restore_original_method) { self.restore_called = true }
+    replace_instance_method(method, :remove_new_method) {}
+    replace_instance_method(method, :reset_mocha) {}
+    define_instance_accessor(method, :restore_called)
+    replace_instance_method(method, :restore_original_method) { self.restore_called = true }
 
     method.unstub
 
@@ -103,15 +135,22 @@ end
   end
 
   def test_should_call_mock_unstub
-    klass = Class.new { def method_x; end }
+    klass = class_with_method(:method_x)
 
     method = AnyInstanceMethod.new(klass, :method_x)
 
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new { class << self; attr_accessor :unstub_method; end; def self.unstub(method); self.unstub_method = method; end; }
-    mocha.define_instance_method(:any_expectations?) { true }
-    method.replace_instance_method(:mock) { mocha }
+    replace_instance_method(method, :remove_new_method) {}
+    replace_instance_method(method, :restore_original_method) {}
+    mocha = Class.new do
+      class << self
+        attr_accessor :unstub_method
+      end
+      def self.unstub(method)
+        self.unstub_method = method
+      end
+    end
+    define_instance_method(mocha, :any_expectations?) { true }
+    replace_instance_method(method, :mock) { mocha }
 
     method.unstub
 
@@ -121,9 +160,9 @@ end
   def test_should_return_any_instance_mocha_for_stubbee
     mocha = Object.new
     any_instance = Object.new
-    any_instance.define_instance_method(:mocha) { mocha }
-    stubbee = Class.new
-    stubbee.define_instance_method(:any_instance) { any_instance }
+    define_instance_method(any_instance, :mocha) { mocha }
+    stubbee = class_with_method(:method_x)
+    define_instance_method(stubbee, :any_instance) { any_instance }
     method = AnyInstanceMethod.new(stubbee, :method_name)
     assert_equal stubbee.any_instance.mocha, method.mock
   end

data/test/unit/array_inspect_test.rb

@@ -2,15 +2,13 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/inspect'
 
 class ArrayInspectTest < Mocha::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
+    array = [1, 2, 'chris']
+    assert_equal %([1, 2, "chris"]), array.mocha_inspect
   end
-
 end

data/test/unit/backtrace_filter_test.rb

@@ -2,18 +2,16 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/backtrace_filter'
 
 class BacktraceFilterTest < Mocha::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']
+    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']
     filter = BacktraceFilter.new(mocha_lib)
     assert_equal ['/keep/me'], filter.filtered(backtrace)
   end
 
   def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new("/lib/$"), BacktraceFilter::LIB_DIRECTORY
+    assert_match Regexp.new('/lib/$'), BacktraceFilter::LIB_DIRECTORY
   end
-
 end

data/test/unit/cardinality_test.rb

@@ -1,44 +1,61 @@
 require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/cardinality'
+require 'mocha/invocation'
+require 'mocha/return_values'
+require 'mocha/yield_parameters'
 
 class CardinalityTest < Mocha::TestCase
-
   include Mocha
 
+  def new_invocation
+    Invocation.new(:irrelevant, :irrelevant)
+  end
+
   def test_should_allow_invocations_if_invocation_count_has_not_yet_reached_maximum
     cardinality = Cardinality.new(2, 3)
-    assert cardinality.invocations_allowed?(0)
-    assert cardinality.invocations_allowed?(1)
-    assert cardinality.invocations_allowed?(2)
-    assert !cardinality.invocations_allowed?(3)
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert cardinality.invocations_allowed?
+    cardinality << new_invocation
+    assert !cardinality.invocations_allowed?
   end
 
   def test_should_be_satisfied_if_invocations_so_far_have_reached_required_threshold
     cardinality = Cardinality.new(2, 3)
-    assert !cardinality.satisfied?(0)
-    assert !cardinality.satisfied?(1)
-    assert cardinality.satisfied?(2)
-    assert cardinality.satisfied?(3)
+    assert !cardinality.satisfied?
+    cardinality << new_invocation
+    assert !cardinality.satisfied?
+    cardinality << new_invocation
+    assert cardinality.satisfied?
+    cardinality << new_invocation
+    assert cardinality.satisfied?
   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
+  def test_should_describe_cardinality_defined_using_at_least
+    assert_equal 'allowed any number of times', Cardinality.at_least(0).anticipated_times
+    assert_equal 'expected at least once', Cardinality.at_least(1).anticipated_times
+    assert_equal 'expected at least twice', Cardinality.at_least(2).anticipated_times
+    assert_equal 'expected at least 3 times', Cardinality.at_least(3).anticipated_times
+  end
 
-    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
+  def test_should_describe_cardinality_defined_using_at_most
+    assert_equal 'expected at most once', Cardinality.at_most(1).anticipated_times
+    assert_equal 'expected at most twice', Cardinality.at_most(2).anticipated_times
+    assert_equal 'expected at most 3 times', Cardinality.at_most(3).anticipated_times
+  end
 
-    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
+  def test_should_describe_cardinality_defined_using_exactly
+    assert_equal 'expected never', Cardinality.exactly(0).anticipated_times
+    assert_equal 'expected exactly once', Cardinality.exactly(1).anticipated_times
+    assert_equal 'expected exactly twice', Cardinality.exactly(2).anticipated_times
+    assert_equal 'expected exactly 3 times', Cardinality.exactly(3).anticipated_times
+  end
 
-    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
+  def test_should_describe_cardinality_defined_using_times_with_range
+    assert_equal 'expected between 2 and 4 times', Cardinality.times(2..4).anticipated_times
+    assert_equal 'expected between 1 and 3 times', Cardinality.times(1..3).anticipated_times
   end
 
   def test_should_need_verifying
@@ -52,5 +69,4 @@ class CardinalityTest < Mocha::TestCase
   def test_should_not_need_verifying
     assert_equal false, Cardinality.at_least(0).needs_verifying?
   end
-
 end