mocha 0.2.1 → 0.3.0

data/test/mocha_test_result_integration_test.rb

@@ -0,0 +1,106 @@
+require 'test_helper'
+require 'smart_test_case/multiple_setup_and_teardown'
+require 'mocha/auto_verify'
+require 'shared/backtracefilter'
+require 'execution_point'
+
+class MochaTestResultIntegrationTest < Test::Unit::TestCase
+
+  def test_should_include_expectation_verification_in_assertion_count
+    test_result = run_test do
+      object = mock()
+      object.expects(:message)
+      object.message
+    end
+    assert_equal 1, test_result.assertion_count
+  end
+  
+  def test_should_include_assertions_in_assertion_count
+    test_result = run_test do
+      assert true
+    end
+    assert_equal 1, test_result.assertion_count
+  end
+  
+  def test_should_not_include_stubbing_expectation_verification_in_assertion_count
+    test_result = run_test do
+      object = mock()
+      object.stubs(:message)
+      object.message
+    end
+    assert_equal 0, test_result.assertion_count
+  end
+  
+  def test_should_include_expectation_verification_failure_in_failure_count
+    test_result = run_test do
+      object = mock()
+      object.expects(:message)
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_include_unexpected_verification_failure_in_failure_count
+    test_result = run_test do
+      object = mock()
+      object.message
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_include_assertion_failure_in_failure_count
+    test_result = run_test do
+      flunk
+    end
+    assert_equal 1, test_result.failure_count
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_expects_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      object = mock()
+      execution_point = ExecutionPoint.current; object.expects(:message)
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_unexpected_method_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      object = mock()
+      execution_point = ExecutionPoint.current; object.message 
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def test_should_display_backtrace_indicating_line_number_where_failing_assertion_was_called
+    test_result = Test::Unit::TestResult.new
+    faults = []
+    test_result.add_listener(Test::Unit::TestResult::FAULT, &lambda { |fault| faults << fault })
+    execution_point = nil
+    run_test(test_result) do
+      execution_point = ExecutionPoint.current; flunk
+    end
+    assert_equal 1, faults.size
+    assert_equal execution_point, ExecutionPoint.new(faults.first.location)
+  end
+  
+  def run_test(test_result = Test::Unit::TestResult.new, &block)
+    test_class = Class.new(Test::Unit::TestCase) do
+      include MultipleSetupAndTeardown
+      include AutoVerify
+      define_method(:test_me, &block)
+    end
+    test = test_class.new(:test_me)
+    test.run(test_result) {}
+    test_result
+  end
+  
+end

data/test/smart_test_case/multiple_setup_and_teardown_test.rb

@@ -4,88 +4,189 @@ require 'active_record_test_case'
 
 class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   
-  def test_1
+  def test_should_call_added_setup
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include MultipleSetupAndTeardown
-      add_setup_method(:setup_1)
-      define_method(:setup_1) { methods_called << :setup_1 }
-      define_method(:test_me) { methods_called << :test_me }
+      add_setup_method(:added_setup)
+      define_method(:added_setup) { methods_called << :added_setup }
+      define_method(:test_method) { methods_called << :test_method }
     end
-    test = test_case.new(:test_me)
+    test = test_case.new(:test_method)
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
-    assert_equal [:setup_1, :test_me], test.methods_called
+    assert_equal [:added_setup, :test_method], test.methods_called
   end
   
-  def test_2
+  def test_should_call_added_teardown
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      include MultipleSetupAndTeardown
+      add_teardown_method(:added_teardown)
+      define_method(:added_teardown) { methods_called << :added_teardown }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:test_method, :added_teardown], test.methods_called
+  end
+  
+  def test_should_call_both_added_teardowns_even_if_one_raises_exception
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      include MultipleSetupAndTeardown
+      add_teardown_method(:added_teardown_1)
+      add_teardown_method(:added_teardown_2)
+      define_method(:added_teardown_1) { methods_called << :added_teardown_1 }
+      define_method(:added_teardown_2) { methods_called << :added_teardown_2; raise }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert_equal false, test_result.passed?
+    assert_equal [:test_method, :added_teardown_2, :added_teardown_1], test.methods_called
+  end
+  
+  def test_should_call_added_setup_and_setup_defined_before_module_included
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       define_method(:setup) { methods_called << :setup }
       include MultipleSetupAndTeardown
-      add_setup_method(:setup_1)
-      define_method(:setup_1) { methods_called << :setup_1 }
-      define_method(:test_me) { methods_called << :test_me }
+      add_setup_method(:added_setup)
+      define_method(:added_setup) { methods_called << :added_setup }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup, :added_setup, :test_method], test.methods_called
+  end
+  
+  def test_should_call_added_teardown_and_teardown_defined_before_module_included
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      define_method(:teardown) { methods_called << :teardown }
+      include MultipleSetupAndTeardown
+      add_teardown_method(:added_teardown)
+      define_method(:added_teardown) { methods_called << :added_teardown }
+      define_method(:test_method) { methods_called << :test_method }
     end
-    test = test_case.new(:test_me)
+    test = test_case.new(:test_method)
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
-    assert_equal [:setup, :setup_1, :test_me], test.methods_called
+    assert_equal [:test_method, :added_teardown, :teardown], test.methods_called
   end
   
-  def test_3
+  def test_should_call_added_setup_and_setup_defined_after_module_included
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include MultipleSetupAndTeardown
       define_method(:setup) { methods_called << :setup }
-      add_setup_method(:setup_1)
-      define_method(:setup_1) { methods_called << :setup_1 }
-      define_method(:test_me) { methods_called << :test_me }
+      add_setup_method(:added_setup)
+      define_method(:added_setup) { methods_called << :added_setup }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:added_setup, :setup, :test_method], test.methods_called
+  end
+  
+  def test_should_call_added_teardown_and_teardown_defined_after_module_included
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      include MultipleSetupAndTeardown
+      define_method(:teardown) { methods_called << :teardown }
+      add_teardown_method(:added_teardown)
+      define_method(:added_teardown) { methods_called << :added_teardown }
+      define_method(:test_method) { methods_called << :test_method }
     end
-    test = test_case.new(:test_me)
+    test = test_case.new(:test_method)
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
-    assert_equal [:setup_1, :setup, :test_me], test.methods_called
+    assert_equal [:test_method, :teardown, :added_teardown], test.methods_called
   end
   
-  def test_4
+  def test_should_call_added_setup_and_setup_defined_in_derived_test_case
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include MultipleSetupAndTeardown
-      add_setup_method(:setup_1)
-      define_method(:setup_1) { methods_called << :setup_1 }
+      add_setup_method(:added_setup)
+      define_method(:added_setup) { methods_called << :added_setup }
     end
     derived_test_case = Class.new(test_case) do
       define_method(:setup) { methods_called << :setup }
-      define_method(:test_me) { methods_called << :test_me }
+      define_method(:test_method) { methods_called << :test_method }
     end
-    test = derived_test_case.new(:test_me)
+    test = derived_test_case.new(:test_method)
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
-    assert_equal [:setup_1, :setup, :test_me], test.methods_called
+    assert_equal [:added_setup, :setup, :test_method], test.methods_called
   end
   
-  def test_5
+  def test_should_call_added_teardown_and_teardown_defined_in_derived_test_case
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      include MultipleSetupAndTeardown
+      add_teardown_method(:added_teardown)
+      define_method(:added_teardown) { methods_called << :added_teardown }
+    end
+    derived_test_case = Class.new(test_case) do
+      define_method(:teardown) { methods_called << :teardown }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = derived_test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:test_method, :teardown, :added_teardown], test.methods_called
+  end
+  
+  def test_should_call_added_setup_and_setup_defined_in_derived_test_case_with_active_record_setup_with_fixtures
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include ActiveRecordTestCase
       include MultipleSetupAndTeardown
-      add_setup_method(:setup_1)
-      define_method(:setup_1) { methods_called << :setup_1 }
+      add_setup_method(:added_setup)
+      define_method(:added_setup) { methods_called << :added_setup }
     end
     derived_test_case = Class.new(test_case) do
       define_method(:setup) { methods_called << :setup }
-      define_method(:test_me) { methods_called << :test_me }
+      define_method(:test_method) { methods_called << :test_method }
     end
-    test = derived_test_case.new(:test_me)
+    test = derived_test_case.new(:test_method)
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
-    assert_equal [:setup_with_fixtures, :setup_1, :setup, :test_me, :teardown_with_fixtures], test.methods_called
+    assert_equal [:setup_with_fixtures, :added_setup, :setup, :test_method, :teardown_with_fixtures], test.methods_called
   end
-  
+    
+  def test_should_call_added_teardown_and_teardown_defined_in_derived_test_case_with_active_record_teardown_with_fixtures
+    test_case = Class.new(Test::Unit::TestCase) do
+      define_method(:methods_called) { @methods_called ||= [] }
+      include ActiveRecordTestCase
+      include MultipleSetupAndTeardown
+      add_teardown_method(:added_teardown)
+      define_method(:added_teardown) { methods_called << :added_teardown }
+    end
+    derived_test_case = Class.new(test_case) do
+      define_method(:teardown) { methods_called << :teardown }
+      define_method(:test_method) { methods_called << :test_method }
+    end
+    test = derived_test_case.new(:test_method)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup_with_fixtures, :test_method, :teardown, :added_teardown, :teardown_with_fixtures], test.methods_called
+  end
+    
 end

data/test/stubba/any_instance_method_test.rb

@@ -72,7 +72,8 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
 
   def test_should_call_remove_new_method
     klass = Class.new { def method_x; end }
-    any_instance = Mock.new(:reset_mocha => nil)
+    any_instance = Mock.new
+    any_instance.stubs(:reset_mocha)
     klass.define_instance_method(:any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
     method.replace_instance_method(:restore_original_method) { }
@@ -86,7 +87,8 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
 
   def test_should_call_restore_original_method
     klass = Class.new { def method_x; end }
-    any_instance = Mock.new(:reset_mocha => nil)
+    any_instance = Mock.new
+    any_instance.stubs(:reset_mocha)
     klass.define_instance_method(:any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
     method.replace_instance_method(:remove_new_method) { }
@@ -111,4 +113,14 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     assert any_instance.mocha_was_reset
   end
 
+  def test_should_return_any_instance_mocha_for_stubbee
+    mocha = Object.new
+    any_instance = Object.new
+    any_instance.define_instance_method(:mocha) { mocha }
+    stubbee = Class.new
+    stubbee.define_instance_method(:any_instance) { any_instance }
+    method = AnyInstanceMethod.new(stubbee, :method_name)
+    assert_equal stubbee.any_instance.mocha, method.mock
+  end
+
 end

data/test/stubba/central_test.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), "..", "test_helper")
 
 require 'stubba/central'
 require 'mocha/mock'
+require 'method_definer'
 
 class CentralTest < Test::Unit::TestCase
   
@@ -49,8 +50,10 @@ class CentralTest < Test::Unit::TestCase
   
   def test_should_unstub_all_methods
     stubba = Central.new
-    method_1 = Mock.new(:unstub => nil)
-    method_2 = Mock.new(:unstub => nil)
+    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
@@ -59,5 +62,62 @@ class CentralTest < Test::Unit::TestCase
     method_1.verify
     method_2.verify
   end
+  
+  def test_should_collect_mock_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 [:mock_1, :mock_2], stubba.unique_mocks
+  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/stubba/class_method_test.rb

@@ -33,6 +33,16 @@ class ClassMethodTest < Test::Unit::TestCase
     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)
@@ -75,7 +85,7 @@ class ClassMethodTest < Test::Unit::TestCase
     method.restore_original_method
     
     assert_equal :original_result, klass.method_x 
-    assert !klass.respond_to?(hidden_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
@@ -144,5 +154,13 @@ class ClassMethodTest < Test::Unit::TestCase
     
     assert klass.reset_called
   end
+  
+  def test_should_return_mock_for_stubbee
+    mocha = Object.new
+    stubbee = Object.new
+    stubbee.define_instance_accessor(:mocha) { mocha }
+    method = ClassMethod.new(stubbee, :method_name)
+    assert_equal stubbee.mocha, method.mock
+  end
 
 end