mocha 1.4.0 → 2.1.0

data/test/unit/class_method_test.rb

@@ -1,229 +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
-
-unless RUBY_V2_PLUS
-  def test_should_hide_original_method
-    klass = Class.new { def self.method_x; end }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    method = ClassMethod.new(klass, :method_x)
-
-    method.hide_original_method
-
-    assert_equal false, klass.respond_to?(:method_x)
-  end
-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 }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    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 }
-    klass.__metaclass__.send(:alias_method, :_method, :method)
-    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.replace_instance_method(:reset_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.replace_instance_method(:reset_mocha) { }
-    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_method(:mocha) { mocha }
-    method = ClassMethod.new(stubbee, :method_name)
-    assert_equal 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

data/test/unit/class_methods_test.rb

@@ -1,40 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/class_methods'
-require 'mocha/object_methods'
-
-class ClassMethodsTest < Mocha::TestCase
-
-  def setup
-    @klass = Class.new.extend(Mocha::ClassMethods, Mocha::ObjectMethods)
-  end
-
-  def test_should_build_any_instance_object
-    any_instance = @klass.any_instance
-    assert_not_nil any_instance
-    assert any_instance.is_a?(Mocha::ClassMethods::AnyInstance)
-  end
-
-  def test_should_return_same_any_instance_object
-    any_instance_1 = @klass.any_instance
-    any_instance_2 = @klass.any_instance
-    assert_equal any_instance_1, any_instance_2
-  end
-
-  def test_should_use_stubba_class_method_for_class
-    assert_equal Mocha::ClassMethod, @klass.stubba_method
-  end
-
-  def test_should_use_stubba_class_method_for_any_instance
-    assert_equal Mocha::AnyInstanceMethod, @klass.any_instance.stubba_method
-  end
-
-  def test_should_stub_self_for_class
-    assert_equal @klass, @klass.stubba_object
-  end
-
-  def test_should_stub_relevant_class_for_any_instance
-    any_instance = @klass.any_instance
-    assert_equal @klass, any_instance.stubba_object
-  end
-
-end

data/test/unit/configuration_test.rb

@@ -1,38 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require "mocha/configuration"
-
-class ConfigurationTest < Mocha::TestCase
-  def test_allow_temporarily_changes_config_when_given_block
-    Mocha::Configuration.warn_when(:stubbing_method_unnecessarily)
-    yielded = false
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily) do
-      yielded = true
-      assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-    end
-    assert yielded
-    assert Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-  end
-
-  def test_prevent_temporarily_changes_config_when_given_block
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily)
-    yielded = false
-    Mocha::Configuration.prevent(:stubbing_method_unnecessarily) do
-      yielded = true
-      assert Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-    end
-    assert yielded
-    assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-  end
-
-  def test_warn_when_temporarily_changes_config_when_given_block
-    Mocha::Configuration.allow(:stubbing_method_unnecessarily)
-    yielded = false
-    Mocha::Configuration.warn_when(:stubbing_method_unnecessarily) do
-      yielded = true
-      assert Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-    end
-    assert yielded
-    assert Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-  end
-end
-

data/test/unit/date_time_inspect_test.rb

@@ -1,21 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/inspect'
-
-class DateTimeInspectTest < Mocha::TestCase
-
-  def test_should_use_include_date_in_seconds
-    time = Time.now
-    assert_equal "#{time.inspect} (#{time.to_f} secs)", time.mocha_inspect
-  end
-
-  def test_should_use_to_s_for_date
-    date = Date.new(2006, 1, 1)
-    assert_equal date.to_s, date.mocha_inspect
-  end
-
-  def test_should_use_to_s_for_datetime
-    datetime = DateTime.new(2006, 1, 1)
-    assert_equal datetime.to_s, datetime.mocha_inspect
-  end
-
-end

data/test/unit/exception_raiser_test.rb

@@ -1,42 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-
-require 'mocha/exception_raiser'
-require 'timeout'
-
-class ExceptionRaiserTest < Mocha::TestCase
-
-  include Mocha
-
-  def test_should_raise_exception_with_specified_class_and_default_message
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class, nil)
-    exception = assert_raises(exception_class) { raiser.evaluate }
-    assert_equal exception_class.to_s, exception.message
-  end
-
-  def test_should_raise_exception_with_specified_class_and_message
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class, 'message')
-    exception = assert_raises(exception_class) { raiser.evaluate }
-    assert_equal 'message', exception.message
-  end
-
-  def test_should_raise_exception_instance
-    exception_class = Class.new(StandardError)
-    raiser = ExceptionRaiser.new(exception_class.new('message'), nil)
-    exception = assert_raises(exception_class) { raiser.evaluate }
-    assert_equal 'message', exception.message
-  end
-
-  def test_should_raise_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
-    raiser = ExceptionRaiser.new(Interrupt, nil)
-    assert_raises(Interrupt) { raiser.evaluate }
-  end
-
-  def test_should_raise_subclass_of_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
-    exception_class = Class.new(Interrupt)
-    raiser = ExceptionRaiser.new(exception_class, nil)
-    assert_raises(exception_class) { raiser.evaluate }
-  end
-
-end

data/test/unit/expectation_list_test.rb

@@ -1,82 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/expectation_list'
-require 'mocha/expectation'
-require 'set'
-require 'method_definer'
-
-class ExpectationListTest < Mocha::TestCase
-
-  include Mocha
-
-  def test_should_return_added_expectation
-    expectation_list = ExpectationList.new
-    expectation = Expectation.new(nil, :my_method)
-    assert_same expectation, expectation_list.add(expectation)
-  end
-
-  def test_should_find_matching_expectation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match(:my_method, :argument1, :argument2)
-  end
-
-  def test_should_remove_all_expectations_matching_method_name
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :method_one).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :method_one).with(:argument3, :argument4)
-    expectation3 = Expectation.new(nil, :method_two)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    expectation_list.add(expectation3)
-    expectation_list.remove_all_matching_method(:method_one)
-    assert_nil expectation_list.match(:method_one, :argument1, :argument2)
-    assert_nil expectation_list.match(:method_one, :argument3, :argument4)
-    assert_same expectation3, expectation_list.match(:method_two)
-  end
-
-  def test_should_find_most_recent_matching_expectation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.match(:my_method, :argument1, :argument2)
-  end
-
-  def test_should_find_matching_expectation_allowing_invocation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    expectation1.define_instance_method(:invocations_allowed?) { true }
-    expectation2.define_instance_method(:invocations_allowed?) { true }
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method, :argument1, :argument2)
-  end
-
-  def test_should_find_most_recent_matching_expectation_allowing_invocation
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
-    expectation1.define_instance_method(:invocations_allowed?) { true }
-    expectation2.define_instance_method(:invocations_allowed?) { false }
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation1, expectation_list.match_allowing_invocation(:my_method)
-  end
-
-  def test_should_combine_two_expectation_lists_into_one
-    expectation_list1 = ExpectationList.new
-    expectation_list2 = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
-    expectation_list1.add(expectation1)
-    expectation_list2.add(expectation2)
-    expectation_list = expectation_list1 + expectation_list2
-    assert_equal [expectation1, expectation2], expectation_list.to_a
-  end
-
-end