mocha 0.10.5 → 0.11.0

data/test/unit/central_test.rb

@@ -5,47 +5,47 @@ 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 = 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
@@ -56,11 +56,11 @@ class CentralTest < Test::Unit::TestCase
     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
@@ -70,11 +70,11 @@ class CentralTest < Test::Unit::TestCase
     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
@@ -86,7 +86,7 @@ class CentralTest < Test::Unit::TestCase
     stubba.stubba_methods = [method_1, method_2]
 
     stubba.unstub_all
-    
+
     assert_equal [], stubba.stubba_methods
     assert method_1.__verified__?
     assert method_2.__verified__?

data/test/unit/change_state_side_effect_test.rb

@@ -3,39 +3,39 @@ require File.expand_path('../../test_helper', __FILE__)
 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

@@ -5,126 +5,68 @@ 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
+  include Mocha
 
-  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)
-    
     method.hide_original_method
 
-    assert klass.respond_to?(:original_method_name)
+    assert_equal false, klass.respond_to?(:method_x)
   end
-  
-  def test_should_not_hide_original_method_if_method_not_defined
+
+  def test_should_not_raise_error_hiding_method_that_isnt_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)
+    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; end }
+    klass = Class.new { def self.method_x; :original_result; 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.hide_original_method
+    method.define_new_method
     method.remove_new_method
     method.restore_original_method
-    
-    assert_equal :original_result, klass.method_x 
-    assert_equal false, klass.respond_to?(hidden_method_x)
+
+    assert klass.respond_to?(:method_x)
+    assert_equal :original_result, klass.method_x
   end
 
-  def test_should_not_restore_original_method_if_hidden_method_is_not_defined
+  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
 
@@ -134,9 +76,9 @@ class ClassMethodTest < Test::Unit::TestCase
     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
 
@@ -145,12 +87,12 @@ class ClassMethodTest < Test::Unit::TestCase
     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)
@@ -158,9 +100,9 @@ class ClassMethodTest < Test::Unit::TestCase
     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
 
@@ -171,9 +113,9 @@ class ClassMethodTest < Test::Unit::TestCase
     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
 
@@ -184,7 +126,7 @@ class ClassMethodTest < Test::Unit::TestCase
     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
@@ -214,7 +156,7 @@ class ClassMethodTest < Test::Unit::TestCase
     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
@@ -228,21 +170,21 @@ class ClassMethodTest < Test::Unit::TestCase
     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

data/test/unit/date_time_inspect_test.rb

@@ -2,20 +2,20 @@ require File.expand_path('../../test_helper', __FILE__)
 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

@@ -4,9 +4,9 @@ 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)
@@ -20,14 +20,14 @@ class ExceptionRaiserTest < Test::Unit::TestCase
     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 }
@@ -39,4 +39,4 @@ class ExceptionRaiserTest < Test::Unit::TestCase
     assert_raises(exception_class) { raiser.evaluate }
   end
 
-end
+end

data/test/unit/expectation_list_test.rb

@@ -5,15 +5,15 @@ 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)
@@ -36,7 +36,7 @@ class ExpectationListTest < Test::Unit::TestCase
     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)
@@ -45,7 +45,7 @@ class ExpectationListTest < Test::Unit::TestCase
     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)
@@ -56,7 +56,7 @@ class ExpectationListTest < Test::Unit::TestCase
     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)
@@ -67,5 +67,5 @@ class ExpectationListTest < Test::Unit::TestCase
     expectation_list.add(expectation2)
     assert_same expectation1, expectation_list.match_allowing_invocation(:my_method)
   end
-  
+
 end