mocha 0.10.5 → 0.11.0

data/test/unit/multiple_yields_test.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/multiple_yields'
 
 class MultipleYieldsTest < Test::Unit::TestCase
-  
+
   include Mocha
 
   def test_should_provide_parameters_for_multiple_yields_in_single_invocation
@@ -14,5 +14,5 @@ class MultipleYieldsTest < Test::Unit::TestCase
     end
     assert_equal [[1, 2, 3], [4, 5]], parameter_groups
   end
-  
+
 end

data/test/unit/no_yields_test.rb

@@ -3,7 +3,7 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/no_yields'
 
 class NoYieldsTest < Test::Unit::TestCase
-  
+
   include Mocha
 
   def test_should_provide_parameters_for_no_yields_in_single_invocation
@@ -14,5 +14,5 @@ class NoYieldsTest < Test::Unit::TestCase
     end
     assert_equal [], parameter_groups
   end
-  
+
 end

data/test/unit/object_inspect_test.rb

@@ -3,7 +3,7 @@ require 'mocha/inspect'
 require 'method_definer'
 
 class ObjectInspectTest < Test::Unit::TestCase
-  
+
   def test_should_return_default_string_representation_of_object_not_including_instance_variables
     object = Object.new
     class << object
@@ -13,7 +13,7 @@ class ObjectInspectTest < Test::Unit::TestCase
     assert_match Regexp.new("^#<Object:0x[0-9A-Fa-f]{1,8}.*>$"), object.mocha_inspect
     assert_no_match(/instance_variable/, object.mocha_inspect)
   end
-  
+
   def test_should_return_customized_string_representation_of_object
     object = Object.new
     class << object
@@ -21,7 +21,7 @@ class ObjectInspectTest < Test::Unit::TestCase
     end
     assert_equal 'custom_inspect', object.mocha_inspect
   end
-  
+
   def test_should_use_underscored_id_instead_of_object_id_or_id_so_that_they_can_be_stubbed
     calls = []
     object = Object.new
@@ -34,5 +34,5 @@ class ObjectInspectTest < Test::Unit::TestCase
 
     assert_equal [:__id__], calls.uniq
   end
-  
+
 end

data/test/unit/object_test.rb

@@ -5,9 +5,9 @@ require 'mocha/mock'
 require 'method_definer'
 
 class ObjectTest < Test::Unit::TestCase
-  
+
   include Mocha
-    
+
   def test_should_build_mocha_referring_to_self
     instance = Object.new
     mocha = instance.mocha
@@ -15,64 +15,64 @@ class ObjectTest < Test::Unit::TestCase
     assert mocha.is_a?(Mock)
     assert_equal instance.mocha_inspect, mocha.mocha_inspect
   end
-  
+
   def test_should_reuse_existing_mocha
     instance = Object.new
     mocha_1 = instance.mocha
     mocha_2 = instance.mocha
     assert_equal mocha_1, mocha_2
   end
-  
+
   def test_should_reset_mocha
     instance = Object.new
     assert_nil instance.reset_mocha
   end
-  
+
   def test_should_build_any_instance_object
     klass = Class.new
     any_instance = klass.any_instance
     assert_not_nil any_instance
     assert any_instance.is_a?(Class::AnyInstance)
   end
-  
+
   def test_should_return_same_any_instance_object
     klass = Class.new
     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_instance_method_for_object
     assert_equal Mocha::InstanceMethod, Object.new.stubba_method
   end
-    
+
   def test_should_use_stubba_module_method_for_module
     assert_equal Mocha::ModuleMethod, Module.new.stubba_method
   end
-    
+
   def test_should_use_stubba_class_method_for_class
     assert_equal Mocha::ClassMethod, Class.new.stubba_method
   end
-  
+
   def test_should_use_stubba_class_method_for_any_instance
     assert_equal Mocha::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
   end
-  
+
   def test_should_stub_self_for_object
     object = Object.new
     assert_equal object, object.stubba_object
   end
-      
+
   def test_should_stub_self_for_module
     mod = Module.new
     assert_equal mod, mod.stubba_object
   end
-      
+
   def test_should_stub_self_for_class
     klass = Class.new
     assert_equal klass, klass.stubba_object
   end
-      
+
   def test_should_stub_relevant_class_for_any_instance
     klass = Class.new
     any_instance = Class::AnyInstance.new(klass)
@@ -83,5 +83,5 @@ class ObjectTest < Test::Unit::TestCase
     object = Object.new
     assert_raise(Mocha::ExpectationError) { object.expects(:the_spanish_inquisition) }
   end
-  
+
 end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -5,22 +5,22 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AllOfTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_if_all_matchers_match
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(true), Stub::Matcher.new(true))
     assert matcher.matches?(['any_old_value'])
   end
-  
+
   def test_should_not_match_if_any_matcher_does_not_match
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
     assert !matcher.matches?(['any_old_value'])
   end
-  
+
   def test_should_describe_matcher
     matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
     assert_equal 'all_of(matcher(true), matcher(false), matcher(true))', matcher.mocha_inspect
   end
-  
-end
+
+end

data/test/unit/parameter_matchers/any_of_test.rb

@@ -5,22 +5,22 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AnyOfTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_if_any_matchers_match
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
     assert matcher.matches?(['any_old_value'])
   end
-  
+
   def test_should_not_match_if_no_matchers_match
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(false), Stub::Matcher.new(false))
     assert !matcher.matches?(['any_old_value'])
   end
-  
+
   def test_should_describe_matcher
     matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
     assert_equal 'any_of(matcher(false), matcher(true), matcher(false))', matcher.mocha_inspect
   end
-  
-end
+
+end

data/test/unit/parameter_matchers/anything_test.rb

@@ -4,18 +4,18 @@ require 'mocha/parameter_matchers/anything'
 require 'mocha/inspect'
 
 class AnythingTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_anything
     matcher = anything
     assert matcher.matches?([:something])
     assert matcher.matches?([{'x' => 'y'}])
   end
-  
+
   def test_should_describe_matcher
     matcher = anything
     assert_equal "anything", matcher.mocha_inspect
   end
-  
-end
+
+end

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -5,19 +5,19 @@ require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasEntriesTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_hash_including_specified_entries
     matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entries
     matcher = has_entries(:key_1 => 'value_2', :key_2 => 'value_2', :key_3 => 'value_3')
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_describe_matcher
     matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
     description = matcher.mocha_inspect
@@ -27,25 +27,25 @@ class HasEntriesTest < Test::Unit::TestCase
     assert_equal 'value_1', entries[:key_1]
     assert_equal 'value_2', entries[:key_2]
   end
-  
+
   def test_should_match_hash_including_specified_entries_with_nested_key_matchers
     matcher = has_entries(equals(:key_1) => 'value_1', equals(:key_2) => 'value_2')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entries_with_nested_key_matchers
     matcher = has_entries(equals(:key_1) => 'value_2', equals(:key_2) => 'value_2', equals(:key_3) => 'value_3')
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_match_hash_including_specified_entries_with_nested_value_matchers
     matcher = has_entries(:key_1 => equals('value_1'), :key_2 => equals('value_2'))
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entries_with_nested_value_matchers
     matcher = has_entries(:key_1 => equals('value_2'), :key_2 => equals('value_2'), :key_3 => equals('value_3'))
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
-end
+
+end

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -6,59 +6,59 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasEntryTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_hash_including_specified_key_value_pair
     matcher = has_entry(:key_1, 'value_1')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_key_value_pair
     matcher = has_entry(:key_1, 'value_2')
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_match_hash_including_specified_entry
     matcher = has_entry(:key_1 => 'value_1')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entry
     matcher = has_entry(:key_1 => 'value_2')
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_describe_matcher_with_key_value_pair
     matcher = has_entry(:key_1, 'value_1')
     assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
   end
-  
+
   def test_should_describe_matcher_with_entry
     matcher = has_entry(:key_1 => 'value_1')
     assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
   end
-  
+
   def test_should_match_hash_including_specified_entry_with_nested_key_matcher
     matcher = has_entry(equals(:key_1) => 'value_1')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_match_hash_including_specified_entry_with_nested_value_matcher
     matcher = has_entry(:key_1 => equals('value_1'))
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entry_with_nested_key_matcher
     matcher = has_entry(equals(:key_1) => 'value_2')
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_entry_with_nested_value_matcher
     matcher = has_entry(:key_1 => equals('value_2'))
     assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_object_that_doesnt_respond_to_keys
     matcher = has_entry(:key_1 => equals('value_2'))
     object = Class.new do
@@ -68,7 +68,7 @@ class HasEntryTest < Test::Unit::TestCase
     end.new
     assert !matcher.matches?([object])
   end
-  
+
   def test_should_not_match_object_that_doesnt_respond_to_square_bracket
     matcher = has_entry(:key_1 => equals('value_2'))
     object = Class.new do

data/test/unit/parameter_matchers/has_key_test.rb

@@ -5,51 +5,51 @@ require 'mocha/parameter_matchers/object'
 require 'mocha/inspect'
 
 class HasKeyTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_hash_including_specified_key
     matcher = has_key(:key_1)
     assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_key
     matcher = has_key(:key_1)
     assert !matcher.matches?([{ :key_2 => 2 }])
   end
-  
+
   def test_should_describe_matcher
     matcher = has_key(:key)
     assert_equal 'has_key(:key)', matcher.mocha_inspect
   end
-  
+
   def test_should_match_hash_including_specified_key_with_nested_key_matcher
     matcher = has_key(equals(:key_1))
     assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_key_with_nested_key_matcher
     matcher = has_key(equals(:key_1))
     assert !matcher.matches?([{ :key_2 => 2 }])
   end
-  
+
   def test_should_not_raise_error_on_empty_arguments
     matcher = has_key(:key)
     assert_nothing_raised { matcher.matches?([]) }
   end
-  
+
   def test_should_not_match_on_empty_arguments
     matcher = has_key(:key)
     assert !matcher.matches?([])
   end
-  
+
   def test_should_not_raise_error_on_argument_that_does_not_respond_to_keys
     matcher = has_key(:key)
     assert_nothing_raised { matcher.matches?([:key]) }
   end
-  
+
   def test_should_not_match_on_argument_that_does_not_respond_to_keys
     matcher = has_key(:key)
     assert !matcher.matches?([:key])
   end
-end
+end

data/test/unit/parameter_matchers/has_value_test.rb

@@ -6,52 +6,52 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class HasValueTest < Test::Unit::TestCase
-  
+
   include Mocha::ParameterMatchers
-  
+
   def test_should_match_hash_including_specified_value
     matcher = has_value('value_1')
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_value
     matcher = has_value('value_1')
     assert !matcher.matches?([{ :key_2 => 'value_2' }])
   end
-  
+
   def test_should_describe_matcher
     matcher = has_value('value_1')
     assert_equal "has_value('value_1')", matcher.mocha_inspect
   end
-  
+
   def test_should_match_hash_including_specified_value_with_nested_value_matcher
     matcher = has_value(equals('value_1'))
     assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_match_hash_not_including_specified_value_with_nested_value_matcher
     matcher = has_value(equals('value_1'))
     assert !matcher.matches?([{ :key_2 => 'value_2' }])
   end
-  
+
   def test_should_not_raise_error_on_empty_arguments
     matcher = has_value('value_1')
     assert_nothing_raised { matcher.matches?([]) }
   end
-  
+
   def test_should_not_match_empty_arguments
     matcher = has_value('value_1')
     assert !matcher.matches?([])
   end
-  
+
   def test_should_not_raise_error_on_argument_that_does_not_respond_to_values
     matcher = has_value('value_1')
     assert_nothing_raised { matcher.matches?(['value_1']) }
   end
-  
+
   def test_should_not_match_on_argument_that_does_not_respond_to_values
     matcher = has_value('value_1')
     assert !matcher.matches?(['value_1'])
   end
-  
-end
+
+end