mocha 1.1.0 → 2.1.0

data/test/test_runner.rb

@@ -1,58 +0,0 @@
-require 'assertions'
-
-require 'mocha/detection/mini_test'
-
-module TestRunner
-  def run_as_test(&block)
-    run_as_tests(:test_me => block)
-  end
-
-  def run_as_tests(methods = {})
-    base_class = Mocha::TestCase
-    test_class = Class.new(base_class) do
-      include Assertions
-
-      methods.each do |(method_name, proc)|
-        define_method(method_name, proc)
-      end
-    end
-
-    tests = methods.keys.select { |m| m.to_s[/^test/] }.map { |m| test_class.new(m) }
-
-    if Mocha::Detection::MiniTest.testcase && (ENV['MOCHA_RUN_INTEGRATION_TESTS'] != 'test-unit')
-      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
-        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)
-        require File.expand_path('../mini_test_result', __FILE__)
-        runner = MiniTest::Unit.new
-        tests.each do |test|
-          test.run(runner)
-        end
-        test_result = MiniTestResult.new(runner, tests)
-      end
-    else
-      require File.expand_path('../test_unit_result', __FILE__)
-      test_result = TestUnitResult.build_test_result
-      tests.each do |test|
-        test.run(test_result) {}
-      end
-    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
-  end
-
-  def assert_failed(test_result)
-    flunk "Test passed unexpectedly" unless test_result.failure_count + test_result.error_count > 0
-  end
-end

data/test/test_unit_result.rb

@@ -1,20 +0,0 @@
-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

@@ -1,132 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/mock'
-require 'mocha/any_instance_method'
-
-class AnyInstanceMethodTest < Mocha::TestCase
-
-  include Mocha
-
-  def test_should_hide_original_method
-    klass = Class.new { def method_x; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-
-    assert_equal false, klass.method_defined?(:method_x)
-  end
-
-  def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = Class.new
-    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 }
-    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; :original_result; end }
-    method = AnyInstanceMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    instance = klass.new
-    assert instance.respond_to?(:method_x)
-    assert_equal :original_result, instance.method_x
-  end
-
-  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
-  end
-
-  def test_should_call_remove_new_method
-    klass = Class.new { def method_x; end }
-    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 }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    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
-
-  def test_should_call_restore_original_method
-    klass = Class.new { def method_x; end }
-    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 }
-    method = AnyInstanceMethod.new(klass, :method_x)
-    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
-
-  def test_should_call_mock_unstub
-    klass = Class.new { def method_x; end }
-
-    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 }
-
-    method.unstub
-
-    assert_equal mocha.unstub_method, :method_x
-  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 }
-    method = AnyInstanceMethod.new(stubbee, :method_name)
-    assert_equal stubbee.any_instance.mocha, method.mock
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end

data/test/unit/array_inspect_test.rb

@@ -1,16 +0,0 @@
-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
-  end
-
-end

data/test/unit/backtrace_filter_test.rb

@@ -1,19 +0,0 @@
-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']
-    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
-  end
-
-end

data/test/unit/cardinality_test.rb

@@ -1,56 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/cardinality'
-
-class CardinalityTest < Mocha::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)
-    assert cardinality.invocations_allowed?(1)
-    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)
-    assert !cardinality.satisfied?(1)
-    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?
-    assert Cardinality.at_most(2).needs_verifying?
-    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

data/test/unit/central_test.rb

@@ -1,100 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/central'
-require 'mocha/mock'
-require 'method_definer'
-
-class CentralTest < Mocha::TestCase
-
-  include Mocha
-
-  def test_should_start_with_empty_stubba_methods
-    stubba = Central.new
-
-    assert_equal [], stubba.stubba_methods
-  end
-
-  def test_should_stub_method_if_not_already_stubbed
-    method = build_mock
-    method.expects(:stub)
-    stubba = Central.new
-
-    stubba.stub(method)
-
-    assert method.__verified__?
-  end
-
-  def test_should_not_stub_method_if_already_stubbed
-    method = build_mock
-    method.stubs(:matches?).returns(true)
-    method.expects(:stub).times(0)
-    stubba = Central.new
-    stubba.stubba_methods = [method]
-
-    stubba.stub(method)
-
-    assert method.__verified__?
-  end
-
-  def test_should_record_method
-    method = build_mock
-    method.expects(:stub)
-    stubba = Central.new
-
-    stubba.stub(method)
-
-    assert_equal [method], stubba.stubba_methods
-  end
-
-  def test_should_unstub_specified_method
-    stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
-
-    stubba.unstub(method_2)
-
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
-  end
-
-  def test_should_not_unstub_specified_method_if_not_already_stubbed
-    stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(false)
-    method_2 = build_mock
-    method_2.expects(:unstub).never
-    stubba.stubba_methods = [method_1]
-
-    stubba.unstub(method_2)
-
-    assert_equal [method_1], stubba.stubba_methods
-    assert method_2.__verified__?
-  end
-
-  def test_should_unstub_all_methods
-    stubba = Central.new
-    method_1 = build_mock
-    method_1.stubs(:matches?).returns(true)
-    method_1.expects(:unstub)
-    method_2 = build_mock
-    method_2.stubs(:matches?).returns(true)
-    method_2.expects(:unstub)
-    stubba.stubba_methods = [method_1, method_2]
-
-    stubba.unstub_all
-
-    assert_equal [], stubba.stubba_methods
-    assert method_1.__verified__?
-    assert method_2.__verified__?
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end

data/test/unit/change_state_side_effect_test.rb

@@ -1,41 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/change_state_side_effect'
-
-class ChangeStateSideEffectTest < Mocha::TestCase
-
-  include Mocha
-
-  class FakeState
-
-    attr_reader :active
-    attr_writer :description
-
-    def activate
-      @active = true
-    end
-
-    def mocha_inspect
-      @description
-    end
-
-  end
-
-  def test_should_activate_the_given_state
-    state = FakeState.new
-    side_effect = ChangeStateSideEffect.new(state)
-
-    side_effect.perform
-
-    assert state.active
-  end
-
-  def test_should_describe_itself_in_terms_of_the_activated_state
-    state = FakeState.new
-    state.description = 'the-new-state'
-    side_effect = ChangeStateSideEffect.new(state)
-
-    assert_equal 'then the-new-state', side_effect.mocha_inspect
-  end
-
-end

data/test/unit/class_method_test.rb

@@ -1,223 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'method_definer'
-require 'mocha/mock'
-
-require 'mocha/class_method'
-
-class ClassMethodTest < Mocha::TestCase
-
-  include Mocha
-
-  def test_should_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-
-  def test_should_not_raise_error_hiding_method_that_isnt_defined
-    klass = Class.new
-    method = ClassMethod.new(klass, :method_x)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_not_raise_error_hiding_method_in_class_that_implements_method_called_method
-    klass = Class.new { def self.method; end }
-    method = ClassMethod.new(klass, :method)
-
-    assert_nothing_raised { method.hide_original_method }
-  end
-
-  def test_should_define_a_new_method_which_should_call_mocha_method_missing
-    klass = Class.new { def self.method_x; end }
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    result = klass.method_x(:param1, :param2)
-
-    assert_equal :result, result
-    assert mocha.__verified__?
-  end
-
-  def test_should_remove_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.remove_new_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-
-  def test_should_restore_original_method
-    klass = Class.new { def self.method_x; :original_result; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    assert klass.respond_to?(:method_x)
-    assert_equal :original_result, klass.method_x
-  end
-
-  def test_should_restore_original_method_accepting_a_block_parameter
-    klass = Class.new { def self.method_x(&block); block.call if block_given? ; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-    method.define_new_method
-    method.remove_new_method
-    method.restore_original_method
-
-    block_called = false
-    klass.method_x { block_called = true }
-    assert block_called
-  end
-
-  def test_should_not_restore_original_method_if_none_was_defined_in_first_place
-    klass = Class.new { def self.method_x; :new_result; end }
-    method = ClassMethod.new(klass, :method_x)
-
-    method.restore_original_method
-
-    assert_equal :new_result, klass.method_x
-  end
-
-  def test_should_call_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.hide_original_method
-    method.define_instance_accessor(:hide_called)
-    method.replace_instance_method(:hide_original_method) { self.hide_called = true }
-
-    method.stub
-
-    assert method.hide_called
-  end
-
-  def test_should_call_define_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.define_instance_accessor(:define_called)
-    method.replace_instance_method(:define_new_method) { self.define_called = true }
-
-    method.stub
-
-    assert method.define_called
-  end
-
-  def test_should_call_remove_new_method
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    method.define_instance_accessor(:remove_called)
-    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
-
-    method.unstub
-
-    assert method.remove_called
-  end
-
-  def test_should_call_restore_original_method
-    klass = Class.new { def self.method_x; end }
-    mocha = build_mock
-    klass.define_instance_method(:mocha) { mocha }
-    method = ClassMethod.new(klass, :method_x)
-    method.define_instance_accessor(:restore_called)
-    method.replace_instance_method(:restore_original_method) { self.restore_called = true }
-
-    method.unstub
-
-    assert method.restore_called
-  end
-
-  def test_should_call_mocha_unstub
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    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 }
-
-    method.unstub
-    assert_equal mocha.unstub_method, :method_x
-  end
-
-  def test_should_call_stubbee_reset_mocha_if_no_expectations_remaining
-    klass = Class.new { def self.method_x; end }
-    method = ClassMethod.new(klass, :method_x)
-    method.replace_instance_method(:remove_new_method) { }
-    method.replace_instance_method(:restore_original_method) { }
-    mocha = Class.new
-    mocha.define_instance_method(:unstub) { |method_name| }
-    mocha.define_instance_method(:any_expectations?) { false }
-    method.replace_instance_method(:mock) { mocha }
-    stubbee = Class.new { attr_accessor :reset_mocha_called; def reset_mocha; self.reset_mocha_called = true; end; }.new
-    method.replace_instance_method(:stubbee) { stubbee }
-
-    method.unstub
-
-    assert stubbee.reset_mocha_called
-  end
-
-  def test_should_return_mock_for_stubbee
-    mocha = Object.new
-    stubbee = Object.new
-    stubbee.define_instance_accessor(:mocha) { mocha }
-    stubbee.mocha = nil
-    method = ClassMethod.new(stubbee, :method_name)
-    assert_equal stubbee.mocha, method.mock
-  end
-
-  def test_should_not_match_if_other_object_has_a_different_class
-    class_method = ClassMethod.new(Object.new, :method)
-    other_object = Object.new
-    assert !class_method.matches?(other_object)
-  end
-
-  def test_should_not_match_if_other_class_method_has_different_stubbee
-    stubbee_1 = Object.new
-    stubbee_2 = Object.new
-    class_method_1 = ClassMethod.new(stubbee_1, :method)
-    class_method_2 = ClassMethod.new(stubbee_2, :method)
-    assert !class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_not_match_if_other_class_method_has_different_method
-    stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method_1)
-    class_method_2 = ClassMethod.new(stubbee, :method_2)
-    assert !class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_so_no_attempt_is_made_to_stub_a_method_twice
-    stubbee = Object.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
-  end
-
-  def test_should_match_if_other_class_method_has_same_stubbee_and_same_method_but_stubbee_equal_method_lies_like_active_record_association_proxy
-    stubbee = Class.new do
-      def equal?(other); false; end
-    end.new
-    class_method_1 = ClassMethod.new(stubbee, :method)
-    class_method_2 = ClassMethod.new(stubbee, :method)
-    assert class_method_1.matches?(class_method_2)
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end