mocha 0.3.2 → 0.3.3

data/Rakefile

@@ -4,7 +4,7 @@ require 'rake/gempackagetask'
 require 'rake/contrib/sshpublisher'
 
 module Mocha
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end
 
 desc "Default task is currently to run all tests"

data/lib/smart_test_case.rb

@@ -1,5 +1,5 @@
 require 'smart_test_case/multiple_setup_and_teardown'
 
 class Test::Unit::TestCase
-  include SmartTestCase::MultipleSetupAndTeardown unless ancestors.include?(SmartTestCase::MultipleSetupAndTeardown)
+  include MultipleSetupAndTeardown unless ancestors.include?(MultipleSetupAndTeardown)
 end

data/lib/smart_test_case/multiple_setup_and_teardown.rb

@@ -1,125 +1,123 @@
-module SmartTestCase
-  module MultipleSetupAndTeardown
+module MultipleSetupAndTeardown
   
-    def self.included(base)
+  def self.included(base)
 
-      base.class_eval do
+    base.class_eval do
   
-        def self.method_added(symbol)
-          # disable until later
-        end
+      def self.method_added(symbol)
+        # disable until later
+      end
 
-        if method_defined?(:setup) then
-          alias_method :setup_original, :setup
-          define_method(:setup_new) do
-            begin
-              setup_original
-            ensure
-              setup_mocha
-            end
-          end
-        else
-          define_method(:setup_new) do
+      if method_defined?(:setup) then
+        alias_method :setup_original, :setup
+        define_method(:setup_new) do
+          begin
+            setup_original
+          ensure
             setup_mocha
           end
         end
-        alias_method :setup, :setup_new
-
-        if method_defined?(:teardown) then
-          alias_method :teardown_original, :teardown
-          define_method(:teardown_new) do
-            begin
-              teardown_mocha
-            ensure
-              teardown_original
-            end
-          end
-        else
-          define_method(:teardown_new) do
+      else
+        define_method(:setup_new) do
+          setup_mocha
+        end
+      end
+      alias_method :setup, :setup_new
+
+      if method_defined?(:teardown) then
+        alias_method :teardown_original, :teardown
+        define_method(:teardown_new) do
+          begin
             teardown_mocha
+          ensure
+            teardown_original
           end
         end
-        alias_method :teardown, :teardown_new
-
-        def self.method_added(method)
-          case method
-          when :setup
-            unless method_defined?(:setup_added)
-              alias_method :setup_added, :setup
-              define_method(:setup) do
-                begin
-                  setup_new
-                ensure
-                  setup_added
-                end
+      else
+        define_method(:teardown_new) do
+          teardown_mocha
+        end
+      end
+      alias_method :teardown, :teardown_new
+
+      def self.method_added(method)
+        case method
+        when :setup
+          unless method_defined?(:setup_added)
+            alias_method :setup_added, :setup
+            define_method(:setup) do
+              begin
+                setup_new
+              ensure
+                setup_added
               end
             end
-          when :teardown
-            unless method_defined?(:teardown_added)
-              alias_method :teardown_added, :teardown
-              define_method(:teardown) do
-                begin
-                  teardown_added
-                ensure
-                  teardown_new
-                end
+          end
+        when :teardown
+          unless method_defined?(:teardown_added)
+            alias_method :teardown_added, :teardown
+            define_method(:teardown) do
+              begin
+                teardown_added
+              ensure
+                teardown_new
               end
             end
           end
         end
+      end
 
-        class << self
-
-          def setup_methods
-            @setup_methods ||= []
-          end
-
-          def teardown_methods
-            @teardown_methods ||= []
-          end
+      class << self
 
-          def add_setup_method(symbol)
-            setup_methods << symbol
-          end
+        def setup_methods
+          @setup_methods ||= []
+        end
 
-          def add_teardown_method(symbol)
-            teardown_methods << symbol
-          end
+        def teardown_methods
+          @teardown_methods ||= []
+        end
 
-          private
+        def add_setup_method(symbol)
+          setup_methods << symbol
+        end
 
-          def inherited_with_setup_and_teardown_methods(child)
-            inherited_without_setup_and_teardown_methods(child) if respond_to?(:inherited_without_setup_and_teardown_methods, true)
-            child.instance_variable_set('@setup_methods', setup_methods.dup)
-            child.instance_variable_set('@teardown_methods', teardown_methods.dup)
-          end
+        def add_teardown_method(symbol)
+          teardown_methods << symbol
+        end
 
-          if respond_to?(:inherited, true)
-            alias_method :inherited_without_setup_and_teardown_methods, :inherited
-          end
-          alias_method :inherited, :inherited_with_setup_and_teardown_methods
+        private
 
+        def inherited_with_setup_and_teardown_methods(child)
+          inherited_without_setup_and_teardown_methods(child) if respond_to?(:inherited_without_setup_and_teardown_methods, true)
+          child.instance_variable_set('@setup_methods', setup_methods.dup)
+          child.instance_variable_set('@teardown_methods', teardown_methods.dup)
         end
 
-        def setup_mocha
-          self.class.class_eval { setup_methods }.each { |symbol| send(symbol) }
+        if respond_to?(:inherited, true)
+          alias_method :inherited_without_setup_and_teardown_methods, :inherited
         end
+        alias_method :inherited, :inherited_with_setup_and_teardown_methods
 
-        def teardown_mocha
-          stored_exception = nil
-          self.class.class_eval { teardown_methods }.reverse.each do |symbol|
-            begin
-              send(symbol)
-            rescue Exception => e
-              stored_exception ||= e
-            end
+      end
+
+      def setup_mocha
+        self.class.class_eval { setup_methods }.each { |symbol| send(symbol) }
+      end
+
+      def teardown_mocha
+        stored_exception = nil
+        self.class.class_eval { teardown_methods }.reverse.each do |symbol|
+          begin
+            send(symbol)
+          rescue Exception => e
+            stored_exception ||= e
           end
-          raise stored_exception if stored_exception
         end
-
+        raise stored_exception if stored_exception
       end
 
     end
 
   end
-end
+
+end

data/lib/stubba.rb

@@ -4,5 +4,5 @@ require 'stubba/setup_and_teardown'
 require 'shared/backtracefilter'
 
 class Test::Unit::TestCase
-  include Stubba::SetupAndTeardown unless ancestors.include?(Stubba::SetupAndTeardown)
+  include SetupAndTeardown unless ancestors.include?(SetupAndTeardown)
 end

data/lib/stubba/instance_method.rb

@@ -6,11 +6,7 @@ module Stubba
    
     def stub
       raise cannot_replace_method_error unless exists?
-      define_new_method
-    end
-  
-    def unstub
-      # intentionally empty
+      super
     end
   
     def exists?

data/lib/stubba/setup_and_teardown.rb

@@ -1,27 +1,25 @@
 require 'stubba/central'
 
-module Stubba
-  module SetupAndTeardown
+module SetupAndTeardown
   
-    def self.included(base)
-      base.add_setup_method(:setup_stubs)
-      base.add_teardown_method(:teardown_stubs)
-    end
+  def self.included(base)
+    base.add_setup_method(:setup_stubs)
+    base.add_teardown_method(:teardown_stubs)
+  end
   
-    def setup_stubs
-      $stubba = Stubba::Central.new
-    end
+  def setup_stubs
+    $stubba = Stubba::Central.new
+  end
   
-    def teardown_stubs
-      if $stubba then
-        begin
-          $stubba.verify_all { add_assertion }
-        ensure
-          $stubba.unstub_all
-          $stubba = nil
-        end
+  def teardown_stubs
+    if $stubba then
+      begin
+        $stubba.verify_all { add_assertion }
+      ensure
+        $stubba.unstub_all
+        $stubba = nil
       end
     end
-
   end
-end
+
+end

data/test/mocha/expectation_test.rb

@@ -275,7 +275,6 @@ class ExpectationSimilarExpectationsTest < Test::Unit::TestCase
     missing_expectation = MissingExpectation.new(:other_meth, @mock, [expectation]).with(1)
     exception = assert_raise(Test::Unit::AssertionFailedError) { missing_expectation.verify }
     assert_equal "Unexpected message :other_meth(1) sent to #{@mock.mocha_inspect}", exception.message
-    p exception.message
   end
   
 end

data/test/mocha_test_result_integration_test.rb

@@ -94,7 +94,7 @@ class MochaTestResultIntegrationTest < Test::Unit::TestCase
   
   def run_test(test_result = Test::Unit::TestResult.new, &block)
     test_class = Class.new(Test::Unit::TestCase) do
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       include Mocha::AutoVerify
       define_method(:test_me, &block)
     end

data/test/smart_test_case/multiple_setup_and_teardown_test.rb

@@ -7,7 +7,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   def test_should_call_added_setup
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_setup_method(:added_setup)
       define_method(:added_setup) { methods_called << :added_setup }
       define_method(:test_method) { methods_called << :test_method }
@@ -22,7 +22,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   def test_should_call_added_teardown
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_teardown_method(:added_teardown)
       define_method(:added_teardown) { methods_called << :added_teardown }
       define_method(:test_method) { methods_called << :test_method }
@@ -37,7 +37,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   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 SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_teardown_method(:added_teardown_1)
       add_teardown_method(:added_teardown_2)
       define_method(:added_teardown_1) { methods_called << :added_teardown_1 }
@@ -55,7 +55,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       define_method(:setup) { methods_called << :setup }
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_setup_method(:added_setup)
       define_method(:added_setup) { methods_called << :added_setup }
       define_method(:test_method) { methods_called << :test_method }
@@ -71,7 +71,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       define_method(:teardown) { methods_called << :teardown }
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_teardown_method(:added_teardown)
       define_method(:added_teardown) { methods_called << :added_teardown }
       define_method(:test_method) { methods_called << :test_method }
@@ -86,7 +86,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   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 SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       define_method(:setup) { methods_called << :setup }
       add_setup_method(:added_setup)
       define_method(:added_setup) { methods_called << :added_setup }
@@ -102,7 +102,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   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 SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       define_method(:teardown) { methods_called << :teardown }
       add_teardown_method(:added_teardown)
       define_method(:added_teardown) { methods_called << :added_teardown }
@@ -118,7 +118,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   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 SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_setup_method(:added_setup)
       define_method(:added_setup) { methods_called << :added_setup }
     end
@@ -136,7 +136,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
   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 SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_teardown_method(:added_teardown)
       define_method(:added_teardown) { methods_called << :added_teardown }
     end
@@ -155,7 +155,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include ActiveRecordTestCase
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_setup_method(:added_setup)
       define_method(:added_setup) { methods_called << :added_setup }
     end
@@ -174,7 +174,7 @@ class MultipleSetupAndTeardownTest < Test::Unit::TestCase
     test_case = Class.new(Test::Unit::TestCase) do
       define_method(:methods_called) { @methods_called ||= [] }
       include ActiveRecordTestCase
-      include SmartTestCase::MultipleSetupAndTeardown
+      include MultipleSetupAndTeardown
       add_teardown_method(:added_teardown)
       define_method(:added_teardown) { methods_called << :added_teardown }
     end

data/test/stubba/instance_method_test.rb

@@ -27,71 +27,20 @@ class InstanceMethodTest < Test::Unit::TestCase
     klass = Class.new
     instance = klass.new
     method = InstanceMethod.new(instance, :non_existent_method)
+
     assert_raise(Test::Unit::AssertionFailedError) { method.stub }
   end
   
-  def test_should_call_define_new_method
-    klass = Class.new { def method_x; end }
-    instance = klass.new
-    method = InstanceMethod.new(instance, :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_not_call_hide_original_method
-    klass = Class.new { def method_x; end }
-    instance = klass.new
-    method = InstanceMethod.new(instance, :method_x)
-    method.replace_instance_method(:define_new_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_not_call_restore_original_method
-    klass = Class.new { def method_x; end }
-    instance = klass.new
-    method = InstanceMethod.new(instance, :method_x)
-    method.replace_instance_method(:define_new_method) { }
-    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_not_call_remove_new_method
+  def test_should_not_raise_assertion_failed_error_when_attempting_to_stub_existing_method
     klass = Class.new { def method_x; end }
     instance = klass.new
     method = InstanceMethod.new(instance, :method_x)
-    method.replace_instance_method(:define_new_method) { }
-    method.define_instance_accessor(:remove_called)
-    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
-    
-    method.unstub
-    
-    assert !method.remove_called
+
+    assert_nothing_raised(Test::Unit::AssertionFailedError) { method.stub }
   end
   
-  def test_should_not_call_reset_mocha
-    klass = Class.new { def method_x; end }
-    instance = klass.new
-    instance.define_instance_accessor(:reset_called)
-    instance.define_instance_method(:reset_mocha) { self.reset_called = true }
-    method = InstanceMethod.new(instance, :method_x)
-    method.replace_instance_method(:define_new_method) { }
-    
-    method.unstub
-    
-    assert !instance.reset_called
+  def test_should_inherit_from_class_method
+    assert_equal ClassMethod, InstanceMethod.superclass
   end
-  
+
 end

data/test/stubba/setup_and_teardown_test.rb

@@ -14,7 +14,7 @@ class SetupAndTeardownTest < Test::Unit::TestCase
         define_method(:add_setup_method) { |symbol| @symbol = symbol }
         define_method(:add_teardown_method) {}
       end
-      include Stubba::SetupAndTeardown
+      include SetupAndTeardown
     end
     
     assert_equal :setup_stubs, test_case_class.symbol
@@ -27,7 +27,7 @@ class SetupAndTeardownTest < Test::Unit::TestCase
         define_method(:add_setup_method) {}
         define_method(:add_teardown_method) { |symbol| @symbol = symbol }
       end
-      include Stubba::SetupAndTeardown
+      include SetupAndTeardown
     end
     
     assert_equal :teardown_stubs, test_case_class.symbol
@@ -126,7 +126,7 @@ class SetupAndTeardownTest < Test::Unit::TestCase
       end
       attr_accessor :add_assertion_called
       define_method(:add_assertion) { self.add_assertion_called = true }
-      include Stubba::SetupAndTeardown
+      include SetupAndTeardown
     end
   end
 

data/test/stubba_acceptance_test.rb

@@ -68,7 +68,7 @@ class StubbaAcceptanceTest < Test::Unit::TestCase
   def test_should_stub_two_different_class_methods_again
     should_stub_two_different_class_methods
   end
-  
+
   private
   
   def should_stub_module_method

data/test/stubba_integration_test.rb

@@ -10,50 +10,87 @@ class StubbaIntegrationTest < Test::Unit::TestCase
     def self.method_x
       :original_return_value
     end
+    def instance_method_1
+      :original_return_value
+    end
+    # def self.object
+    #   @object ||= Class.new do
+    #     def instance_method_1
+    #       :original_return_value
+    #     end
+    #   end.new
+    # end
   end
   
   def test_should_stub_class_method_within_test
-    test_class = Class.new(Test::Unit::TestCase) do
-      include SmartTestCase::MultipleSetupAndTeardown
-      include Stubba::SetupAndTeardown
-      define_method(:test_me) do
-        DontMessWithMe.expects(:method_x).returns(:new_return_value)
-        assert_equal :new_return_value, DontMessWithMe.method_x
-      end
+    test = build_test do
+      DontMessWithMe.expects(:method_x).returns(:new_return_value)
+      assert_equal :new_return_value, DontMessWithMe.method_x
     end
-    test = test_class.new(:test_me)
 
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
     assert test_result.passed?
   end
 
-  def test_should_leave_stubbed_class_unchanged_after_test
-    test_class = Class.new(Test::Unit::TestCase) do
-      include SmartTestCase::MultipleSetupAndTeardown
-      include Stubba::SetupAndTeardown
-      define_method(:test_me) do
-        DontMessWithMe.expects(:method_x).returns(:new_return_value)
-      end
+  def test_should_leave_stubbed_class_method_unchanged_after_test
+    test = build_test do
+      DontMessWithMe.expects(:method_x).returns(:new_return_value)
     end
-    test = test_class.new(:test_me)
 
     test.run(Test::Unit::TestResult.new) {}
     assert_equal :original_return_value, DontMessWithMe.method_x
   end
   
-  def test_should_reset_expectations_after_test
-    test_class = Class.new(Test::Unit::TestCase) do
-      include SmartTestCase::MultipleSetupAndTeardown
-      include Stubba::SetupAndTeardown
-      define_method(:test_me) do
-        DontMessWithMe.expects(:method_x)
-      end
+  def test_should_reset_class_expectations_after_test
+    test = build_test do
+      DontMessWithMe.expects(:method_x)
     end
-    test = test_class.new(:test_me)
     
     test.run(Test::Unit::TestResult.new) {}
     assert_equal 0, DontMessWithMe.mocha.expectations.size
   end  
 
+  def test_should_stub_instance_method_within_test
+    instance = DontMessWithMe.new
+    test = build_test do
+      instance.expects(:instance_method_1).returns(:new_return_value)
+      assert_equal :new_return_value, instance.instance_method_1
+    end
+    test_result = Test::Unit::TestResult.new
+    test.run(test_result) {}
+    assert test_result.passed?
+  end
+  
+  def test_should_leave_stubbed_instance_method_unchanged_after_test
+    instance = DontMessWithMe.new
+    test = build_test do
+      instance.expects(:instance_method_1).returns(:new_return_value)
+    end
+
+    test.run(Test::Unit::TestResult.new) {}
+    assert_equal :original_return_value, instance.instance_method_1
+  end
+  
+  def test_should_reset_instance_expectations_after_test
+    instance = DontMessWithMe.new
+    test = build_test do
+      instance.expects(:instance_method_1).returns(:new_return_value)
+    end
+    
+    test.run(Test::Unit::TestResult.new) {}
+    assert_equal 0, instance.mocha.expectations.size
+  end  
+
+  private
+
+  def build_test(&block)
+    test_class = Class.new(Test::Unit::TestCase) do
+      include MultipleSetupAndTeardown
+      include SetupAndTeardown
+      define_method(:test_me, &block)
+    end
+    test_class.new(:test_me)
+  end
+
 end

data/test/stubba_test_result_integration_test.rb

@@ -74,8 +74,8 @@ class StubbaTestResultIntegrationTest < Test::Unit::TestCase
   
   def run_test(test_result = Test::Unit::TestResult.new, &block)
     test_class = Class.new(Test::Unit::TestCase) do
-      include SmartTestCase::MultipleSetupAndTeardown
-      include Stubba::SetupAndTeardown
+      include MultipleSetupAndTeardown
+      include SetupAndTeardown
       define_method(:test_me, &block)
     end
     test = test_class.new(:test_me)

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: mocha
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2006-09-06 00:00:00 +01:00
+  version: 0.3.3
+date: 2007-01-18 00:00:00 +00:00
 summary: Mocking and stubbing library
 require_paths: 
   - lib