mocha 0.3.1 → 0.3.2

data/lib/mocha/mock.rb

@@ -4,9 +4,16 @@ module Mocha
   class Mock
   
     include MockMethods
-  
-    def initialize(stub_everything = false)
+    
+    attr_reader :__mock_name
+    def initialize(stub_everything = false, name = nil)
       @stub_everything = stub_everything
+      @__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
     end
   
   end

data/lib/mocha/mock_methods.rb

@@ -1,24 +1,38 @@
 require 'mocha/expectation'
 
 module Mocha
+  # Methods added to mock objects.
+  # These methods all return an expectation which can be further modified by methods on Mocha::Expectation.
   module MockMethods
     
+    # :stopdoc:
+    
     attr_reader :stub_everything
   
     def expectations
       @expectations ||= []
     end
 
+    # :startdoc:
+
+    # :call-seq: expects(symbol) -> 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)
       expectations.last
     end
 
+    # :call-seq: stubs(symbol) -> expectation
+    #
+    # 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)
       expectations.last
     end
     
+    # :stopdoc:
+
     def method_missing(symbol, *arguments, &block)
       matching_expectation = matching_expectation(symbol, *arguments)
       if matching_expectation then
@@ -43,13 +57,19 @@ module Mocha
     end
 
   	def unexpected_method_called(symbol, *arguments)
-      MissingExpectation.new(symbol, expectations).with(*arguments).verify
+      MissingExpectation.new(symbol, self, expectations).with(*arguments).verify
     end
 	
   	def matching_expectation(symbol, *arguments)
       expectations.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

data/lib/smart_test_case.rb

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

data/lib/smart_test_case/multiple_setup_and_teardown.rb

@@ -1,123 +1,125 @@
-module MultipleSetupAndTeardown
+module SmartTestCase
+  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
+        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
-      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
+        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
-          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
+        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
-          end
-        when :teardown
-          unless method_defined?(:teardown_added)
-            alias_method :teardown_added, :teardown
-            define_method(:teardown) do
-              begin
-                teardown_added
-              ensure
-                teardown_new
+          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
-      end
 
-      class << self
+        class << self
 
-        def setup_methods
-          @setup_methods ||= []
-        end
+          def setup_methods
+            @setup_methods ||= []
+          end
 
-        def teardown_methods
-          @teardown_methods ||= []
-        end
+          def teardown_methods
+            @teardown_methods ||= []
+          end
 
-        def add_setup_method(symbol)
-          setup_methods << symbol
-        end
+          def add_setup_method(symbol)
+            setup_methods << symbol
+          end
 
-        def add_teardown_method(symbol)
-          teardown_methods << symbol
-        end
+          def add_teardown_method(symbol)
+            teardown_methods << symbol
+          end
 
-        private
+          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 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
+          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
+        end
 
-      def setup_mocha
-        self.class.class_eval { setup_methods }.each { |symbol| send(symbol) }
-      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
+        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
-        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 SetupAndTeardown unless ancestors.include?(SetupAndTeardown)
+  include Stubba::SetupAndTeardown unless ancestors.include?(Stubba::SetupAndTeardown)
 end

data/lib/stubba/object.rb

@@ -3,43 +3,60 @@ require 'stubba/instance_method'
 require 'stubba/class_method'
 require 'stubba/any_instance_method'
 
+# Methods added all Objects.
 class Object
   
-  def mocha
+  def mocha # :nodoc:
     @mocha ||= Mocha::Mock.new
   end
   
-  def reset_mocha
+  def reset_mocha # :nodoc:
     @mocha = nil
   end
   
-  def stubba_method
+  def stubba_method # :nodoc:
     Stubba::InstanceMethod
   end
   
-  def stubba_object
+  def stubba_object # :nodoc:
     self
   end
-
+  
+  # :call-seq: expects(symbol) -> expectation
+  #
+  # Adds an expectation that a method identified by +symbol+ must be called exactly once with any parameters.
+  # Returns the new expectation which can be further modified by methods on Mocha::Expectation.
+  #   product = Product.new
+  #   product.expects(:save).returns(true)
+  #   assert_equal false, product.save
   def expects(symbol) 
     method = stubba_method.new(stubba_object, symbol)
     $stubba.stub(method)
     mocha.expects(symbol, caller)
   end
   
+  # :call-seq: stubs(symbol) -> expectation
+  #
+  # Adds an expectation that a method identified by +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.
+  #   product = Product.new
+  #   product.stubs(:save).returns(true)
+  #   assert_equal false, product.save
   def stubs(symbol) 
     method = stubba_method.new(stubba_object, symbol)
     $stubba.stub(method)
     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
     mocha.verify
   end
   
 end
 
-class Module
+class Module # :nodoc:
   
   def stubba_method
     Stubba::ClassMethod
@@ -49,11 +66,11 @@ end
   
 class Class
   
-  def stubba_method
+  def stubba_method # :nodoc:
     Stubba::ClassMethod
   end
 
-  class AnyInstance
+  class AnyInstance # :nodoc:
     
     def initialize(klass)
       @stubba_object = klass
@@ -69,6 +86,14 @@ class Class
     
   end
   
+  # :call-seq: any_instance -> mock object
+  #
+  # Returns a mock object which will detect calls to any instance of this class.
+  #   Product.any_instance.stubs(:save).returns(false)
+  #   product_1 = Product.new
+  #   assert_equal false, product_1.save
+  #   product_2 = Product.new
+  #   assert_equal false, product_2.save
   def any_instance
     @any_instance ||= AnyInstance.new(self)
   end

data/lib/stubba/setup_and_teardown.rb

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