mocha 0.1.2 → 0.2.0

data/test/all_tests.rb

@@ -1,6 +1,3 @@
-require 'test_helper'
-require 'stubba/test_case' # only works if loaded before any derived test cases
-
 require 'test/unit/ui/console/testrunner'
 
 require 'mocha/inspect_test'
@@ -9,92 +6,74 @@ require 'mocha/expectation_test'
 require 'mocha/infinite_range_test'
 require 'mocha/mock_methods_test'
 require 'mocha/mock_test'
-
-class MochaUnitTests
-  
-  def self.suite
-    suite = Test::Unit::TestSuite.new('MochaUnitTests')
-    suite << InspectTest.suite
-    suite << PrettyParametersTest.suite
-    suite << ExpectationTest.suite
-    suite << InfiniteRangeTest.suite
-    suite << MockMethodsTest.suite
-    suite << MockTest.suite
-    suite
-  end
-  
-end
-
-Test::Unit::UI::Console::TestRunner.run(MochaUnitTests)
+require 'mocha/auto_verify_test'
 
 require 'auto_mocha/mock_class_test'
 require 'auto_mocha/auto_mock_test'
 
-class AutoMochaUnitTests
-  
-  def self.suite
-    suite = Test::Unit::TestSuite.new('AutoMochaUnitTests')
-    suite << AutoMockTest.suite
-    suite << MockClassTest.suite
-  end
-  
-end
-
-Test::Unit::UI::Console::TestRunner.run(AutoMochaUnitTests)
-
-require 'stubba/stubba_test'
+require 'stubba/central_test'
 require 'stubba/class_method_test'
 require 'stubba/instance_method_test'
 require 'stubba/any_instance_method_test'
-require 'stubba/test_case_test'
+require 'stubba/setup_and_teardown_test'
+require 'stubba/object_test'
+
+require 'smart_test_case/multiple_setup_and_teardown_test'
 
-class StubbaUnitTests
+class UnitTests
   
   def self.suite
-    suite = Test::Unit::TestSuite.new('StubbaUnitTests')
-    suite << StubbaTest.suite
+    suite = Test::Unit::TestSuite.new('UnitTests')
+    suite << InspectTest.suite
+    suite << PrettyParametersTest.suite
+    suite << ExpectationTest.suite
+    suite << InfiniteRangeTest.suite
+    suite << MockMethodsTest.suite
+    suite << MockTest.suite
+    suite << AutoVerifyTest.suite
+    suite << MockClassTest.suite
+    suite << AutoMockTest.suite
+    suite << CentralTest.suite
     suite << ClassMethodTest.suite
     suite << InstanceMethodTest.suite
     suite << AnyInstanceMethodTest.suite
-    suite << TestCaseTest.suite
+    suite << SetupAndTeardownTest.suite
+    suite << ObjectTest.suite
+    suite << MultipleSetupAndTeardownTest.suite
     suite
   end
   
 end
 
-Test::Unit::UI::Console::TestRunner.run(StubbaUnitTests)
+Test::Unit::UI::Console::TestRunner.run(UnitTests)
 
-require 'stubba/object_test'
+require 'stubba_integration_test'
 
-class IsolatedStubbaUnitTests # avoid loading stubba_object until now which breaks other stubba unit tests
+class IntegrationTests
   
   def self.suite
-    suite = Test::Unit::TestSuite.new('IsolatedStubbaUnitTests')
-    suite << ObjectTest.suite
-    suite
+    suite = Test::Unit::TestSuite.new('IntegrationTests')
+    suite << StubbaIntegrationTest.suite
   end
   
 end
 
-Test::Unit::UI::Console::TestRunner.run(IsolatedStubbaUnitTests)
-
-require 'stubba_integration_test'
-Test::Unit::UI::Console::TestRunner.run(StubbaIntegrationTest)
+Test::Unit::UI::Console::TestRunner.run(IntegrationTests)
 
 require 'mocha_acceptance_test'
-require 'stubba_acceptance_test'
 require 'auto_mock_acceptance_test'
+require 'stubba_acceptance_test'
 
 class AcceptanceTests
   
   def self.suite
     suite = Test::Unit::TestSuite.new('AcceptanceTests')
     suite << MochaAcceptanceTest.suite
-    suite << StubbaAcceptanceTest.suite
     suite << AutoMockAcceptanceTest.suite
+    suite << StubbaAcceptanceTest.suite
     suite
   end
   
 end
 
-Test::Unit::UI::Console::TestRunner.run(AcceptanceTests)
+Test::Unit::UI::Console::TestRunner.run(AcceptanceTests)

data/test/auto_mock_acceptance_test.rb

@@ -1,5 +1,4 @@
 require 'test_helper'
-require 'mocha'
 require 'auto_mocha'
 
 class Product < ActiveRecord::Base

data/test/mocha/auto_verify_test.rb

@@ -0,0 +1,49 @@
+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
+      def self.add_teardown_method(symbol); end
+      include AutoVerify
+    end
+  end
+  
+  def test_should_build_mock
+    assert test_case.mock.is_a?(Mocha::Mock)
+  end
+  
+  def test_should_build_new_mock_each_time
+    assert_not_equal test_case.mock, test_case.mock
+  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_verify_each_mock_on_teardown
+    mocks = Array.new(3) do
+      mock = Object.new
+      mock.define_instance_accessor(:verify_called)
+      mock.define_instance_method(:verify) { self.verify_called = true }
+      mock
+    end
+    test_case.replace_instance_method(:mocks)  { mocks }
+    test_case.teardown_mocks
+    assert mocks.all? { |mock| mock.verify_called }
+  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
+  
+end

data/test/mocha_acceptance_test.rb

@@ -35,11 +35,9 @@ class MochaAcceptanceTest < Test::Unit::TestCase
 
   end
   
-  include Mocha
-
   def test_should_move_both_tracks_forward_ten_steps
-    left_track = Mock.new
-    right_track = Mock.new
+    left_track = mock()
+    right_track = mock()
     steps_per_metre = 5
     rover = Rover.new(left_track, right_track, steps_per_metre, nil)
     
@@ -50,14 +48,11 @@ class MochaAcceptanceTest < Test::Unit::TestCase
     right_track.stubs(:moving?).returns(false)
     
     rover.forward(2)
-    
-    left_track.verify
-    right_track.verify
   end
   
   def test_should_move_both_tracks_backward_ten_steps
-    left_track = Mock.new
-    right_track = Mock.new
+    left_track = mock()
+    right_track = mock()
     steps_per_metre = 5
     rover = Rover.new(left_track, right_track, steps_per_metre, nil)
     
@@ -68,14 +63,11 @@ class MochaAcceptanceTest < Test::Unit::TestCase
     right_track.stubs(:moving?).returns(false)
     
     rover.backward(2)
-    
-    left_track.verify
-    right_track.verify
   end
   
   def test_should_move_left_track_forwards_five_steps_and_right_track_backwards_five_steps
-    left_track = Mock.new
-    right_track = Mock.new
+    left_track = mock()
+    right_track = mock()
     steps_per_degree = 5.0 / 90.0
     rover = Rover.new(left_track, right_track, nil, steps_per_degree)
     
@@ -86,14 +78,11 @@ class MochaAcceptanceTest < Test::Unit::TestCase
     right_track.stubs(:moving?).returns(false)
     
     rover.right(90)
-    
-    left_track.verify
-    right_track.verify
   end
   
   def test_should_move_left_track_backwards_five_steps_and_right_track_forwards_five_steps
-    left_track = Mock.new
-    right_track = Mock.new
+    left_track = mock()
+    right_track = mock()
     steps_per_degree = 5.0 / 90.0
     rover = Rover.new(left_track, right_track, nil, steps_per_degree)
     
@@ -104,9 +93,6 @@ class MochaAcceptanceTest < Test::Unit::TestCase
     right_track.stubs(:moving?).returns(false)
     
     rover.left(90)
-    
-    left_track.verify
-    right_track.verify
   end
   
 end

data/test/smart_test_case/multiple_setup_and_teardown_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'smart_test_case/multiple_setup_and_teardown'
+require 'active_record_test_case'
+
+class MultipleSetupAndTeardownTest < Test::Unit::TestCase
+  
+  def test_1
+    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 }
+    end
+    test = test_case.new(:test_me)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup_1, :test_me], test.methods_called
+  end
+  
+  def test_2
+    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 }
+    end
+    test = test_case.new(:test_me)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup, :setup_1, :test_me], test.methods_called
+  end
+  
+  def test_3
+    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 }
+    end
+    test = test_case.new(:test_me)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup_1, :setup, :test_me], test.methods_called
+  end
+  
+  def test_4
+    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 }
+    end
+    derived_test_case = Class.new(test_case) do
+      define_method(:setup) { methods_called << :setup }
+      define_method(:test_me) { methods_called << :test_me }
+    end
+    test = derived_test_case.new(:test_me)
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+    assert_equal [:setup_1, :setup, :test_me], test.methods_called
+  end
+  
+  def test_5
+    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 }
+    end
+    derived_test_case = Class.new(test_case) do
+      define_method(:setup) { methods_called << :setup }
+      define_method(:test_me) { methods_called << :test_me }
+    end
+    test = derived_test_case.new(:test_me)
+    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
+  end
+  
+end

data/test/stubba/any_instance_method_test.rb

@@ -34,7 +34,8 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     method = AnyInstanceMethod.new(klass, :method_x)
     mocha = Mock.new
     mocha.expects(:method_x).with(:param1, :param2).returns(:result)
-    any_instance = Mock.new(:mocha => mocha)
+    any_instance = Object.new
+    any_instance.define_instance_method(:mocha) { mocha }
     klass.define_instance_method(:any_instance) { any_instance }
     
     method.define_new_method
@@ -99,7 +100,7 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
 
   def test_should_call_reset_mocha
     klass = Class.new { def method_x; end }
-    any_instance = Mock.new(:reset_mocha => nil)
+    any_instance = Class.new { attr_accessor :mocha_was_reset; def reset_mocha; self.mocha_was_reset = true; end }.new
     klass.define_instance_method(:any_instance) { any_instance }
     method = AnyInstanceMethod.new(klass, :method_x)
     method.replace_instance_method(:remove_new_method) { }
@@ -107,7 +108,7 @@ class AnyInstanceMethodTest < Test::Unit::TestCase
     
     method.unstub
 
-    any_instance.verify(:reset_mocha)
+    assert any_instance.mocha_was_reset
   end
 
 end

data/test/stubba/{stubba_test.rb → central_test.rb}

@@ -1,14 +1,15 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
-require 'stubba/stubba'
+
+require 'stubba/central'
 require 'mocha/mock'
 
-class StubbaTest < Test::Unit::TestCase
+class CentralTest < Test::Unit::TestCase
   
-  include Stubba
   include Mocha
+  include Stubba
   
   def test_should_start_with_empty_stubba_methods
-    stubba = Stubba.new
+    stubba = Central.new
     
     assert_equal [], stubba.stubba_methods
   end
@@ -16,7 +17,7 @@ class StubbaTest < Test::Unit::TestCase
   def test_should_stub_method_if_not_already_stubbed
     method = Mock.new
     method.expects(:stub)
-    stubba = Stubba.new
+    stubba = Central.new
     
     stubba.stub(method)
     
@@ -26,7 +27,7 @@ class StubbaTest < Test::Unit::TestCase
   def test_should_not_stub_method_if_already_stubbed
     method = Mock.new
     method.expects(:stub).times(0)
-    stubba = Stubba.new
+    stubba = Central.new
     stubba_methods = Mock.new
     stubba_methods.stubs(:include?).with(method).returns(true)
     stubba.stubba_methods = stubba_methods
@@ -39,7 +40,7 @@ class StubbaTest < Test::Unit::TestCase
   def test_should_record_method
     method = Mock.new
     method.expects(:stub)
-    stubba = Stubba.new
+    stubba = Central.new
     
     stubba.stub(method)
     
@@ -47,7 +48,7 @@ class StubbaTest < Test::Unit::TestCase
   end
   
   def test_should_unstub_all_methods
-    stubba = Stubba.new
+    stubba = Central.new
     method_1 = Mock.new(:unstub => nil)
     method_2 = Mock.new(:unstub => nil)
     stubba.stubba_methods = [method_1, method_2]

data/test/stubba/class_method_test.rb

@@ -7,7 +7,6 @@ require 'stubba/class_method'
 class ClassMethodTest < Test::Unit::TestCase
   
   include Stubba
-  include Mocha
 
   def test_should_provide_hidden_version_of_method_name
     method = ClassMethod.new(nil, :original_method_name)
@@ -46,7 +45,7 @@ class ClassMethodTest < Test::Unit::TestCase
   
   def test_should_define_a_new_method_which_should_call_mocha_method_missing
     klass = Class.new { def self.method_x; end }
-    mocha = Mock.new
+    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)