mocha 0.5.6 → 3.1.0

data/test/unit/auto_verify_test.rb

@@ -1,129 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/auto_verify'
-require 'method_definer'
-
-class AutoVerifyTest < Test::Unit::TestCase
-  
-  attr_reader :test_case
-  
-  def setup
-    @test_case = Object.new
-    class << test_case
-      include Mocha::AutoVerify
-    end
-  end
-  
-  def test_should_build_mock
-    mock = test_case.mock
-    assert mock.is_a?(Mocha::Mock)
-  end
-  
-  def test_should_add_expectations_to_mock
-    mock = test_case.mock(:method_1 => 'result_1', :method_2 => 'result_2')
-    assert_equal 'result_1', mock.method_1
-    assert_equal 'result_2', mock.method_2
-  end
-  
-  def test_should_build_stub
-    stub = test_case.stub
-    assert stub.is_a?(Mocha::Mock)
-  end
-  
-  def test_should_add_expectation_to_stub
-    stub = test_case.stub(:method_1 => 'result_1', :method_2 => 'result_2')
-    assert_equal 'result_1', stub.method_1
-    assert_equal 'result_2', stub.method_2
-  end
-  
-  def test_should_build_stub_that_stubs_all_methods
-    stub = test_case.stub_everything
-    assert stub.everything_stubbed
-  end
-  
-  def test_should_add_expectations_to_stub_that_stubs_all_methods
-    stub = test_case.stub_everything(:method_1 => 'result_1', :method_2 => 'result_2')
-    assert_equal 'result_1', stub.method_1
-    assert_equal 'result_2', stub.method_2
-  end
-  
-  def test_should_always_new_mock
-    assert_not_equal test_case.mock, test_case.mock
-  end
-  
-  def test_should_always_build_new_stub
-    assert_not_equal test_case.stub, test_case.stub
-  end
-  
-  def test_should_always_build_new_stub_that_stubs_all_methods
-    assert_not_equal test_case.stub, test_case.stub
-  end
-  
-  def test_should_store_each_new_mock
-    expected = Array.new(3) { test_case.mock }
-    assert_equal expected, test_case.mocks
-  end
-  
-  def test_should_store_each_new_stub
-    expected = Array.new(3) { test_case.stub }
-    assert_equal expected, test_case.mocks
-  end
-  
-  def test_should_store_each_new_stub_that_stubs_all_methods
-    expected = Array.new(3) { test_case.stub_everything }
-    assert_equal expected, test_case.mocks
-  end
-  
-  def test_should_verify_each_mock
-    mocks = Array.new(3) do
-      mock = Object.new
-      mock.define_instance_accessor(:verify_called)
-      class << mock
-        def verify(&block)
-          self.verify_called = true
-        end
-      end
-      mock
-    end
-    test_case.replace_instance_method(:mocks)  { mocks }
-    test_case.verify_mocks
-    assert mocks.all? { |mock| mock.verify_called }
-  end
-  
-  def test_should_yield_to_block_for_each_assertion
-    mock_class = Class.new do
-      def verify(&block); yield; end
-    end
-    mock = mock_class.new
-    test_case.replace_instance_method(:mocks)  { [mock] }
-    yielded = false
-    test_case.verify_mocks { yielded = true }
-    assert yielded
-  end
-  
-  def test_should_reset_mocks_on_teardown
-    mock = Class.new { define_method(:verify) {} }.new
-    test_case.mocks << mock
-    test_case.teardown_mocks
-    assert test_case.mocks.empty?
-  end
-  
-  def test_should_create_named_mock
-    mock = test_case.mock('named_mock')
-    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
-  end
-  
-  def test_should_create_named_stub
-    stub = test_case.stub('named_stub')
-    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
-  end
-  
-  def test_should_create_named_stub_that_stubs_all_methods
-    stub = test_case.stub_everything('named_stub')
-    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
-  end
-  
-  def test_should_build_sequence
-    assert_not_nil test_case.sequence('name')
-  end
-  
-end

data/test/unit/central_test.rb

@@ -1,124 +0,0 @@
-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)
-    
-    method.verify
-  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)
-    
-    method.verify
-  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
-    method_1.verify
-    method_2.verify
-  end
-  
-  def test_should_collect_mocks_from_all_methods
-    method_1 = Mock.new
-    method_1.stubs(:mock).returns(:mock_1)
-
-    method_2 = Mock.new
-    method_2.stubs(:mock).returns(:mock_2)
-
-    stubba = Central.new
-    stubba.stubba_methods = [method_1, method_2]
-    
-    assert_equal 2, stubba.unique_mocks.length
-    assert stubba.unique_mocks.include?(:mock_1)
-    assert stubba.unique_mocks.include?(:mock_2)
-  end
-
-  def test_should_return_unique_mochas
-    method_1 = Mock.new
-    method_1.stubs(:mock).returns(:mock_1)
-
-    method_2 = Mock.new
-    method_2.stubs(:mock).returns(:mock_1)
-
-    stubba = Central.new
-    stubba.stubba_methods = [method_1, method_2]
-    
-    assert_equal [:mock_1], stubba.unique_mocks
-  end
-  
-  def test_should_call_verify_on_all_unique_mocks
-    mock_class = Class.new do
-      attr_accessor :verify_called
-      def verify
-        self.verify_called = true
-      end
-    end
-    mocks = [mock_class.new, mock_class.new]
-    stubba = Central.new
-    stubba.replace_instance_method(:unique_mocks) { mocks }
-    
-    stubba.verify_all
-    
-    assert mocks.all? { |mock| mock.verify_called }
-  end
-
-  def test_should_call_verify_on_all_unique_mochas
-    mock_class = Class.new do
-      def verify(&block)
-        yield if block_given?
-      end
-    end
-    stubba = Central.new
-    stubba.replace_instance_method(:unique_mocks) { [mock_class.new] }
-    yielded = false
-    
-    stubba.verify_all { yielded = true }
-    
-    assert yielded
-  end
-
-end

data/test/unit/class_method_test.rb

@@ -1,200 +0,0 @@
-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)
-  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)
-  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)
-  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)
-    assert_match(/question_mark_substituted_character_63/, method.hidden_method)
-  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)
-    assert_match(/exclamation_mark_substituted_character_33/, method.hidden_method)
-  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)
-    assert_match(/equals_sign_substituted_character_61/, method.hidden_method)
-  end
-
-  def test_should_provide_hidden_version_of_method_name_substituting_brackets
-    method = ClassMethod.new(nil, :[])
-    assert_no_match(/\[\]/, method.hidden_method)
-    assert_match(/substituted_character_91__substituted_character_93/, method.hidden_method)
-  end
-  
-  def test_should_provide_hidden_version_of_method_name_substituting_plus_sign
-    method = ClassMethod.new(nil, :+)
-    assert_no_match(/\+/, method.hidden_method)
-    assert_match(/substituted_character_43/, method.hidden_method)
-  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
-    mocha.verify
-  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
-
-end

data/test/unit/date_time_inspect_test.rb

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

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'mocha/expectation_error'
-
-class ExpectationErrorTest < Test::Unit::TestCase
-  
-  include Mocha
-  
-  def test_should_exclude_mocha_locations_from_backtrace
-    mocha_lib = "/username/workspace/mocha_wibble/lib/"
-    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
-    expectation_error = ExpectationError.new(nil, backtrace, mocha_lib)
-    assert_equal ['/keep/me'], expectation_error.backtrace
-  end
-
-  def test_should_determine_path_for_mocha_lib_directory
-    assert_match Regexp.new("/lib/$"), ExpectationError::LIB_DIRECTORY
-  end
-  
-  def test_should_set_error_message
-    expectation_error = ExpectationError.new('message')
-    assert_equal 'message', expectation_error.message
-  end
-
-end

data/test/unit/expectation_list_test.rb

@@ -1,75 +0,0 @@
-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 expectation2, expectation_list.detect(:my_method, :argument3, :argument4)
-  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.detect(:my_method, :argument1, :argument2)
-  end
-
-  def test_should_find_most_recent_matching_expectation_but_give_preference_to_those_allowing_invocations
-    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.detect(:my_method)
-  end
-
-  def test_should_find_most_recent_matching_expectation_if_no_matching_expectations_allow_invocations
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method)
-    expectation2 = Expectation.new(nil, :my_method)
-    expectation1.define_instance_method(:invocations_allowed?) { false }
-    expectation2.define_instance_method(:invocations_allowed?) { false }
-    expectation_list.add(expectation1)
-    expectation_list.add(expectation2)
-    assert_same expectation2, expectation_list.detect(:my_method)
-  end
-
-  def test_should_find_expectations_for_the_same_method_no_matter_what_the_arguments
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
-    expectation_list.add(expectation1)
-    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
-    expectation_list.add(expectation2)
-    assert_equal [expectation1, expectation2].to_set, expectation_list.similar(:my_method).to_set
-  end
-  
-  def test_should_ignore_expectations_for_different_methods
-    expectation_list = ExpectationList.new
-    expectation1 = Expectation.new(nil, :method1).with(:argument1, :argument2)
-    expectation_list.add(expectation1)
-    expectation2 = Expectation.new(nil, :method2).with(:argument1, :argument2)
-    expectation_list.add(expectation2)
-    assert_equal [expectation2], expectation_list.similar(:method2)
-  end
-  
-end

data/test/unit/expectation_raiser_test.rb

@@ -1,28 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "test_helper")
-
-require 'mocha/exception_raiser'
-
-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_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
-    raiser = ExceptionRaiser.new(Interrupt, nil)
-    assert_raises(Interrupt) { raiser.evaluate }
-  end
-
-end