mocha 0.3.3 → 0.4.0

data/test/stubba_acceptance_test.rb

@@ -1,5 +1,5 @@
 require 'test_helper'
-require 'stubba'
+require 'mocha'
 
 class Widget
   
@@ -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

@@ -1,31 +1,24 @@
 require 'test_helper'
 
-require 'stubba/object'
-require 'smart_test_case/multiple_setup_and_teardown'
-require 'stubba/setup_and_teardown'
+require 'mocha/object'
+require 'mocha/test_case_adapter'
+require 'mocha/standalone'
 
 class StubbaIntegrationTest < Test::Unit::TestCase
   
   class DontMessWithMe
-    def self.method_x
+    def self.my_class_method
       :original_return_value
     end
-    def instance_method_1
+    def my_instance_method
       :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 = build_test do
-      DontMessWithMe.expects(:method_x).returns(:new_return_value)
-      assert_equal :new_return_value, DontMessWithMe.method_x
+      DontMessWithMe.expects(:my_class_method).returns(:new_return_value)
+      assert_equal :new_return_value, DontMessWithMe.my_class_method
     end
 
     test_result = Test::Unit::TestResult.new
@@ -35,16 +28,16 @@ class StubbaIntegrationTest < Test::Unit::TestCase
 
   def test_should_leave_stubbed_class_method_unchanged_after_test
     test = build_test do
-      DontMessWithMe.expects(:method_x).returns(:new_return_value)
+      DontMessWithMe.expects(:my_class_method).returns(:new_return_value)
     end
 
     test.run(Test::Unit::TestResult.new) {}
-    assert_equal :original_return_value, DontMessWithMe.method_x
+    assert_equal :original_return_value, DontMessWithMe.my_class_method
   end
   
   def test_should_reset_class_expectations_after_test
     test = build_test do
-      DontMessWithMe.expects(:method_x)
+      DontMessWithMe.expects(:my_class_method)
     end
     
     test.run(Test::Unit::TestResult.new) {}
@@ -54,8 +47,8 @@ class StubbaIntegrationTest < Test::Unit::TestCase
   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
+      instance.expects(:my_instance_method).returns(:new_return_value)
+      assert_equal :new_return_value, instance.my_instance_method
     end
     test_result = Test::Unit::TestResult.new
     test.run(test_result) {}
@@ -65,17 +58,17 @@ class StubbaIntegrationTest < Test::Unit::TestCase
   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)
+      instance.expects(:my_instance_method).returns(:new_return_value)
     end
 
     test.run(Test::Unit::TestResult.new) {}
-    assert_equal :original_return_value, instance.instance_method_1
+    assert_equal :original_return_value, instance.my_instance_method
   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)
+      instance.expects(:my_instance_method).returns(:new_return_value)
     end
     
     test.run(Test::Unit::TestResult.new) {}
@@ -86,8 +79,8 @@ class StubbaIntegrationTest < Test::Unit::TestCase
 
   def build_test(&block)
     test_class = Class.new(Test::Unit::TestCase) do
-      include MultipleSetupAndTeardown
-      include SetupAndTeardown
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
       define_method(:test_me, &block)
     end
     test_class.new(:test_me)

data/test/stubba_test_result_integration_test.rb

@@ -1,8 +1,7 @@
 require 'test_helper'
-require 'stubba/object'
-require 'smart_test_case/multiple_setup_and_teardown'
-require 'stubba/setup_and_teardown'
-require 'shared/backtracefilter'
+require 'mocha/object'
+require 'mocha/standalone'
+require 'mocha/test_case_adapter'
 require 'execution_point'
 
 class StubbaTestResultIntegrationTest < Test::Unit::TestCase
@@ -74,8 +73,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 MultipleSetupAndTeardown
-      include SetupAndTeardown
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
       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.3
-date: 2007-01-18 00:00:00 +00:00
+  version: 0.4.0
+date: 2007-01-22 00:00:00 +00:00
 summary: Mocking and stubbing library
 require_paths: 
   - lib
@@ -31,48 +31,52 @@ authors:
   - James Mead
 files: 
   - lib/mocha.rb
-  - lib/smart_test_case.rb
+  - lib/mocha_standalone.rb
   - lib/stubba.rb
+  - lib/mocha/any_instance_method.rb
   - lib/mocha/auto_verify.rb
+  - lib/mocha/central.rb
+  - lib/mocha/class_method.rb
   - lib/mocha/expectation.rb
+  - lib/mocha/expectation_error.rb
   - lib/mocha/infinite_range.rb
   - lib/mocha/inspect.rb
+  - lib/mocha/instance_method.rb
   - lib/mocha/metaclass.rb
   - lib/mocha/mock.rb
   - lib/mocha/mock_methods.rb
+  - lib/mocha/object.rb
   - lib/mocha/pretty_parameters.rb
-  - lib/shared/backtracefilter.rb
-  - lib/smart_test_case/multiple_setup_and_teardown.rb
-  - lib/stubba/any_instance_method.rb
-  - lib/stubba/central.rb
-  - lib/stubba/class_method.rb
-  - lib/stubba/instance_method.rb
-  - lib/stubba/object.rb
-  - lib/stubba/setup_and_teardown.rb
+  - lib/mocha/setup_and_teardown.rb
+  - lib/mocha/standalone.rb
+  - lib/mocha/test_case_adapter.rb
   - test/active_record_test_case.rb
   - test/all_tests.rb
   - test/execution_point.rb
   - test/method_definer.rb
   - test/mocha_acceptance_test.rb
   - test/mocha_test_result_integration_test.rb
+  - test/standalone_acceptance_test.rb
   - test/stubba_acceptance_test.rb
   - test/stubba_integration_test.rb
   - test/stubba_test_result_integration_test.rb
   - test/test_helper.rb
+  - test/mocha/any_instance_method_test.rb
   - test/mocha/auto_verify_test.rb
+  - test/mocha/central_test.rb
+  - test/mocha/class_method_test.rb
   - test/mocha/expectation_test.rb
   - test/mocha/infinite_range_test.rb
   - test/mocha/inspect_test.rb
+  - test/mocha/metaclass_test.rb
   - test/mocha/mock_methods_test.rb
   - test/mocha/mock_test.rb
+  - test/mocha/object_test.rb
   - test/mocha/pretty_parameters_test.rb
-  - test/smart_test_case/multiple_setup_and_teardown_test.rb
-  - test/stubba/any_instance_method_test.rb
-  - test/stubba/central_test.rb
-  - test/stubba/class_method_test.rb
-  - test/stubba/instance_method_test.rb
-  - test/stubba/object_test.rb
-  - test/stubba/setup_and_teardown_test.rb
+  - test/mocha/setup_and_teardown_test.rb
+  - examples/misc.rb
+  - examples/mocha.rb
+  - examples/stubba.rb
   - COPYING
   - MIT-LICENSE
   - Rakefile

data/lib/shared/backtracefilter.rb

@@ -1,46 +0,0 @@
-module Test
-  module Unit
-    module Util
-      module BacktraceFilter
-        
-        # quick rip-off of Test::Unit code - there must be a better way of doing this!
-        
-        MOCHA_FILE_SEPARATORS = %r{[\\/:]}
-        MOCHA_PREFIX = __FILE__.split(MOCHA_FILE_SEPARATORS)[0..-3]
-        MOCHA_RB_FILE = /\.rb\Z/
-        
-        alias_method :__filter_backtrace__, :filter_backtrace
-        
-        def filter_backtrace(backtrace, prefix=nil)
-          backtrace = __filter_backtrace__(backtrace, prefix)
-          return ["No backtrace"] unless(backtrace)
-          split_p = if(prefix)
-            prefix.split(MOCHA_FILE_SEPARATORS)
-          else
-            MOCHA_PREFIX
-          end
-          match = proc do |e|
-            split_e = e.split(MOCHA_FILE_SEPARATORS)[0, split_p.size]
-            next false unless(split_e[0..-2] == split_p[0..-2])
-            split_e[-1].sub(MOCHA_RB_FILE, '') == split_p[-1]
-          end
-          return backtrace unless(backtrace.detect(&match))
-          found_prefix = false
-          new_backtrace = backtrace.reverse.reject do |e|
-            if(match[e])
-              found_prefix = true
-              true
-            elsif(found_prefix)
-              false
-            else
-              true
-            end
-          end.reverse
-          new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
-          new_backtrace = new_backtrace.reject(&match)
-          new_backtrace.empty? ? backtrace : new_backtrace
-        end
-      end
-    end
-  end
-end

data/lib/smart_test_case.rb

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

data/lib/smart_test_case/multiple_setup_and_teardown.rb

@@ -1,123 +0,0 @@
-module MultipleSetupAndTeardown
-  
-  def self.included(base)
-
-    base.class_eval do
-  
-      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
-          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
-          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
-          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
-
-        def add_setup_method(symbol)
-          setup_methods << symbol
-        end
-
-        def add_teardown_method(symbol)
-          teardown_methods << symbol
-        end
-
-        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
-
-        if respond_to?(:inherited, true)
-          alias_method :inherited_without_setup_and_teardown_methods, :inherited
-        end
-        alias_method :inherited, :inherited_with_setup_and_teardown_methods
-
-      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
-        end
-        raise stored_exception if stored_exception
-      end
-
-    end
-
-  end
-
-end

data/lib/stubba/instance_method.rb

@@ -1,18 +0,0 @@
-require 'stubba/class_method'
-
-module Stubba
-
-  class InstanceMethod < ClassMethod
-   
-    def stub
-      raise cannot_replace_method_error unless exists?
-      super
-    end
-  
-    def exists?
-      stubbee.respond_to?(method)
-    end
-    
-  end
-  
-end

data/lib/stubba/setup_and_teardown.rb

@@ -1,25 +0,0 @@
-require 'stubba/central'
-
-module SetupAndTeardown
-  
-  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 teardown_stubs
-    if $stubba then
-      begin
-        $stubba.verify_all { add_assertion }
-      ensure
-        $stubba.unstub_all
-        $stubba = nil
-      end
-    end
-  end
-
-end

data/test/smart_test_case/multiple_setup_and_teardown_test.rb

@@ -1,192 +0,0 @@
-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_should_call_added_setup
-    test_case = Class.new(Test::Unit::TestCase) do
-      define_method(:methods_called) { @methods_called ||= [] }
-      include MultipleSetupAndTeardown
-      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, :test_method], test.methods_called
-  end
-  
-  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(: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_method)
-    test_result = Test::Unit::TestResult.new
-    test.run(test_result) {}
-    assert test_result.passed?
-    assert_equal [:test_method, :added_teardown, :teardown], test.methods_called
-  end
-  
-  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(: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_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
-    test_case = Class.new(Test::Unit::TestCase) do
-      define_method(:methods_called) { @methods_called ||= [] }
-      include MultipleSetupAndTeardown
-      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_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 [:added_setup, :setup, :test_method], test.methods_called
-  end
-  
-  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(: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_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, :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