floehopper-mocha 0.9.3.20081220175348

data/test/unit/mock_test.rb

@@ -0,0 +1,295 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mock'
+require 'mocha/expectation_error'
+require 'set'
+require 'simple_counter'
+
+class MockTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_set_single_expectation
+   mock = Mock.new
+   mock.expects(:method1).returns(1)
+   assert_nothing_raised(ExpectationError) do
+     assert_equal 1, mock.method1
+   end
+  end 
+
+  def test_should_build_and_store_expectations
+   mock = Mock.new
+   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 = Mock.new
+    assert_equal false, mock.everything_stubbed
+  end
+  
+  def test_should_stub_everything
+    mock = Mock.new
+    mock.stub_everything
+    assert_equal true, mock.everything_stubbed
+  end
+  
+  def test_should_be_able_to_extend_mock_object_with_module
+    mock = Mock.new
+    assert_nothing_raised(ExpectationError) { mock.extend(Module.new) }
+  end
+  
+  def test_should_be_equal
+    mock = Mock.new
+    assert_equal true, mock.eql?(mock)
+  end
+  
+  if RUBY_VERSION < '1.9'
+    OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ }
+  else
+    OBJECT_METHODS = STANDARD_OBJECT_PUBLIC_INSTANCE_METHODS.reject { |m| m =~ /^__.*__$/ || m == :object_id }
+  end
+  
+  def test_should_be_able_to_mock_standard_object_methods
+    mock = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    backtrace = Object.new
+    expectation = mock.expects(:method1, backtrace)
+    assert_equal backtrace, expectation.backtrace
+  end
+  
+  def test_should_pass_backtrace_into_stub
+    mock = Mock.new
+    backtrace = Object.new
+    stub = mock.stubs(:method1, backtrace)
+    assert_equal backtrace, stub.backtrace
+  end
+  
+  def test_should_create_and_add_stubs
+    mock = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    mock.stub_everything
+    result = nil
+    assert_nothing_raised(ExpectationError) do
+      result = mock.unexpected_method
+    end
+    assert_nil result
+  end
+  
+  def test_should_raise_assertion_error_for_unexpected_method_call
+    mock = Mock.new
+    error = assert_raise(ExpectationError) 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 = Mock.new
+    mock.expects(:method1)
+    mock.expects(:method2)
+    mock.method1
+    assert !mock.__verified__?
+  end
+  
+  def test_should_increment_assertion_counter_for_every_verified_expectation
+    mock = Mock.new
+    
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    mock.expects(:method1).returns(0)
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+  
+  def test_should_respond_to_expected_method
+    mock = Mock.new
+    mock.expects(:method1)
+    assert_equal true, mock.respond_to?(:method1)
+  end
+  
+  def test_should_not_respond_to_unexpected_method
+    mock = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    mock.responds_like(instance)
+    assert_equal false, mock.respond_to?(:invoked_method)
+  end
+  
+  def test_should_return_itself_to_allow_method_chaining
+    mock = Mock.new
+    assert_same mock.responds_like(Object.new), mock
+  end
+  
+  def test_should_not_raise_no_method_error_if_mock_is_not_restricted_to_respond_like_a_responder
+    instance = Class.new do
+      define_method(:respond_to?) { true }
+    end.new
+    mock = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    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 = Mock.new
+    assert_nothing_raised{ mock.respond_to?(:object_id, false) }
+  end
+  
+end

data/test/unit/mockery_test.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mockery'
+require 'mocha/state_machine'
+
+class MockeryTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_build_instance_of_mockery
+    mockery = Mockery.instance
+    assert_not_nil mockery
+    assert_kind_of Mockery, mockery
+  end
+  
+  def test_should_cache_instance_of_mockery
+    mockery_1 = Mockery.instance
+    mockery_2 = Mockery.instance
+    assert_same mockery_1, mockery_2
+  end
+  
+  def test_should_expire_mockery_instance_cache
+    mockery_1 = Mockery.instance
+    Mockery.reset_instance
+    mockery_2 = Mockery.instance
+    assert_not_same mockery_1, mockery_2
+  end
+  
+  def test_should_raise_expectation_error_because_not_all_expectations_are_satisfied
+    mockery = Mockery.new
+    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 }
+    assert_raises(ExpectationError) { mockery.verify }
+  end
+  
+  def test_should_reset_list_of_mocks_on_teardown
+    mockery = Mockery.new
+    mock = mockery.unnamed_mock { expects(:my_method) }
+    mockery.teardown
+    assert_nothing_raised(ExpectationError) { 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
+    stubba_1 = mockery.stubba
+    mockery.teardown
+    stubba_2 = mockery.stubba
+    assert_not_same stubba_1, stubba_2
+  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
+  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}", 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
+  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/multiple_yields_test.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/multiple_yields'
+
+class MultipleYieldsTest < Test::Unit::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

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/no_yields'
+
+class NoYieldsTest < Test::Unit::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

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+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
+      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
+    object = Object.new
+    object.define_instance_accessor(:called)
+    object.called = false
+    object.replace_instance_method(:object_id) { self.called = true; 1 }
+    if RUBY_VERSION < '1.9'
+      object.replace_instance_method(:id) { self.called = true; 1 }
+    end
+    object.mocha_inspect
+    assert_equal false, object.called
+  end
+  
+end

data/test/unit/object_test.rb

@@ -0,0 +1,82 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/object'
+require 'mocha/mockery'
+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
+    assert_not_nil mocha
+    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)
+    assert_equal klass, any_instance.stubba_object
+  end
+  
+end

data/test/unit/parameter_matchers/all_of_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/all_of'
+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

data/test/unit/parameter_matchers/any_of_test.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/any_of'
+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

data/test/unit/parameter_matchers/anything_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+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

data/test/unit/parameter_matchers/equals_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), "..", "..", "test_helper")
+
+require 'mocha/parameter_matchers/equals'
+require 'mocha/inspect'
+
+class EqualsTest < Test::Unit::TestCase
+
+  include Mocha::ParameterMatchers
+
+  def test_should_match_object_that_equals_value
+    matcher = equals('x')
+    assert matcher.matches?(['x'])
+  end
+
+  def test_should_not_match_object_that_does_not_equal_value
+    matcher = equals('x')
+    assert !matcher.matches?(['y'])
+  end
+
+  def test_should_describe_matcher
+    matcher = equals('x')
+    assert_equal "'x'", matcher.mocha_inspect
+  end
+
+end