mocha 1.8.0 → 1.13.0

data/test/unit/mock_test.rb

@@ -1,363 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/ruby_version'
-require 'mocha/mock'
-require 'mocha/expectation_error_factory'
-require 'set'
-require 'simple_counter'
-
-class MockTest < Mocha::TestCase
-  include Mocha
-
-  def test_should_set_single_expectation
-    mock = build_mock
-    mock.expects(:method1).returns(1)
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) do
-      assert_equal 1, mock.method1
-    end
-  end
-
-  def test_should_build_and_store_expectations
-    mock = build_mock
-    expectation = mock.expects(:method1)
-    assert_not_nil expectation
-    assert_equal [expectation], mock.__expectations__.to_a
-  end
-
-  def test_should_not_stub_everything_by_default
-    mock = build_mock
-    assert_equal false, mock.everything_stubbed
-  end
-
-  def test_should_stub_everything
-    mock = build_mock
-    mock.stub_everything
-    assert_equal true, mock.everything_stubbed
-  end
-
-  def test_should_be_able_to_extend_mock_object_with_module
-    mock = build_mock
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) { mock.extend(Module.new) }
-  end
-
-  def test_should_be_equal
-    mock = build_mock
-    assert_equal true, mock.eql?(mock)
-  end
-
-  EXCLUDED_METHODS = {
-    true => %w[
-      method_missing
-      singleton_method_undefined
-      initialize
-    ],
-    false => [
-      :object_id,
-      :method_missing,
-      :singleton_method_undefined,
-      :initialize,
-      :String,
-      :singleton_method_added
-    ]
-  }.freeze
-
-  OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject do |m|
-    m =~ /^__.*__$/ || EXCLUDED_METHODS[PRE_RUBY_V19].include?(m)
-  end
-
-  def test_should_be_able_to_mock_standard_object_methods
-    mock = build_mock
-    OBJECT_METHODS.each { |method| mock.__expects__(method.to_sym).returns(method) }
-    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-    assert mock.__verified__?
-  end
-
-  def test_should_be_able_to_stub_standard_object_methods
-    mock = build_mock
-    OBJECT_METHODS.each { |method| mock.__stubs__(method.to_sym).returns(method) }
-    OBJECT_METHODS.each { |method| assert_equal method, mock.__send__(method.to_sym) }
-  end
-
-  def test_should_create_and_add_expectations
-    mock = build_mock
-    expectation1 = mock.expects(:method1)
-    expectation2 = mock.expects(:method2)
-    assert_equal [expectation1, expectation2].to_set, mock.__expectations__.to_set
-  end
-
-  def test_should_pass_backtrace_into_expectation
-    mock = build_mock
-    backtrace = Object.new
-    expectation = mock.expects(:method1, backtrace)
-    assert_equal backtrace, expectation.backtrace
-  end
-
-  def test_should_pass_backtrace_into_stub
-    mock = build_mock
-    backtrace = Object.new
-    stub = mock.stubs(:method1, backtrace)
-    assert_equal backtrace, stub.backtrace
-  end
-
-  def test_should_create_and_add_stubs
-    mock = build_mock
-    stub1 = mock.stubs(:method1)
-    stub2 = mock.stubs(:method2)
-    assert_equal [stub1, stub2].to_set, mock.__expectations__.to_set
-  end
-
-  def test_should_invoke_expectation_and_return_result
-    mock = build_mock
-    mock.expects(:my_method).returns(:result)
-    result = mock.my_method
-    assert_equal :result, result
-  end
-
-  def test_should_not_raise_error_if_stubbing_everything
-    mock = build_mock
-    mock.stub_everything
-    result = nil
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) do
-      result = mock.unexpected_method
-    end
-    assert_nil result
-  end
-
-  def test_should_raise_assertion_error_for_unexpected_method_call
-    mock = build_mock
-    error = assert_raise(ExpectationErrorFactory.exception_class) do
-      mock.unexpected_method_called(:my_method, :argument1, :argument2)
-    end
-    assert_match(/unexpected invocation/, error.message)
-    assert_match(/my_method/, error.message)
-    assert_match(/argument1/, error.message)
-    assert_match(/argument2/, error.message)
-  end
-
-  def test_should_not_verify_successfully_because_not_all_expectations_have_been_satisfied
-    mock = build_mock
-    mock.expects(:method1)
-    mock.expects(:method2)
-    mock.method1
-    assert !mock.__verified__?
-  end
-
-  def test_should_increment_assertion_counter_for_every_verified_expectation
-    mock = build_mock
-
-    mock.expects(:method1)
-    mock.method1
-
-    mock.expects(:method2)
-    mock.method2
-
-    assertion_counter = SimpleCounter.new
-
-    mock.__verified__?(assertion_counter)
-
-    assert_equal 2, assertion_counter.count
-  end
-
-  def test_should_yield_supplied_parameters_to_block
-    mock = build_mock
-    parameters_for_yield = [1, 2, 3]
-    mock.expects(:method1).yields(*parameters_for_yield)
-    yielded_parameters = nil
-    mock.method1 { |*parameters| yielded_parameters = parameters }
-    assert_equal parameters_for_yield, yielded_parameters
-  end
-
-  def test_should_set_up_multiple_expectations_with_return_values
-    mock = build_mock
-    mock.expects(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-
-  def test_should_set_up_multiple_stubs_with_return_values
-    mock = build_mock
-    mock.stubs(:method1 => :result1, :method2 => :result2)
-    assert_equal :result1, mock.method1
-    assert_equal :result2, mock.method2
-  end
-
-  def test_should_keep_returning_specified_value_for_stubs
-    mock = build_mock
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_keep_returning_specified_value_for_expects
-    mock = build_mock
-    mock.expects(:method1).times(2).returns(1)
-    assert_equal 1, mock.method1
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_expects
-    mock = build_mock
-    mock.expects(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_stubs
-    mock = build_mock
-    mock.stubs(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_stubs_or_expects
-    mock = build_mock
-    mock.stubs(:method1).returns(0)
-    mock.expects(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_match_most_recent_call_to_expects_or_stubs
-    mock = build_mock
-    mock.expects(:method1).returns(0)
-    mock.stubs(:method1).returns(1)
-    assert_equal 1, mock.method1
-  end
-
-  def test_should_respond_to_expected_method
-    mock = build_mock
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?(:method1)
-  end
-
-  def test_should_respond_to_expected_method_as_string
-    mock = build_mock
-    mock.expects(:method1)
-    assert_equal true, mock.respond_to?('method1')
-  end
-
-  def test_should_not_respond_to_unexpected_method
-    mock = build_mock
-    assert_equal false, mock.respond_to?(:method1)
-  end
-
-  def test_should_respond_to_methods_which_the_responder_does_responds_to
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    assert_equal true, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_not_respond_to_methods_which_the_responder_does_not_responds_to
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    assert_equal false, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_respond_to_methods_which_the_responder_instance_does_responds_to
-    klass = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end
-    mock = build_mock
-    mock.responds_like_instance_of(klass)
-    assert_equal true, mock.respond_to?(:invoked_method)
-  end
-
-  def test_should_not_respond_to_methods_which_the_responder_instance_does_not_responds_to
-    klass = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-    end
-    mock = build_mock
-    mock.responds_like_instance_of(klass)
-    assert_equal false, mock.respond_to?(:invoked_method)
-  end
-
-  def test_respond_like_should_return_itself_to_allow_method_chaining
-    mock = build_mock
-    assert_same mock.responds_like(Object.new), mock
-  end
-
-  def test_respond_like_instance_of_should_return_itself_to_allow_method_chaining
-    mock = build_mock
-    assert_same mock.responds_like_instance_of(Object), mock
-  end
-
-  def test_should_not_raise_no_method_error_if_mock_is_not_restricted_to_respond_like_a_responder
-    mock = build_mock
-    mock.stubs(:invoked_method)
-    assert_nothing_raised(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_not_raise_no_method_error_if_responder_does_respond_to_invoked_method
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| true }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    assert_nothing_raised(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_raise_no_method_error_if_responder_does_not_respond_to_invoked_method
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-      define_method(:mocha_inspect) { 'mocha_inspect' }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    assert_raises(NoMethodError) { mock.invoked_method }
-  end
-
-  def test_should_raise_no_method_error_with_message_indicating_that_mock_is_constrained_to_respond_like_responder
-    instance = Class.new do
-      define_method(:respond_to?) { |_symbol| false }
-      define_method(:mocha_inspect) { 'mocha_inspect' }
-    end.new
-    mock = build_mock
-    mock.responds_like(instance)
-    mock.stubs(:invoked_method)
-    begin
-      mock.invoked_method
-    rescue NoMethodError => e
-      assert_match(/which responds like mocha_inspect/, e.message)
-    end
-  end
-
-  def test_should_handle_respond_to_with_private_methods_param_without_error
-    mock = build_mock
-    assert_nothing_raised { mock.respond_to?(:object_id, false) }
-  end
-
-  def test_should_respond_to_any_method_if_stubbing_everything
-    mock = build_mock
-    mock.stub_everything
-    assert mock.respond_to?(:abc)
-    assert mock.respond_to?(:xyz)
-  end
-
-  def test_should_remove_expectation_for_unstubbed_method
-    mock = build_mock
-    mock.expects(:method1)
-    mock.unstub(:method1)
-    e = assert_raises(ExpectationErrorFactory.exception_class) { mock.method1 }
-    assert_match(/unexpected invocation/, e.message)
-  end
-
-  unless PRE_RUBY_V19
-    def test_expectation_is_defined_on_mock
-      mock = build_mock
-      mock.expects(:method1)
-      assert defined? mock.method1
-    end
-  end
-
-  private
-
-  def build_mock
-    Mock.new(nil)
-  end
-end

data/test/unit/mockery_test.rb

@@ -1,174 +0,0 @@
-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
-  end
-
-  def teardown
-    Mockery.teardown
-  end
-
-  def test_should_return_null_mockery_if_not_setup
-    Mockery.teardown
-    mockery = Mockery.instance
-    assert_not_nil mockery
-    assert_kind_of Mockery::Null, mockery
-  end
-
-  def test_should_return_instance_of_mockery
-    mockery = Mockery.instance
-    assert_not_nil mockery
-    assert_kind_of Mockery, mockery
-  end
-
-  def test_should_cache_instance_of_mockery
-    mockery1 = Mockery.instance
-    mockery2 = Mockery.instance
-    assert_same mockery1, mockery2
-  end
-
-  def test_should_expire_mockery_instance_cache
-    mockery1 = Mockery.instance
-    Mockery.teardown
-    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
-      mock1 = mockery.named_mock('mock-1') { expects(:method_1) }
-      mock2 = mockery.named_mock('mock-2') { expects(:method_2) }
-      1.times { mock1.method_1 }
-      0.times { mock2.method_2 }
-    end
-    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
-    mockery.teardown
-    assert_nothing_raised(ExpectationErrorFactory.exception_class) { mockery.verify }
-  end
-
-  def test_should_build_instance_of_stubba_on_instantiation
-    mockery = Mockery.new
-    assert_not_nil mockery.stubba
-    assert_kind_of Central, mockery.stubba
-  end
-
-  def test_should_build_new_instance_of_stubba_on_teardown
-    mockery = Mockery.new
-    stubba1 = mockery.stubba
-    mockery.teardown
-    stubba2 = mockery.stubba
-    assert_not_same stubba1, stubba2
-  end
-
-  def test_should_build_and_store_new_state_machine
-    mockery = Mockery.new
-    mockery.new_state_machine('state-machine-name')
-    assert_equal 1, mockery.state_machines.length
-    assert_kind_of StateMachine, mockery.state_machines[0]
-  end
-
-  def test_should_reset_list_of_state_machines_on_teardown
-    mockery = Mockery.new
-    mockery.new_state_machine('state-machine-name')
-    mockery.teardown
-    assert_equal 0, mockery.state_machines.length
-  end
-
-  class FakeMethod
-    def stub; end
-
-    def unstub; end
-
-    def matches?(_other)
-      true
-    end
-  end
-
-  def test_should_unstub_all_methods_on_teardown
-    mockery = Mockery.new
-    stubba = mockery.stubba
-    stubba.stub(FakeMethod.new)
-    mockery.teardown
-    assert stubba.stubba_methods.empty?
-  end
-
-  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
-  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
-  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
-  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
-  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
-  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
-  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.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.to_s, mock.inspect
-  end
-
-  class FakeClass; end
-
-  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
-  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
-  end
-end

data/test/unit/module_methods_test.rb

@@ -1,17 +0,0 @@
-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)
-  end
-
-  def test_should_use_stubba_module_method_for_module
-    assert_equal Mocha::ModuleMethod, @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

@@ -1,16 +0,0 @@
-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
-    parameter_group = MultipleYields.new([1, 2, 3], [4, 5])
-    parameter_groups = []
-    parameter_group.each do |parameters|
-      parameter_groups << parameters
-    end
-    assert_equal [[1, 2, 3], [4, 5]], parameter_groups
-  end
-end

data/test/unit/no_yields_test.rb

@@ -1,16 +0,0 @@
-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
-    parameter_group = NoYields.new
-    parameter_groups = []
-    parameter_group.each do |parameters|
-      parameter_groups << parameters
-    end
-    assert_equal [], parameter_groups
-  end
-end

data/test/unit/object_inspect_test.rb

@@ -1,58 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/ruby_version'
-require 'mocha/inspect'
-require 'method_definer'
-
-class ObjectInspectTest < Mocha::TestCase
-  def test_should_return_default_string_representation_of_object_not_including_instance_variables
-    object = Object.new
-    class << object
-      attr_accessor :attribute
-    end
-    object.attribute = 'instance_variable'
-    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
-      define_method(:inspect) { 'custom_inspect' }
-    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
-    if Mocha::PRE_RUBY_V19
-      object.replace_instance_method(:id) do
-        calls << :id
-        return 1
-      end
-    end
-    object.replace_instance_method(:object_id) do
-      calls << :object_id
-      return 1
-    end
-    object.replace_instance_method(:__id__) do
-      calls << :__id__
-      return 1
-    end
-    object.replace_instance_method(: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

@@ -1,62 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-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)
-  end
-
-  def teardown
-    Mocha::Mockery.teardown
-  end
-
-  def test_should_build_mocha_referring_to_self
-    mocha = @object.mocha
-    assert_not_nil mocha
-    assert mocha.is_a?(Mocha::Mock)
-    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
-    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
-    assert_nil @object.reset_mocha
-  end
-
-  def test_should_use_stubba_instance_method_for_object
-    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
-  end
-
-  def test_should_stub_self_for_object
-    assert_equal @object, @object.stubba_object
-  end
-
-  def test_nobody_expects_the_spanish_inquisition
-    assert_raise(Mocha::ExpectationErrorFactory.exception_class) { @object.expects(:the_spanish_inquisition) }
-  end
-
-  def test_should_alias_object_method
-    klass = Class.new { def self.method_x; end }
-    assert_equal klass._method(:method_x), klass.method(:method_x)
-  end
-end