mocha 0.5.6 → 0.9.0

data/lib/mocha/logger.rb

@@ -0,0 +1,15 @@
+module Mocha
+  
+  class Logger
+    
+    def initialize(io)
+      @io = io
+    end
+    
+    def warn(message)
+      @io.puts "WARNING: #{message}"
+    end
+    
+  end
+  
+end

data/lib/mocha/mock.rb

@@ -1,8 +1,10 @@
 require 'mocha/expectation'
 require 'mocha/expectation_list'
-require 'mocha/stub'
-require 'mocha/missing_expectation'
 require 'mocha/metaclass'
+require 'mocha/names'
+require 'mocha/mockery'
+require 'mocha/method_matcher'
+require 'mocha/parameters_matcher'
 
 module Mocha # :nodoc:
   
@@ -72,11 +74,11 @@ module Mocha # :nodoc:
       if method_name_or_hash.is_a?(Hash) then
         method_name_or_hash.each do |method_name, return_value|
           ensure_method_not_already_defined(method_name)
-          @expectations.add(Stub.new(self, method_name, backtrace).returns(return_value))
+          @expectations.add(Expectation.new(self, method_name, backtrace).at_least(0).returns(return_value))
         end
       else
         ensure_method_not_already_defined(method_name_or_hash)
-        @expectations.add(Stub.new(self, method_name_or_hash, backtrace))
+        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace).at_least(0))
       end
     end
     
@@ -128,7 +130,7 @@ module Mocha # :nodoc:
     # :stopdoc:
     
     def initialize(name = nil, &block)
-      @mock_name = name
+      @name = name || DefaultName.new(self)
       @expectations = ExpectationList.new
       @everything_stubbed = false
       @responder = nil
@@ -172,19 +174,22 @@ module Mocha # :nodoc:
         @expectations.matches_method?(symbol)
       end
     end
-  
+    
     def unexpected_method_called(symbol, *arguments)
-      MissingExpectation.new(self, symbol).with(*arguments).verify
+      method_matcher = MethodMatcher.new(symbol)
+      parameters_matcher = ParametersMatcher.new(arguments)
+      method_signature = "#{mocha_inspect}.#{method_matcher.mocha_inspect}#{parameters_matcher.mocha_inspect}"
+      message = "unexpected invocation: #{method_signature}\n"
+      message << Mockery.instance.mocha_inspect
+      raise ExpectationError.new(message, caller)
     end
-  
-    def verify(&block)
-      @expectations.verify(&block)
+    
+    def verified?(assertion_counter = nil)
+      @expectations.verified?(assertion_counter)
     end
-  
+    
     def mocha_inspect
-      address = self.__id__ * 2
-      address += 0x100000000 if address < 0
-      @mock_name ? "#<Mock:#{@mock_name}>" : "#<Mock:0x#{'%x' % address}>"
+      @name.mocha_inspect
     end
     
     def inspect

data/lib/mocha/mockery.rb

@@ -0,0 +1,166 @@
+require 'mocha/central'
+require 'mocha/mock'
+require 'mocha/names'
+require 'mocha/state_machine'
+require 'mocha/logger'
+require 'mocha/configuration'
+require 'mocha/stubbing_error'
+
+module Mocha
+  
+  class Mockery
+    
+    class << self
+      
+      def instance
+        @instance ||= new
+      end
+      
+      def reset_instance
+        @instance = nil
+      end
+      
+    end
+    
+    def named_mock(name, &block)
+      add_mock(Mock.new(Name.new(name), &block))
+    end
+    
+    def unnamed_mock(&block)
+      add_mock(Mock.new(&block))
+    end
+    
+    def mock_impersonating(object, &block)
+      add_mock(Mock.new(ImpersonatingName.new(object), &block))
+    end
+    
+    def mock_impersonating_any_instance_of(klass, &block)
+      add_mock(Mock.new(ImpersonatingAnyInstanceName.new(klass), &block))
+    end
+    
+    def new_state_machine(name)
+      add_state_machine(StateMachine.new(name))
+    end
+    
+    def verify(assertion_counter = nil)
+      unless mocks.all? { |mock| mock.verified?(assertion_counter) }
+        message = "not all expectations were satisfied\n#{mocha_inspect}"
+        if unsatisfied_expectations.empty?
+          backtrace = caller
+        else
+          backtrace = unsatisfied_expectations[0].backtrace
+        end
+        raise ExpectationError.new(message, backtrace)
+      end
+      expectations.each do |e|
+        on_stubbing_method_unnecessarily(e) unless e.used?
+      end
+    end
+    
+    def teardown
+      stubba.unstub_all
+      reset
+    end
+    
+    def stubba
+      @stubba ||= Central.new
+    end
+    
+    def mocks
+      @mocks ||= []
+    end
+    
+    def state_machines
+      @state_machines ||= []
+    end
+    
+    def mocha_inspect
+      message = ""
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
+      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message
+    end
+    
+    def on_stubbing(object, symbol)
+      on_stubbing_non_existent_method(object, symbol) unless object.method_exists?(symbol, include_public_methods = true)
+      on_stubbing_non_public_method(object, symbol) if object.method_exists?(symbol, include_public_methods = false)
+      on_stubbing_method_on_non_mock_object(object, symbol)
+    end
+    
+    def on_stubbing_non_existent_method(object, symbol)
+      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
+        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{symbol}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
+        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{symbol}"
+      end
+    end
+    
+    def on_stubbing_non_public_method(object, symbol)
+      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
+        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{symbol}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
+        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{symbol}"
+      end
+    end
+    
+    def on_stubbing_method_on_non_mock_object(object, symbol)
+      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
+        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{symbol}", caller)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
+        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{symbol}"
+      end
+    end
+    
+    def on_stubbing_method_unnecessarily(expectation)
+      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
+        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
+      end
+      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
+        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      end
+    end
+    
+    attr_writer :logger
+    
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+    
+    
+    private
+    
+    def expectations
+      mocks.map { |mock| mock.expectations.to_a }.flatten
+    end
+    
+    def unsatisfied_expectations
+      expectations.reject { |e| e.verified? }
+    end
+    
+    def satisfied_expectations
+      expectations.select { |e| e.verified? }
+    end
+    
+    def add_mock(mock)
+      mocks << mock
+      mock
+    end
+    
+    def add_state_machine(state_machine)
+      state_machines << state_machine
+      state_machine
+    end
+    
+    def reset
+      @stubba = nil
+      @mocks = nil
+      @state_machines = nil
+    end
+    
+  end
+  
+end

data/lib/mocha/module_method.rb

@@ -0,0 +1,17 @@
+require 'mocha/module_method'
+
+module Mocha
+
+  class ModuleMethod < ClassMethod
+
+    def method_exists?(method)
+      existing_methods = []
+      existing_methods += stubbee.public_methods(false)
+      existing_methods += stubbee.protected_methods(false)
+      existing_methods += stubbee.private_methods(false)
+      existing_methods.any? { |m| m.to_s == method.to_s }
+    end
+
+  end
+  
+end

data/lib/mocha/names.rb

@@ -0,0 +1,53 @@
+module Mocha
+  
+  class ImpersonatingName
+    
+    def initialize(object)
+      @object = object
+    end
+    
+    def mocha_inspect
+      @object.mocha_inspect
+    end
+    
+  end
+  
+  class ImpersonatingAnyInstanceName
+    
+    def initialize(klass)
+      @klass = klass
+    end
+    
+    def mocha_inspect
+      "#<AnyInstance:#{@klass.mocha_inspect}>"
+    end
+    
+  end
+  
+  class Name
+    
+    def initialize(name)
+      @name = name
+    end
+    
+    def mocha_inspect
+      "#<Mock:#{@name}>"
+    end
+    
+  end
+  
+  class DefaultName
+    
+    def initialize(mock)
+      @mock = mock
+    end
+    
+    def mocha_inspect
+      address = @mock.__id__ * 2
+      address += 0x100000000 if address < 0
+      "#<Mock:0x#{'%x' % address}>"
+    end
+    
+  end
+  
+end

data/lib/mocha/object.rb

@@ -1,6 +1,7 @@
-require 'mocha/mock'
+require 'mocha/mockery'
 require 'mocha/instance_method'
 require 'mocha/class_method'
+require 'mocha/module_method'
 require 'mocha/any_instance_method'
 
 # Methods added all objects to allow mocking and stubbing on real objects.
@@ -9,7 +10,7 @@ require 'mocha/any_instance_method'
 class Object
   
   def mocha # :nodoc:
-    @mocha ||= Mocha::Mock.new
+    @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
   end
   
   def reset_mocha # :nodoc:
@@ -35,9 +36,11 @@ class Object
   # The original implementation of <tt>Product#save</tt> is replaced temporarily.
   #
   # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def expects(symbol) 
+  def expects(symbol)
+    mockery = Mocha::Mockery.instance
+    mockery.on_stubbing(self, symbol)
     method = stubba_method.new(stubba_object, symbol)
-    $stubba.stub(method)
+    mockery.stubba.stub(method)
     mocha.expects(symbol, caller)
   end
   
@@ -52,14 +55,18 @@ class Object
   # The original implementation of <tt>Product#save</tt> is replaced temporarily.
   #
   # The original implementation of <tt>Product#save</tt> is restored at the end of the test.
-  def stubs(symbol) 
+  def stubs(symbol)
+    mockery = Mocha::Mockery.instance
+    mockery.on_stubbing(self, symbol)
     method = stubba_method.new(stubba_object, symbol)
-    $stubba.stub(method)
+    mockery.stubba.stub(method)
     mocha.stubs(symbol, caller)
   end
   
-  def verify # :nodoc:
-    mocha.verify
+  def method_exists?(symbol, include_public_methods = true)
+    existing_methods = private_methods(include_superclass_methods = true) + protected_methods(include_superclass_methods = true)
+    existing_methods += public_methods(include_superclass_methods = true) if include_public_methods
+    existing_methods.any? { |m| m.to_s == symbol.to_s } || (respond_to?(symbol) && include_public_methods)
   end
   
 end
@@ -67,7 +74,7 @@ end
 class Module # :nodoc:
   
   def stubba_method
-    Mocha::ClassMethod
+    Mocha::ModuleMethod
   end
     
 end
@@ -84,6 +91,10 @@ class Class
       @stubba_object = klass
     end
     
+    def mocha
+      @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+    end
+
     def stubba_method
       Mocha::AnyInstanceMethod
     end
@@ -92,6 +103,12 @@ class Class
       @stubba_object
     end
     
+    def method_exists?(symbol, include_public_methods = true)
+      existing_methods = @stubba_object.private_instance_methods(include_superclass_methods = true) + @stubba_object.protected_instance_methods(include_superclass_methods = true)
+      existing_methods += @stubba_object.public_instance_methods(include_superclass_methods = true) if include_public_methods
+      existing_methods.any? { |m| m.to_s == symbol.to_s }
+    end
+    
   end
   
   # :call-seq: any_instance -> mock object

data/lib/mocha/parameter_matchers.rb

@@ -1,6 +1,6 @@
 module Mocha
   
-  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation.
+  # Used as parameters for Expectation#with to restrict the parameter values which will match the expectation. Can be nested.
   module ParameterMatchers; end
   
 end
@@ -23,3 +23,4 @@ require 'mocha/parameter_matchers/kind_of'
 require 'mocha/parameter_matchers/not'
 require 'mocha/parameter_matchers/optionally'
 require 'mocha/parameter_matchers/regexp_matches'
+require 'mocha/parameter_matchers/yaml_equivalent'

data/lib/mocha/parameter_matchers/all_of.rb

@@ -4,9 +4,9 @@ module Mocha
   
   module ParameterMatchers
 
-    # :call-seq: all_of -> parameter_matcher
+    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
     #
-    # Matches if all +matchers+ match.
+    # Matches if all +parameter_matchers+ match.
     #   object = mock()
     #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
     #   object.method_1([1, 3])
@@ -28,7 +28,7 @@ module Mocha
     
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @matchers.all? { |matcher| matcher.matches?([parameter]) }
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/any_of.rb

@@ -4,9 +4,9 @@ module Mocha
   
   module ParameterMatchers
 
-    # :call-seq: any_of -> parameter_matcher
+    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
     #
-    # Matches if any +matchers+ match.
+    # Matches if any +parameter_matchers+ match.
     #   object = mock()
     #   object.expects(:method_1).with(any_of(1, 3))
     #   object.method_1(1)
@@ -33,7 +33,7 @@ module Mocha
     
       def matches?(available_parameters)
         parameter = available_parameters.shift
-        @matchers.any? { |matcher| matcher.matches?([parameter]) }
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
       end
       
       def mocha_inspect