floehopper-mocha 0.9.3.20081220175348

data/test/unit/cardinality_test.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+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)
+    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

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/central'
+require 'mocha/mock'
+require 'method_definer'
+
+class CentralTest < Test::Unit::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 = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    assert method.__verified__?
+  end
+  
+  def test_should_not_stub_method_if_already_stubbed
+    method = Mock.new
+    method.expects(:stub).times(0)
+    stubba = Central.new
+    stubba_methods = Mock.new
+    stubba_methods.stubs(:include?).with(method).returns(true)
+    stubba.stubba_methods = stubba_methods
+    
+    stubba.stub(method)
+    
+    assert method.__verified__?
+  end
+  
+  def test_should_record_method
+    method = Mock.new
+    method.expects(:stub)
+    stubba = Central.new
+    
+    stubba.stub(method)
+    
+    assert_equal [method], stubba.stubba_methods
+  end
+  
+  def test_should_unstub_all_methods
+    stubba = Central.new
+    method_1 = Mock.new
+    method_1.expects(:unstub)
+    method_2 = Mock.new
+    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
+  
+end

data/test/unit/change_state_side_effect_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/change_state_side_effect'
+
+class ChangeStateSideEffectTest < Test::Unit::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

@@ -0,0 +1,237 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/mock'
+
+require 'mocha/class_method'
+
+class ClassMethodTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_provide_hidden_version_of_method_name_starting_with_prefix
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/^__stubba__/, method.hidden_method.to_s)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_ending_with_suffix
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/__stubba__$/, method.hidden_method.to_s)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_including_original_method_name
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/original_method_name/, method.hidden_method.to_s)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_question_mark
+    method = ClassMethod.new(nil, :question_mark?)
+    assert_no_match(/\?/, method.hidden_method.to_s)
+    assert_match(/question_mark_substituted_character_63/, method.hidden_method.to_s)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_exclamation_mark
+    method = ClassMethod.new(nil, :exclamation_mark!)
+    assert_no_match(/!/, method.hidden_method.to_s)
+    assert_match(/exclamation_mark_substituted_character_33/, method.hidden_method.to_s)
+  end
+
+  def test_should_provide_hidden_version_of_method_name_substituting_equals_sign
+    method = ClassMethod.new(nil, :equals_sign=)
+    assert_no_match(/\=/, method.hidden_method.to_s)
+    assert_match(/equals_sign_substituted_character_61/, method.hidden_method.to_s)
+  end
+
+  def test_should_provide_hidden_version_of_method_name_substituting_brackets
+    method = ClassMethod.new(nil, :[])
+    assert_no_match(/\[\]/, method.hidden_method.to_s)
+    assert_match(/substituted_character_91__substituted_character_93/, method.hidden_method.to_s)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_plus_sign
+    method = ClassMethod.new(nil, :+)
+    assert_no_match(/\+/, method.hidden_method.to_s)
+    assert_match(/substituted_character_43/, method.hidden_method.to_s)
+  end
+  
+  def test_should_hide_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_respond_to_original_method_name_after_original_method_has_been_hidden
+    klass = Class.new { def self.original_method_name; end }
+    method = ClassMethod.new(klass, :original_method_name)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert klass.respond_to?(:original_method_name)
+  end
+  
+  def test_should_not_hide_original_method_if_method_not_defined
+    klass = Class.new
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert_equal false, klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_define_a_new_method_which_should_call_mocha_method_missing
+    klass = Class.new { def self.method_x; end }
+    mocha = Mocha::Mock.new
+    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; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    klass.define_instance_method(hidden_method_x) { :original_result }
+
+    method.remove_new_method
+    method.restore_original_method
+    
+    assert_equal :original_result, klass.method_x 
+    assert_equal false, klass.respond_to?(hidden_method_x)
+  end
+
+  def test_should_not_restore_original_method_if_hidden_method_is_not_defined
+    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 }
+    klass.define_instance_method(:reset_mocha) { }
+    method = ClassMethod.new(klass, :method_x)
+    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 }
+    klass.define_instance_method(:reset_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_reset_mocha
+    klass = Class.new { def self.method_x; end }
+    klass.define_instance_accessor(:reset_called)
+    klass.define_instance_method(:reset_mocha) { self.reset_called = true }
+    method = ClassMethod.new(klass, :method_x)
+    method.replace_instance_method(:restore_original_method) { }
+    
+    method.unstub
+    
+    assert klass.reset_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_be_equal_if_other_object_has_a_different_class
+    class_method = ClassMethod.new(Object.new, :method)
+    other_object = Object.new
+    assert class_method != other_object
+  end
+
+  def test_should_not_be_equal_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 != class_method_2
+  end
+  
+  def test_should_not_be_equal_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 != class_method_2
+  end
+  
+  def test_should_be_equal_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 == class_method_2
+  end
+  
+  def test_should_be_equal_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 == class_method_2
+  end
+  
+end

data/test/unit/date_time_inspect_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+class DateTimeInspectTest < Test::Unit::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

@@ -0,0 +1,42 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/exception_raiser'
+require 'timeout'
+
+class ExceptionRaiserTest < Test::Unit::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

@@ -0,0 +1,57 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/expectation_list'
+require 'mocha/expectation'
+require 'set'
+require 'method_definer'
+
+class ExpectationListTest < Test::Unit::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_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
+  
+end