mocha 1.5.0 → 1.10.0.alpha

data/test/unit/mockery_test.rb

@@ -2,12 +2,9 @@ require File.expand_path('../../test_helper', __FILE__)
 require 'mocha/mockery'
 require 'mocha/state_machine'
 require 'mocha/expectation_error_factory'
-require 'deprecation_disabler'
 
 class MockeryTest < Mocha::TestCase
-
   include Mocha
-  include DeprecationDisabler
 
   def setup
     Mockery.setup
@@ -31,34 +28,33 @@ class MockeryTest < Mocha::TestCase
   end
 
   def test_should_cache_instance_of_mockery
-    mockery_1 = Mockery.instance
-    mockery_2 = Mockery.instance
-    assert_same mockery_1, mockery_2
+    mockery1 = Mockery.instance
+    mockery2 = Mockery.instance
+    assert_same mockery1, mockery2
   end
 
   def test_should_expire_mockery_instance_cache
-    mockery_1 = Mockery.instance
+    mockery1 = Mockery.instance
     Mockery.teardown
-    mockery_2 = Mockery.instance
-    assert_not_same mockery_1, mockery_2
+    mockery2 = Mockery.instance
+    assert_not_same mockery1, mockery2
   end
 
   def test_should_raise_expectation_error_because_not_all_expectations_are_satisfied
     mockery = Mockery.new
-    disable_deprecations do
-      mock_1 = mockery.named_mock('mock-1') { expects(:method_1) }
-      mock_2 = mockery.named_mock('mock-2') { expects(:method_2) }
-      1.times { mock_1.method_1 }
-      0.times { mock_2.method_2 }
-    end
+    mock1 = mockery.named_mock('mock-1')
+    mock1.expects(:method_1)
+    mock2 = mockery.named_mock('mock-2')
+    mock2.expects(:method_2)
+    1.times { mock1.method_1 }
+    0.times { mock2.method_2 }
     assert_raises(ExpectationErrorFactory.exception_class) { mockery.verify }
   end
 
   def test_should_reset_list_of_mocks_on_teardown
     mockery = Mockery.new
-    disable_deprecations do
-      mockery.unnamed_mock { expects(:my_method) }
-    end
+    mock = mockery.unnamed_mock
+    mock.expects(:my_method)
     mockery.teardown
     assert_nothing_raised(ExpectationErrorFactory.exception_class) { mockery.verify }
   end
@@ -71,10 +67,10 @@ class MockeryTest < Mocha::TestCase
 
   def test_should_build_new_instance_of_stubba_on_teardown
     mockery = Mockery.new
-    stubba_1 = mockery.stubba
+    stubba1 = mockery.stubba
     mockery.teardown
-    stubba_2 = mockery.stubba
-    assert_not_same stubba_1, stubba_2
+    stubba2 = mockery.stubba
+    assert_not_same stubba1, stubba2
   end
 
   def test_should_build_and_store_new_state_machine
@@ -93,8 +89,12 @@ class MockeryTest < Mocha::TestCase
 
   class FakeMethod
     def stub; end
+
     def unstub; end
-    def matches?(other); true; end
+
+    def matches?(_other)
+      true
+    end
   end
 
   def test_should_unstub_all_methods_on_teardown
@@ -108,51 +108,51 @@ class MockeryTest < Mocha::TestCase
   def test_should_display_object_id_for_mocha_inspect_if_mock_has_no_name
     mockery = Mockery.new
     mock = mockery.unnamed_mock
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.mocha_inspect
+    assert_match Regexp.new('^#<Mock:0x[0-9A-Fa-f]{1,12}>$'), mock.mocha_inspect
   end
 
   def test_should_display_object_id_for_inspect_if_mock_has_no_name
     mockery = Mockery.new
     mock = mockery.unnamed_mock
-    assert_match Regexp.new("^#<Mock:0x[0-9A-Fa-f]{1,12}>$"), mock.inspect
+    assert_match Regexp.new('^#<Mock:0x[0-9A-Fa-f]{1,12}>$'), mock.inspect
   end
 
   def test_should_display_name_for_mocha_inspect_if_mock_has_string_name
     mockery = Mockery.new
     mock = mockery.named_mock('named_mock')
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
   end
 
   def test_should_display_name_for_mocha_inspect_if_mock_has_symbol_name
     mockery = Mockery.new
     mock = mockery.named_mock(:named_mock)
-    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
   end
 
   def test_should_display_name_for_inspect_if_mock_has_string_name
     mockery = Mockery.new
     mock = mockery.named_mock('named_mock')
-    assert_equal "#<Mock:named_mock>", mock.inspect
+    assert_equal '#<Mock:named_mock>', mock.inspect
   end
 
   def test_should_display_name_for_inspect_if_mock_has_symbol_name
     mockery = Mockery.new
     mock = mockery.named_mock(:named_mock)
-    assert_equal "#<Mock:named_mock>", mock.inspect
+    assert_equal '#<Mock:named_mock>', mock.inspect
   end
 
   def test_should_display_impersonated_object_for_mocha_inspect
     mockery = Mockery.new
     instance = Object.new
     mock = mockery.mock_impersonating(instance)
-    assert_equal "#{instance.mocha_inspect}", mock.mocha_inspect
+    assert_equal instance.mocha_inspect.to_s, mock.mocha_inspect
   end
 
   def test_should_display_impersonated_object_for_inspect
     mockery = Mockery.new
     instance = Object.new
     mock = mockery.mock_impersonating(instance)
-    assert_equal "#{instance.mocha_inspect}", mock.inspect
+    assert_equal instance.mocha_inspect.to_s, mock.inspect
   end
 
   class FakeClass; end
@@ -160,13 +160,12 @@ class MockeryTest < Mocha::TestCase
   def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_mocha_inspect
     mockery = Mockery.new
     mock = mockery.mock_impersonating_any_instance_of(FakeClass)
-    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.mocha_inspect
+    assert_equal '#<AnyInstance:MockeryTest::FakeClass>', mock.mocha_inspect
   end
 
   def test_should_display_any_instance_prefix_followed_by_class_whose_instances_are_being_impersonated_for_inspect
     mockery = Mockery.new
     mock = mockery.mock_impersonating_any_instance_of(FakeClass)
-    assert_equal "#<AnyInstance:MockeryTest::FakeClass>", mock.inspect
+    assert_equal '#<AnyInstance:MockeryTest::FakeClass>', mock.inspect
   end
-
 end

data/test/unit/module_methods_test.rb

@@ -1,19 +1,16 @@
 require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/module_methods'
 require 'mocha/object_methods'
 
 class ModuleMethodsTest < Mocha::TestCase
-
   def setup
-    @module = Module.new.extend(Mocha::ModuleMethods, Mocha::ObjectMethods)
+    @module = Module.new.extend(Mocha::ObjectMethods)
   end
 
   def test_should_use_stubba_module_method_for_module
-    assert_equal Mocha::ModuleMethod, @module.stubba_method
+    assert_equal Mocha::InstanceMethod, @module.stubba_method
   end
 
   def test_should_stub_self_for_module
     assert_equal @module, @module.stubba_object
   end
-
 end

data/test/unit/multiple_yields_test.rb

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

data/test/unit/no_yields_test.rb

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

data/test/unit/object_inspect_test.rb

@@ -4,6 +4,7 @@ require 'mocha/inspect'
 require 'method_definer'
 
 class ObjectInspectTest < Mocha::TestCase
+  include MethodDefiner
 
   def test_should_return_default_string_representation_of_object_not_including_instance_variables
     object = Object.new
@@ -11,7 +12,7 @@ class ObjectInspectTest < Mocha::TestCase
       attr_accessor :attribute
     end
     object.attribute = 'instance_variable'
-    assert_match Regexp.new("^#<Object:0x[0-9A-Fa-f]{1,8}.*>$"), object.mocha_inspect
+    assert_match Regexp.new('^#<Object:0x[0-9A-Fa-f]{1,8}.*>$'), object.mocha_inspect
     assert_no_match(/instance_variable/, object.mocha_inspect)
   end
 
@@ -26,14 +27,34 @@ class ObjectInspectTest < Mocha::TestCase
   def test_should_use_underscored_id_instead_of_object_id_or_id_so_that_they_can_be_stubbed
     calls = []
     object = Object.new
-    object.replace_instance_method(:id) { calls << :id; return 1 } if Mocha::PRE_RUBY_V19
-    object.replace_instance_method(:object_id) { calls << :object_id; return 1 }
-    object.replace_instance_method(:__id__) { calls << :__id__; return 1 }
-    object.replace_instance_method(:inspect) { "object-description" }
+    if Mocha::PRE_RUBY_V19
+      replace_instance_method(object, :id) do
+        calls << :id
+        return 1
+      end
+    end
+    replace_instance_method(object, :object_id) do
+      calls << :object_id
+      return 1
+    end
+    replace_instance_method(object, :__id__) do
+      calls << :__id__
+      return 1
+    end
+    replace_instance_method(object, :inspect) { 'object-description' }
 
     object.mocha_inspect
 
     assert_equal [:__id__], calls.uniq
   end
 
+  def test_should_not_call_object_instance_format_method
+    object = Object.new
+    class << object
+      def format(*)
+        'internal_format'
+      end
+    end
+    assert_no_match(/internal_format/, object.mocha_inspect)
+  end
 end

data/test/unit/object_methods_test.rb

@@ -3,9 +3,9 @@ require 'mocha/object_methods'
 require 'mocha/mockery'
 require 'mocha/mock'
 require 'mocha/expectation_error_factory'
+require 'mocha/names'
 
 class ObjectMethodsTest < Mocha::TestCase
-
   def setup
     Mocha::Mockery.setup
     @object = Object.new.extend(Mocha::ObjectMethods)
@@ -19,13 +19,24 @@ class ObjectMethodsTest < Mocha::TestCase
     mocha = @object.mocha
     assert_not_nil mocha
     assert mocha.is_a?(Mocha::Mock)
-    assert_equal @object.mocha_inspect, mocha.mocha_inspect
+    expected_name = Mocha::ImpersonatingName.new(@object).mocha_inspect
+    assert_equal expected_name, mocha.mocha_inspect
+  end
+
+  def test_should_not_build_mocha_if_instantiate_is_false
+    assert_nil @object.mocha(false)
   end
 
   def test_should_reuse_existing_mocha
-    mocha_1 = @object.mocha
-    mocha_2 = @object.mocha
-    assert_equal mocha_1, mocha_2
+    mocha1 = @object.mocha
+    mocha2 = @object.mocha
+    assert_equal mocha1, mocha2
+  end
+
+  def test_should_reuse_existing_mocha_even_if_instantiate_is_false
+    mocha1 = @object.mocha
+    mocha2 = @object.mocha(false)
+    assert_equal mocha1, mocha2
   end
 
   def test_should_reset_mocha
@@ -33,7 +44,7 @@ class ObjectMethodsTest < Mocha::TestCase
   end
 
   def test_should_use_stubba_instance_method_for_object
-    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
+    assert_equal Mocha::InstanceMethod, @object.stubba_method
   end
 
   def test_should_stub_self_for_object
@@ -41,12 +52,12 @@ class ObjectMethodsTest < Mocha::TestCase
   end
 
   def test_nobody_expects_the_spanish_inquisition
-    assert_raise(Mocha::ExpectationErrorFactory.exception_class) { @object.expects(:the_spanish_inquisition) }
+    assert_raises(Mocha::ExpectationErrorFactory.exception_class) { @object.expects(:the_spanish_inquisition) }
   end
 
   def test_should_alias_object_method
     klass = Class.new { def self.method_x; end }
+    klass.extend(Mocha::ObjectMethods)
     assert_equal klass._method(:method_x), klass.method(:method_x)
   end
-
 end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AllOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_all_matchers_match
@@ -22,5 +21,4 @@ class AllOfTest < Mocha::TestCase
     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

data/test/unit/parameter_matchers/any_of_test.rb

@@ -5,7 +5,6 @@ require 'mocha/inspect'
 require 'stub_matcher'
 
 class AnyOfTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_if_any_matchers_match
@@ -22,5 +21,4 @@ class AnyOfTest < Mocha::TestCase
     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

data/test/unit/parameter_matchers/anything_test.rb

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

data/test/unit/parameter_matchers/equals_test.rb

@@ -4,7 +4,6 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/inspect'
 
 class EqualsTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_object_that_equals_value
@@ -19,7 +18,6 @@ class EqualsTest < Mocha::TestCase
 
   def test_should_describe_matcher
     matcher = equals('x')
-    assert_equal %{"x"}, matcher.mocha_inspect
+    assert_equal %("x"), matcher.mocha_inspect
   end
-
 end

data/test/unit/parameter_matchers/equivalent_uri_test.rb

@@ -1,24 +1,14 @@
 require File.expand_path('../../../test_helper', __FILE__)
-require 'deprecation_disabler'
 require 'mocha/parameter_matchers/equivalent_uri'
 
 class EquivalentUriMatchesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
-  include DeprecationDisabler
 
   def test_should_match_identical_uri
     matcher = equivalent_uri('http://example.com/foo?a=1&b=2')
     assert matcher.matches?(['http://example.com/foo?a=1&b=2'])
   end
 
-  def test_should_support_legacy_matcher_method
-    disable_deprecations do
-      matcher = has_equivalent_query_string('http://example.com/foo?a=1&b=2')
-      assert matcher.matches?(['http://example.com/foo?a=1&b=2'])
-    end
-  end
-
   def test_should_match_uri_with_rearranged_query_string
     matcher = equivalent_uri('http://example.com/foo?b=2&a=1')
     assert matcher.matches?(['http://example.com/foo?a=1&b=2'])

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -1,11 +1,10 @@
 require File.expand_path('../../../test_helper', __FILE__)
 
 require 'mocha/parameter_matchers/has_entries'
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 require 'mocha/inspect'
 
 class HasEntriesTest < Mocha::TestCase
-
   include Mocha::ParameterMatchers
 
   def test_should_match_hash_including_specified_entries
@@ -23,7 +22,9 @@ class HasEntriesTest < Mocha::TestCase
     description = matcher.mocha_inspect
     matches = /has_entries\((.*)\)/.match(description)
     assert_not_nil matches[0]
+    # rubocop:disable Security/Eval
     entries = eval(matches[1], binding, __FILE__, __LINE__)
+    # rubocop:enable Security/Eval
     assert_equal 'value_1', entries[:key_1]
     assert_equal 'value_2', entries[:key_2]
   end
@@ -47,5 +48,4 @@ class HasEntriesTest < Mocha::TestCase
     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