mocha 0.3.3 → 0.4.0

data/test/mocha/inspect_test.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'mocha/inspect'
+require 'method_definer'
 
 class InspectTest
   def self.suite
@@ -17,7 +18,17 @@ class ObjectInspectTest < Test::Unit::TestCase
   
   def test_should_provide_custom_representation_of_object
     object = Object.new
-    assert_equal "#<#{object.class}: #{object.object_id}>", object.mocha_inspect
+    assert_equal "#<#{object.class}:#{"0x%x" % object.__id__}>", 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 }
+    object.replace_instance_method(:id) { self.called = true; 1 }
+    object.mocha_inspect
+    assert_equal false, object.called
   end
   
 end

data/test/mocha/metaclass_test.rb

@@ -0,0 +1,22 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/metaclass'
+
+class MetaclassTest < Test::Unit::TestCase
+  
+  def test_should_return_objects_singleton_class
+    object = Object.new
+    assert_raises(NoMethodError) { object.success? }
+
+    object = Object.new
+    assert object.__metaclass__.ancestors.include?(Object)
+    assert object.__metaclass__.ancestors.include?(Kernel)
+    assert object.__metaclass__.is_a?(Class)
+
+    object.__metaclass__.class_eval { def success?; true; end }
+    assert object.success?
+    
+    object = Object.new
+    assert_raises(NoMethodError) { object.success? }
+  end
+  
+end

data/test/mocha/mock_methods_test.rb

@@ -49,7 +49,17 @@ class MockMethodsTest < Test::Unit::TestCase
     expectation1 = mock.expects(:my_method).with(:argument1, :argument2)
     expectation2 = mock.expects(:my_method).with(:argument3, :argument4)
     
-    assert_equal expectation2, mock.matching_expectation(:my_method, :argument3, :argument4)
+    assert_same expectation2, mock.matching_expectation(:my_method, :argument3, :argument4)
+  end
+  
+  def test_should_find_most_recent_matching_expectation
+    mock = Object.new
+    mock.extend(MockMethods)
+
+    expectation1 = mock.expects(:my_method).with(:argument1, :argument2)
+    expectation2 = mock.expects(:my_method).with(:argument1, :argument2)
+    
+    assert_same expectation2, mock.matching_expectation(:my_method, :argument1, :argument2)
   end
   
   def test_should_invoke_expectation_and_return_result
@@ -67,7 +77,7 @@ class MockMethodsTest < Test::Unit::TestCase
     mock.extend(MockMethods)
     
     result = nil
-    assert_nothing_raised(Test::Unit::AssertionFailedError) do
+    assert_nothing_raised(ExpectationError) do
       result = mock.unexpected_method
     end
     assert_nil result
@@ -84,7 +94,7 @@ class MockMethodsTest < Test::Unit::TestCase
   def test_should_raise_assertion_error_for_unexpected_method_call
     mock = Object.new
     mock.extend(MockMethods)
-    error = assert_raise(Test::Unit::AssertionFailedError) do
+    error = assert_raise(ExpectationError) do
       mock.unexpected_method_called(:my_method, :argument1, :argument2)
     end
     assert_match /my_method/, error.message
@@ -129,16 +139,16 @@ class MockMethodsTest < Test::Unit::TestCase
     mock.expects(:method1)
     mock.expects(:method2)
     mock.method1
-    assert_raise(Test::Unit::AssertionFailedError) do
+    assert_raise(ExpectationError) do
       mock.verify
     end
   end
   
   def test_should_report_possible_expectations
     mock = Object.new.extend(MockMethods)
-    mock.expects(:meth).with(1)
-    exception = assert_raise(Test::Unit::AssertionFailedError) { mock.meth(2) }
-    assert_equal "Unexpected message :meth(2) sent to #{mock.mocha_inspect}\nSimilar expectations :meth(1)", exception.message
+    mock.expects(:expected_method).with(1)
+    exception = assert_raise(ExpectationError) { mock.expected_method(2) }
+    assert_equal "#{mock.mocha_inspect}.expected_method(2) - expected calls: 0, actual calls: 1\nSimilar expectations:\nexpected_method(1)", exception.message
   end
   
   def test_should_pass_block_through_to_expectations_verify_method
@@ -174,4 +184,52 @@ class MockMethodsTest < Test::Unit::TestCase
     assert_equal false, mock.respond_to?(:method1)
   end
   
+  def test_should_set_up_multiple_expectations_with_return_values
+    mock = Object.new
+    mock.extend(MockMethods)
+    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 = Object.new
+    mock.extend(MockMethods)
+    mock.stubs(:method1 => :result1, :method2 => :result2)
+    assert_equal :result1, mock.method1
+    assert_equal :result2, mock.method2
+  end
+  
+  def test_should_match_most_recent_call_to_expects
+    mock = Object.new
+    mock.extend(MockMethods)
+    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 = Object.new
+    mock.extend(MockMethods)
+    mock.stubs(:method1).returns(0)
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
+  def test_should_match_call_to_expects_with_previous_call_to_stubs
+    mock = Object.new
+    mock.extend(MockMethods)
+    mock.stubs(:method1).returns(0)
+    mock.expects(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
+  def test_should_match_call_to_stubs_with_previous_call_to_expects
+    mock = Object.new
+    mock.extend(MockMethods)
+    mock.expects(:method1).returns(0)
+    mock.stubs(:method1).returns(1)
+    assert_equal 1, mock.method1
+  end
+
 end

data/test/mocha/mock_test.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'mocha/mock'
+require 'mocha/expectation_error'
 
 class MockTest < Test::Unit::TestCase
   
@@ -12,7 +13,7 @@ class MockTest < Test::Unit::TestCase
   def test_should_set_single_expectation
    mock = Mock.new
    mock.expects(:method1).returns(1)
-   assert_nothing_raised(Test::Unit::AssertionFailedError) do
+   assert_nothing_raised(ExpectationError) do
      assert_equal 1, mock.method1
    end
   end 
@@ -34,14 +35,50 @@ class MockTest < Test::Unit::TestCase
     assert_equal true, mock.stub_everything
   end
   
-  def test_should_use_default_inspect_message
+  def test_should_display_object_id_for_inspect_if_mock_has_no_name
     mock = Mock.new
-    assert_equal mock.mocha_inspect_before_hijacked_by_named_mocks, mock.mocha_inspect
+    assert_match Regexp.new("#<Mock:0x[0-9A-Fa-f]{6}>"), mock.mocha_inspect
   end
   
+  def test_should_display_name_for_inspect_if_mock_has_name
+    mock = Mock.new(false, 'named_mock')
+    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+  end
+
   def test_should_give_name_in_inspect_message
     mock = Mock.new(false, 'named_mock')
-    assert_equal "#<Mock: 'named_mock'>", mock.mocha_inspect
+    assert_equal "#<Mock:named_mock>", mock.mocha_inspect
+  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
+    
+  def test_should_be_able_to_mock_standard_object_methods
+    mock = Mock.new
+    object_methods = Object.public_instance_methods.reject { |m| m =~ /^__.*__$/ }.sort
+    object_methods.each { |method| mock.__expects__(method.to_sym).returns(method) }
+    object_methods.each { |method| assert_equal method, mock.__send__(method.to_sym) }
+    assert_nothing_raised(ExpectationError) { mock.verify }
+  end
+
+  def test_should_be_able_to_stub_standard_object_methods
+    mock = Mock.new
+    object_methods = Object.public_instance_methods.reject { |m| m =~ /^__.*__$/ }.sort
+    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_respond_to_expected_methods
+    mock = Mock.new
+    mock.expects(:method1)
+    assert_equal true, mock.respond_to?(:method1)
   end
   
 end

data/test/{stubba → mocha}/object_test.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'mocha/mock'
 require 'method_definer'
 
-require 'stubba/object'
+require 'mocha/object'
 
 class ObjectTest < Test::Unit::TestCase
   
@@ -30,7 +30,7 @@ class ObjectTest < Test::Unit::TestCase
   def test_should_stub_instance_method
     instance = Object.new
     $stubba = Mock.new
-    $stubba.expects(:stub).with(Stubba::InstanceMethod.new(instance, :method1))
+    $stubba.expects(:stub).with(Mocha::InstanceMethod.new(instance, :method1))
     instance.expects(:method1)
     $stubba.verify
   end 
@@ -48,7 +48,7 @@ class ObjectTest < Test::Unit::TestCase
     $stubba = Mock.new
     $stubba.stubs(:stub)
     instance.expects(:method1).with(:value1, :value2)
-    assert_raise(Test::Unit::AssertionFailedError) { instance.verify }
+    assert_raise(ExpectationError) { instance.verify }
   end
   
   def test_should_pass_backtrace_into_expects
@@ -96,7 +96,7 @@ class ObjectTest < Test::Unit::TestCase
   def test_should_stub_class_method
     klass = Class.new
     $stubba = Mock.new
-    $stubba.expects(:stub).with(Stubba::ClassMethod.new(klass, :method1))
+    $stubba.expects(:stub).with(Mocha::ClassMethod.new(klass, :method1))
     klass.expects(:method1)
     $stubba.verify
   end 
@@ -112,7 +112,7 @@ class ObjectTest < Test::Unit::TestCase
   def test_should_stub_module_method
     mod = Module.new
     $stubba = Mock.new
-    $stubba.expects(:stub).with(Stubba::ClassMethod.new(mod, :method1))
+    $stubba.expects(:stub).with(Mocha::ClassMethod.new(mod, :method1))
     mod.expects(:method1)
     $stubba.verify
   end
@@ -126,19 +126,19 @@ class ObjectTest < Test::Unit::TestCase
   end
   
   def test_should_use_stubba_instance_method_for_object
-    assert_equal Stubba::InstanceMethod, Object.new.stubba_method
+    assert_equal Mocha::InstanceMethod, Object.new.stubba_method
   end
     
   def test_should_use_stubba_class_method_for_module
-    assert_equal Stubba::ClassMethod, Module.new.stubba_method
+    assert_equal Mocha::ClassMethod, Module.new.stubba_method
   end
     
   def test_should_use_stubba_class_method_for_class
-    assert_equal Stubba::ClassMethod, Class.new.stubba_method
+    assert_equal Mocha::ClassMethod, Class.new.stubba_method
   end
   
   def test_should_use_stubba_class_method_for_any_instance
-    assert_equal Stubba::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
+    assert_equal Mocha::AnyInstanceMethod, Class::AnyInstance.new(nil).stubba_method
   end
   
   def test_should_stub_self_for_object

data/test/mocha/setup_and_teardown_test.rb

@@ -0,0 +1,76 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/mock'
+
+require 'mocha/setup_and_teardown'
+
+class SetupAndTeardownTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_instantiate_new_stubba
+    test_case = stubbed_test_case_class.new
+    test_case.setup_stubs
+    
+    assert $stubba
+    assert $stubba.is_a?(Mocha::Central)
+  end
+
+  def test_should_verify_all_expectations
+    test_case = stubbed_test_case_class.new
+    stubba = Mock.new
+    stubba.expects(:verify_all)
+    $stubba = stubba
+    
+    test_case.verify_stubs
+    
+    stubba.verify
+  end
+
+  def test_should_yield_to_block_for_each_assertion
+    test_case = stubbed_test_case_class.new
+    $stubba = Mock.new
+    $stubba.stubs(:verify_all).yields
+    yielded = false
+    
+    test_case.verify_stubs { yielded = true }
+    
+    assert_equal true, yielded
+  end
+
+  def test_should_unstub_all_stubbed_methods
+    test_case = stubbed_test_case_class.new
+    stubba = Mock.new
+    stubba.expects(:unstub_all)
+    $stubba = stubba
+    
+    test_case.teardown_stubs
+    
+    stubba.verify
+  end
+
+  def test_should_set_stubba_to_nil
+    test_case = stubbed_test_case_class.new
+    $stubba = Mock.new
+    $stubba.stubs(:unstub_all)
+
+    test_case.teardown_stubs
+    
+    assert_nil $stubba
+  end
+  
+  def test_should_not_raise_exception_if_no_stubba_central_available
+    test_case = stubbed_test_case_class.new
+    $stubba = nil
+    assert_nothing_raised { test_case.teardown_stubs }
+  end
+  
+  private
+  
+  def stubbed_test_case_class
+    Class.new do
+      include Mocha::SetupAndTeardown
+    end
+  end
+
+end
+

data/test/mocha_acceptance_test.rb

@@ -36,8 +36,8 @@ class MochaAcceptanceTest < Test::Unit::TestCase
   end
   
   def test_should_step_both_tracks_forward_ten_steps
-    left_track = mock()
-    right_track = mock()
+    left_track = mock('left_track')
+    right_track = mock('right_track')
     steps_per_metre = 5
     rover = Rover.new(left_track, right_track, steps_per_metre, nil)
     
@@ -51,8 +51,8 @@ class MochaAcceptanceTest < Test::Unit::TestCase
   end
   
   def test_should_step_both_tracks_backward_ten_steps
-    left_track = mock()
-    right_track = mock()
+    left_track = mock('left_track')
+    right_track = mock('right_track')
     steps_per_metre = 5
     rover = Rover.new(left_track, right_track, steps_per_metre, nil)
     
@@ -66,8 +66,8 @@ class MochaAcceptanceTest < Test::Unit::TestCase
   end
   
   def test_should_step_left_track_forwards_five_steps_and_right_track_backwards_five_steps
-    left_track = mock()
-    right_track = mock()
+    left_track = mock('left_track')
+    right_track = mock('right_track')
     steps_per_degree = 5.0 / 90.0
     rover = Rover.new(left_track, right_track, nil, steps_per_degree)
     
@@ -81,8 +81,8 @@ class MochaAcceptanceTest < Test::Unit::TestCase
   end
   
   def test_should_step_left_track_backwards_five_steps_and_right_track_forwards_five_steps
-    left_track = mock()
-    right_track = mock()
+    left_track = mock('left_track')
+    right_track = mock('right_track')
     steps_per_degree = 5.0 / 90.0
     rover = Rover.new(left_track, right_track, nil, steps_per_degree)
     

data/test/mocha_test_result_integration_test.rb

@@ -1,11 +1,10 @@
 require 'test_helper'
-require 'smart_test_case/multiple_setup_and_teardown'
-require 'mocha/auto_verify'
-require 'shared/backtracefilter'
+require 'mocha/standalone'
+require 'mocha/test_case_adapter'
 require 'execution_point'
 
 class MochaTestResultIntegrationTest < Test::Unit::TestCase
-
+  
   def test_should_include_expectation_verification_in_assertion_count
     test_result = run_test do
       object = mock()
@@ -94,8 +93,8 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
   
   def run_test(test_result = Test::Unit::TestResult.new, &block)
     test_class = Class.new(Test::Unit::TestCase) do
-      include MultipleSetupAndTeardown
-      include Mocha::AutoVerify
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
       define_method(:test_me, &block)
     end
     test = test_class.new(:test_me)

data/test/standalone_acceptance_test.rb

@@ -0,0 +1,110 @@
+require 'test_helper'
+require 'mocha_standalone'
+
+class NotATestUnitAssertionFailedError < StandardError
+end
+
+class NotATestUnitTestCase
+  
+  include Mocha::Standalone
+  
+  attr_reader :assertion_count
+  
+  def initialize
+    @assertion_count = 0
+  end
+  
+  def run(test_method)
+    mocha_setup
+    begin
+      prepare
+      begin
+        send(test_method)
+        mocha_verify { @assertion_count += 1 }
+      rescue Mocha::ExpectationError => e
+        new_error = NotATestUnitAssertionFailedError.new(e.message)
+        new_error.set_backtrace(e.backtrace)
+        raise new_error
+      ensure
+        cleanup
+      end
+    ensure
+      mocha_teardown
+    end
+  end
+  
+  def prepare
+  end
+  
+  def cleanup
+  end
+    
+end
+
+class SampleTest < NotATestUnitTestCase
+  
+  def mocha_with_fulfilled_expectation
+    mockee = mock()
+    mockee.expects(:blah)
+    mockee.blah
+  end
+  
+  def mocha_with_unfulfilled_expectation
+    mockee = mock()
+    mockee.expects(:blah)
+  end
+  
+  def mocha_with_unexpected_invocation
+    mockee = mock()
+    mockee.blah
+  end
+  
+  def stubba_with_fulfilled_expectation
+    stubbee = Class.new { define_method(:blah) {} }.new
+    stubbee.expects(:blah)
+    stubbee.blah
+  end
+  
+  def stubba_with_unfulfilled_expectation
+    stubbee = Class.new { define_method(:blah) {} }.new
+    stubbee.expects(:blah)
+  end
+  
+end
+
+require 'test/unit'
+
+class StandaloneAcceptanceTest < Test::Unit::TestCase
+  
+  attr_reader :sample_test
+
+  def setup
+    @sample_test = SampleTest.new
+  end
+  
+  def test_should_pass_mocha_test
+    assert_nothing_raised { sample_test.run(:mocha_with_fulfilled_expectation) }
+    assert_equal 1, sample_test.assertion_count
+  end
+
+  def test_should_fail_mocha_test_due_to_unfulfilled_exception
+    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unfulfilled_expectation) }
+    assert_equal 1, sample_test.assertion_count
+  end
+
+  def test_should_fail_mocha_test_due_to_unexpected_invocation
+    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:mocha_with_unexpected_invocation) }
+    assert_equal 0, sample_test.assertion_count
+  end
+
+  def test_should_pass_stubba_test
+    assert_nothing_raised { sample_test.run(:stubba_with_fulfilled_expectation) }
+    assert_equal 1, sample_test.assertion_count
+  end
+
+  def test_should_fail_stubba_test
+    assert_raises(NotATestUnitAssertionFailedError) { sample_test.run(:stubba_with_unfulfilled_expectation) }
+    assert_equal 1, sample_test.assertion_count
+  end
+
+end