mocha 0.3.3 → 0.4.0

data/lib/mocha/expectation_error.rb

@@ -0,0 +1,6 @@
+module Mocha
+
+  class ExpectationError < StandardError
+  end
+  
+end

data/lib/mocha/inspect.rb

@@ -2,7 +2,7 @@ require 'date'
 
 class Object
   def mocha_inspect
-    inspect =~ /#</ ? "#<#{self.class}: #{self.object_id}>" : inspect
+    inspect =~ /#</ ? "#<#{self.class}:0x#{self.__id__.to_s(16)}>" : inspect
   end
 end
 

data/lib/mocha/instance_method.rb

@@ -0,0 +1,8 @@
+require 'mocha/class_method'
+
+module Mocha
+
+  class InstanceMethod < ClassMethod
+  end
+  
+end

data/lib/mocha/metaclass.rb

@@ -1,6 +1,6 @@
 class Object
   
-  def metaclass
+  def __metaclass__
     class << self; self; end
   end
 

data/lib/mocha/mock.rb

@@ -1,20 +1,20 @@
 require 'mocha/mock_methods'
 
 module Mocha
+
   class Mock
-  
-    include MockMethods
     
-    attr_reader :__mock_name
+    include MockMethods
+
     def initialize(stub_everything = false, name = nil)
       @stub_everything = stub_everything
-      @__mock_name = name
+      @mock_name = name
     end
-    
-    alias :mocha_inspect_before_hijacked_by_named_mocks :mocha_inspect
+
     def mocha_inspect
-      @__mock_name ? "#<Mock: '#{@__mock_name}'>" : mocha_inspect_before_hijacked_by_named_mocks
+      @mock_name ? "#<Mock:#{@mock_name}>" : "#<Mock:0x#{__id__.to_s(16)}>"
     end
-  
+
   end
+
 end

data/lib/mocha/mock_methods.rb

@@ -1,4 +1,5 @@
 require 'mocha/expectation'
+require 'mocha/metaclass'
 
 module Mocha
   # Methods added to mock objects.
@@ -15,22 +16,69 @@ module Mocha
 
     # :startdoc:
 
-    # :call-seq: expects(symbol) -> expectation
+    # :call-seq: expects(method_name) -> expectation
+    #            expects(method_names) -> last expectation
     #
-    # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
-    def expects(symbol, backtrace = nil)
-      expectations << Expectation.new(symbol, backtrace)
+    # Adds an expectation that a method identified by +method_name+ symbol must be called exactly once with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   object = mock()
+    #   object.expects(:method1)
+    #   object.method1
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method1)
+    #   # error raised, because method1 not called exactly once
+    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   object = mock()
+    #   object.expects(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
+    #
+    #   object = mock()
+    #   object.expects(:method1).returns(:result1)
+    #   object.expects(:method2).returns(:result2)
+    def expects(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Expectation.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
       expectations.last
     end
 
-    # :call-seq: stubs(symbol) -> expectation
+    alias_method :__expects__, :expects
+
+    # :call-seq: stubs(method_name) -> expectation
+    #            stubs(method_names) -> last expectation
+    #
+    # Adds an expectation that a method identified by +method_name+ symbol may be called any number of times with any parameters.
+    # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+    #   object = mock()
+    #   object.stubs(:method1)
+    #   object.method1
+    #   object.method1
+    #   # no error raised
+    # If +method_names+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   object = mock()
+    #   object.stubs(:method1 => :result1, :method2 => :result2)
+    #
+    #   # exactly equivalent to
     #
-    # Adds an expectation that a method identified by +symbol+ may be called any number of times with any parameters.
-    def stubs(symbol, backtrace = nil)
-      expectations << Stub.new(symbol, backtrace)
+    #   object = mock()
+    #   object.stubs(:method1).returns(:result1)
+    #   object.stubs(:method2).returns(:result2)
+    def stubs(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Stub.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
       expectations.last
     end
     
+    alias_method :__stubs__, :stubs
+
     # :stopdoc:
 
     def method_missing(symbol, *arguments, &block)
@@ -57,22 +105,18 @@ module Mocha
     end
 
   	def unexpected_method_called(symbol, *arguments)
-      MissingExpectation.new(symbol, self, expectations).with(*arguments).verify
+      MissingExpectation.new(self, symbol).with(*arguments).verify
     end
 	
   	def matching_expectation(symbol, *arguments)
-      expectations.detect { |expectation| expectation.match?(symbol, *arguments) }
+      expectations.reverse.detect { |expectation| expectation.match?(symbol, *arguments) }
     end
   
-    # :startdoc:
-
-    # :call-seq: verify
-    # 
-    # Asserts that all expectations have been fulfilled.
-    # Called automatically at the end of a test for mock objects created by methods in Mocha::AutoVerify.
     def verify(&block)
       expectations.each { |expectation| expectation.verify(&block) }
     end
   
+    # :startdoc:
+
   end
 end

data/lib/{stubba → mocha}/object.rb

@@ -1,7 +1,7 @@
 require 'mocha/mock'
-require 'stubba/instance_method'
-require 'stubba/class_method'
-require 'stubba/any_instance_method'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/any_instance_method'
 
 # Methods added all Objects.
 class Object
@@ -15,7 +15,7 @@ class Object
   end
   
   def stubba_method # :nodoc:
-    Stubba::InstanceMethod
+    Mocha::InstanceMethod
   end
   
   def stubba_object # :nodoc:
@@ -48,9 +48,7 @@ class Object
     mocha.stubs(symbol, caller)
   end
   
-  # Asserts that all expectations have been fulfilled.
-  # Called automatically at the end of a test for all objects with expectations.
-  def verify
+  def verify # :nodoc:
     mocha.verify
   end
   
@@ -59,7 +57,7 @@ end
 class Module # :nodoc:
   
   def stubba_method
-    Stubba::ClassMethod
+    Mocha::ClassMethod
   end
     
 end
@@ -67,7 +65,7 @@ end
 class Class
   
   def stubba_method # :nodoc:
-    Stubba::ClassMethod
+    Mocha::ClassMethod
   end
 
   class AnyInstance # :nodoc:
@@ -77,7 +75,7 @@ class Class
     end
     
     def stubba_method
-      Stubba::AnyInstanceMethod
+      Mocha::AnyInstanceMethod
     end
     
     def stubba_object

data/lib/mocha/setup_and_teardown.rb

@@ -0,0 +1,23 @@
+require 'mocha/central'
+
+module Mocha
+  
+  module SetupAndTeardown
+  
+    def setup_stubs
+      $stubba = Mocha::Central.new
+    end
+    
+    def verify_stubs
+      $stubba.verify_all { yield if block_given? } if $stubba
+    end
+  
+    def teardown_stubs
+      if $stubba then
+        $stubba.unstub_all
+        $stubba = nil
+      end
+    end
+
+  end
+end

data/lib/mocha/standalone.rb

@@ -0,0 +1,30 @@
+require 'mocha/auto_verify'
+require 'mocha/setup_and_teardown'
+
+module Mocha
+  
+  module Standalone
+    
+    include AutoVerify
+    include SetupAndTeardown
+    
+    def mocha_setup
+      setup_stubs
+    end
+    
+    def mocha_verify(&block)
+      verify_mocks(&block)
+      verify_stubs(&block)
+    end
+    
+    def mocha_teardown
+      begin
+        teardown_mocks
+      ensure
+        teardown_stubs
+      end
+    end
+    
+  end
+  
+end

data/lib/mocha/test_case_adapter.rb

@@ -0,0 +1,49 @@
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module TestCaseAdapter
+
+    def self.included(base)
+      base.class_eval do
+
+        alias_method :run_before_mocha_test_case_adapter, :run
+
+        def run(result)
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
+          begin
+            mocha_setup
+            begin
+              setup
+              __send__(@method_name)
+              mocha_verify { add_assertion }
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue StandardError, ScriptError
+              add_error($!)
+            ensure
+              begin
+                teardown
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue StandardError, ScriptError
+                add_error($!)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
+        end
+                
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha_standalone.rb

@@ -0,0 +1,2 @@
+require 'mocha/standalone'
+require 'mocha/object'

data/lib/stubba.rb

@@ -1,8 +1,2 @@
-require 'stubba/object'
-require 'smart_test_case'
-require 'stubba/setup_and_teardown'
-require 'shared/backtracefilter'
-
-class Test::Unit::TestCase
-  include SetupAndTeardown unless ancestors.include?(SetupAndTeardown)
-end
+# for backwards compatibility
+require 'mocha'

data/test/all_tests.rb

@@ -8,14 +8,12 @@ require 'mocha/mock_methods_test'
 require 'mocha/mock_test'
 require 'mocha/auto_verify_test'
 
-require 'stubba/central_test'
-require 'stubba/class_method_test'
-require 'stubba/instance_method_test'
-require 'stubba/any_instance_method_test'
-require 'stubba/setup_and_teardown_test'
-require 'stubba/object_test'
-
-require 'smart_test_case/multiple_setup_and_teardown_test'
+require 'mocha/central_test'
+require 'mocha/class_method_test'
+require 'mocha/any_instance_method_test'
+require 'mocha/setup_and_teardown_test'
+require 'mocha/object_test'
+require 'mocha/metaclass_test'
 
 class UnitTests
   
@@ -30,11 +28,10 @@ class UnitTests
     suite << AutoVerifyTest.suite
     suite << CentralTest.suite
     suite << ClassMethodTest.suite
-    suite << InstanceMethodTest.suite
     suite << AnyInstanceMethodTest.suite
     suite << SetupAndTeardownTest.suite
     suite << ObjectTest.suite
-    suite << MultipleSetupAndTeardownTest.suite
+    suite << MetaclassTest.suite
     suite
   end
   
@@ -61,6 +58,7 @@ Test::Unit::UI::Console::TestRunner.run(IntegrationTests)
 
 require 'mocha_acceptance_test'
 require 'stubba_acceptance_test'
+require 'standalone_acceptance_test'
 
 class AcceptanceTests
   
@@ -68,6 +66,7 @@ class AcceptanceTests
     suite = Test::Unit::TestSuite.new('AcceptanceTests')
     suite << MochaAcceptanceTest.suite
     suite << StubbaAcceptanceTest.suite
+    suite << StandaloneAcceptanceTest.suite
     suite
   end
   

data/test/method_definer.rb

@@ -3,7 +3,7 @@ require 'mocha/metaclass'
 class Object
   
   def define_instance_method(method_symbol, &block)
-    metaclass.send(:define_method, method_symbol, block)
+    __metaclass__.send(:define_method, method_symbol, block)
   end
 
   def replace_instance_method(method_symbol, &block)
@@ -12,7 +12,7 @@ class Object
   end
 
   def define_instance_accessor(*symbols)
-    symbols.each { |symbol| metaclass.send(:attr_accessor, symbol) }
+    symbols.each { |symbol| __metaclass__.send(:attr_accessor, symbol) }
   end
 
 end

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

@@ -1,12 +1,10 @@
 require File.join(File.dirname(__FILE__), "..", "test_helper")
 require 'method_definer'
 require 'mocha/mock'
-
-require 'stubba/any_instance_method'
+require 'mocha/any_instance_method'
 
 class AnyInstanceMethodTest < Test::Unit::TestCase
   
-  include Stubba
   include Mocha
   
   def test_should_hide_original_method

data/test/mocha/auto_verify_test.rb

@@ -95,7 +95,7 @@ class AutoVerifyTest < Test::Unit::TestCase
     assert_equal expected, test_case.mocks
   end
   
-  def test_should_verify_each_mock_on_teardown
+  def test_should_verify_each_mock
     mocks = Array.new(3) do
       mock = Object.new
       mock.define_instance_accessor(:verify_called)
@@ -103,20 +103,19 @@ class AutoVerifyTest < Test::Unit::TestCase
       mock
     end
     test_case.replace_instance_method(:mocks)  { mocks }
-    test_case.teardown_mocks
+    test_case.verify_mocks
     assert mocks.all? { |mock| mock.verify_called }
   end
   
-  def test_should_provide_block_for_adding_assertion
+  def test_should_yield_to_block_for_each_assertion
     mock_class = Class.new do
       def verify(&block); yield; end
     end
     mock = mock_class.new
     test_case.replace_instance_method(:mocks)  { [mock] }
-    test_case.define_instance_accessor(:add_assertion_called)
-    test_case.define_instance_method(:add_assertion) { self.add_assertion_called = true }
-    test_case.teardown_mocks
-    assert test_case.add_assertion_called
+    yielded = false
+    test_case.verify_mocks { yielded = true }
+    assert yielded
   end
   
   def test_should_reset_mocks_on_teardown
@@ -148,17 +147,17 @@ class AutoVerifyTest < Test::Unit::TestCase
   
   def test_should_create_mock_with_name
     mock = test_case.mock('named_mock')
-    assert_equal 'named_mock', mock.__mock_name
+    assert_equal '#<Mock:named_mock>', mock.mocha_inspect
   end
   
   def test_should_create_stub_with_name
     stub = test_case.stub('named_stub')
-    assert_equal 'named_stub', stub.__mock_name
+    assert_equal '#<Mock:named_stub>', stub.mocha_inspect
   end
   
   def test_should_create_greedy_stub_with_name
     greedy_stub = test_case.stub_everything('named_greedy_stub')
-    assert_equal 'named_greedy_stub', greedy_stub.__mock_name
+    assert_equal '#<Mock:named_greedy_stub>', greedy_stub.mocha_inspect
   end
   
 end