mocha 0.5.5 → 0.5.6

data/lib/mocha/expectation_error.rb

@@ -1,6 +1,15 @@
 module Mocha
 
   class ExpectationError < StandardError
+    
+    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
+    
+    def initialize(message = nil, backtrace = [], lib_directory = LIB_DIRECTORY)
+      super(message)
+      filtered_backtrace = backtrace.reject { |location| Regexp.new(lib_directory).match(File.expand_path(location)) }
+      set_backtrace(filtered_backtrace)
+    end
+
   end
   
 end

data/lib/mocha/expectation_list.rb

@@ -8,20 +8,21 @@ module Mocha # :nodoc:
 
     def add(expectation)
       @expectations << expectation
+      expectation
     end
 
-    def respond_to?(method_name)
-      @expectations.any? { |expectation| expectation.method_name == method_name }
+    def matches_method?(method_name)
+      @expectations.any? { |expectation| expectation.matches_method?(method_name) }
     end
 
-    def detect(method_name, *arguments)
-      expectations = @expectations.reverse.select { |expectation| expectation.match?(method_name, *arguments) }
-      expectation = expectations.detect { |expectation| expectation.invocations_allowed? }
-      expectation || expectations.first
+    def similar(method_name)
+      @expectations.select { |expectation| expectation.matches_method?(method_name) }
     end
 
-    def similar(method_name)
-      @expectations.select { |expectation| expectation.method_name == method_name }
+    def detect(method_name, *arguments)
+      expectations = @expectations.reverse.select { |e| e.match?(method_name, *arguments) }
+      expectation = expectations.detect { |e| e.invocations_allowed? }
+      expectation || expectations.first
     end
 
     def verify(&block)
@@ -36,8 +37,8 @@ module Mocha # :nodoc:
       @expectations.to_set
     end
 
-    def size
-      @expectations.size
+    def length
+      @expectations.length
     end
 
   end

data/lib/mocha/method_matcher.rb

@@ -0,0 +1,21 @@
+module Mocha
+  
+  class MethodMatcher
+    
+    attr_reader :expected_method_name
+    
+    def initialize(expected_method_name)
+      @expected_method_name = expected_method_name
+    end
+    
+    def match?(actual_method_name)
+      @expected_method_name == actual_method_name
+    end
+    
+    def mocha_inspect
+      "#{@expected_method_name}"
+    end
+    
+  end
+
+end

data/lib/mocha/missing_expectation.rb

@@ -4,22 +4,12 @@ module Mocha # :nodoc:
   
   class MissingExpectation < Expectation # :nodoc:
 
-    def initialize(mock, method_name)
-      super
-      @invoked_count = true
-    end
-
     def verify
-      msg = error_message(0, 1)
-      similar_expectations_list = @mock.similar_expectations(@method_name).collect { |expectation| expectation.method_signature }.join("\n")
-      msg << "\nSimilar expectations:\n#{similar_expectations_list}" unless similar_expectations_list.empty?
-      error = ExpectationError.new(msg)
-      error.set_backtrace(filtered_backtrace)
-      raise error if @invoked_count
-    end
-
-    def similar_expectations
-      @mock.similar_expectations(method_name)
+      message = error_message(0, 1)
+      similar_expectations = @mock.expectations.similar(@method_matcher.expected_method_name)
+      method_signatures = similar_expectations.map { |expectation| expectation.method_signature }
+      message << "\nSimilar expectations:\n#{method_signatures.join("\n")}" unless method_signatures.empty?
+      raise ExpectationError.new(message, backtrace)
     end
 
   end

data/lib/mocha/mock.rb

@@ -11,19 +11,6 @@ module Mocha # :nodoc:
   # Methods return an Expectation which can be further modified by methods on Expectation.
   class Mock
     
-    # :stopdoc:
-    
-    def initialize(stub_everything = false, name = nil)
-      @stub_everything = stub_everything
-      @mock_name = name
-      @expectations = ExpectationList.new
-      @responder = nil
-    end
-
-    attr_reader :stub_everything, :expectations
-  
-    # :startdoc:
-
     # :call-seq: expects(method_name) -> expectation
     #            expects(method_names) -> last expectation
     #
@@ -51,10 +38,12 @@ module Mocha # :nodoc:
     def expects(method_name_or_hash, backtrace = nil)
       if method_name_or_hash.is_a?(Hash) then
         method_name_or_hash.each do |method_name, return_value|
-          add_expectation(Expectation.new(self, method_name, backtrace).returns(return_value))
+          ensure_method_not_already_defined(method_name)
+          @expectations.add(Expectation.new(self, method_name, backtrace).returns(return_value))
         end
       else
-        add_expectation(Expectation.new(self, method_name_or_hash, backtrace))
+        ensure_method_not_already_defined(method_name_or_hash)
+        @expectations.add(Expectation.new(self, method_name_or_hash, backtrace))
       end
     end
     
@@ -82,10 +71,12 @@ module Mocha # :nodoc:
     def stubs(method_name_or_hash, backtrace = nil)
       if method_name_or_hash.is_a?(Hash) then
         method_name_or_hash.each do |method_name, return_value|
-          add_expectation(Stub.new(self, method_name, backtrace).returns(return_value))
+          ensure_method_not_already_defined(method_name)
+          @expectations.add(Stub.new(self, method_name, backtrace).returns(return_value))
         end
       else
-        add_expectation(Stub.new(self, method_name_or_hash, backtrace))
+        ensure_method_not_already_defined(method_name_or_hash)
+        @expectations.add(Stub.new(self, method_name_or_hash, backtrace))
       end
     end
     
@@ -135,6 +126,16 @@ module Mocha # :nodoc:
     end
     
     # :stopdoc:
+    
+    def initialize(name = nil, &block)
+      @mock_name = name
+      @expectations = ExpectationList.new
+      @everything_stubbed = false
+      @responder = nil
+      instance_eval(&block) if block
+    end
+
+    attr_reader :everything_stubbed, :expectations
 
     alias_method :__expects__, :expects
 
@@ -144,11 +145,12 @@ module Mocha # :nodoc:
 
     def add_expectation(expectation)
       @expectations.add(expectation)
-      method_name = expectation.method_name
-      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
-      expectation
     end
-
+    
+    def stub_everything
+      @everything_stubbed = true
+    end
+    
     def method_missing(symbol, *arguments, &block)
       if @responder and not @responder.respond_to?(symbol)
         raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
@@ -156,7 +158,7 @@ module Mocha # :nodoc:
       matching_expectation = @expectations.detect(symbol, *arguments)
       if matching_expectation then
         matching_expectation.invoke(&block)
-      elsif stub_everything then
+      elsif @everything_stubbed then
         return
       else
         unexpected_method_called(symbol, *arguments)
@@ -167,7 +169,7 @@ module Mocha # :nodoc:
       if @responder then
         @responder.respond_to?(symbol)
       else
-        @expectations.respond_to?(symbol)
+        @expectations.matches_method?(symbol)
       end
     end
   
@@ -188,9 +190,9 @@ module Mocha # :nodoc:
     def inspect
       mocha_inspect
     end
-
-    def similar_expectations(method_name)
-      @expectations.similar(method_name)
+    
+    def ensure_method_not_already_defined(method_name)
+      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
     end
 
     # :startdoc:

data/lib/mocha/parameter_matchers.rb

@@ -5,5 +5,21 @@ module Mocha
   
 end
 
+require 'mocha/parameter_matchers/object'
 
-Dir[File.expand_path(File.join(File.dirname(__FILE__), 'parameter_matchers', "*.rb"))].each { |lib| require lib }
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/any_of'
+require 'mocha/parameter_matchers/any_parameters'
+require 'mocha/parameter_matchers/anything'
+require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/has_entry'
+require 'mocha/parameter_matchers/has_entries'
+require 'mocha/parameter_matchers/has_key'
+require 'mocha/parameter_matchers/has_value'
+require 'mocha/parameter_matchers/includes'
+require 'mocha/parameter_matchers/instance_of'
+require 'mocha/parameter_matchers/is_a'
+require 'mocha/parameter_matchers/kind_of'
+require 'mocha/parameter_matchers/not'
+require 'mocha/parameter_matchers/optionally'
+require 'mocha/parameter_matchers/regexp_matches'

data/lib/mocha/parameter_matchers/all_of.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -18,14 +20,15 @@ module Mocha
       AllOf.new(*matchers)
     end
     
-    class AllOf # :nodoc:
+    class AllOf < Base # :nodoc:
       
       def initialize(*matchers)
         @matchers = matchers
       end
     
-      def ==(parameter)
-        @matchers.all? { |matcher| matcher == parameter }
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.all? { |matcher| matcher.matches?([parameter]) }
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/any_of.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -23,14 +25,15 @@ module Mocha
       AnyOf.new(*matchers)
     end
     
-    class AnyOf # :nodoc:
+    class AnyOf < Base # :nodoc:
       
       def initialize(*matchers)
         @matchers = matchers
       end
     
-      def ==(parameter)
-        @matchers.any? { |matcher| matcher == parameter }
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.any? { |matcher| matcher.matches?([parameter]) }
       end
       
       def mocha_inspect

data/lib/mocha/parameter_matchers/any_parameters.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_parameters() -> parameter_matcher
+    #
+    # Matches any parameters.
+    #   object = mock()
+    #   object.expects(:method_1).with(any_parameters)
+    #   object.method_1(1, 2, 3, 4)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_parameters)
+    #   object.method_1(5, 6, 7, 8, 9, 0)
+    #   # no error raised
+    def any_parameters
+      AnyParameters.new
+    end
+
+    class AnyParameters < Base # :nodoc:
+      
+      def matches?(available_parameters)
+        while available_parameters.length > 0 do
+          available_parameters.shift
+        end
+        return true
+      end
+
+      def mocha_inspect
+        "any_parameters"
+      end
+
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/anything.rb

@@ -1,3 +1,5 @@
+require 'mocha/parameter_matchers/base'
+
 module Mocha
   
   module ParameterMatchers
@@ -13,9 +15,10 @@ module Mocha
       Anything.new
     end
     
-    class Anything # :nodoc:
+    class Anything < Base # :nodoc:
     
-      def ==(parameter)
+      def matches?(available_parameters)
+        available_parameters.shift
         return true
       end
       

data/lib/mocha/parameter_matchers/base.rb

@@ -0,0 +1,15 @@
+module Mocha
+  
+  module ParameterMatchers
+    
+    class Base # :nodoc:
+      
+      def to_matcher
+        self
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/equals.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: equals(value) -> parameter_matcher
+    #
+    # Matches +Object+ equalling +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(equals(2))
+    #   object.method_1(3)
+    #   # error raised, because method_1 was not called with Object equalling 3
+    def equals(value)
+      Equals.new(value)
+    end
+
+    class Equals < Base # :nodoc:
+      
+      def initialize(value)
+        @value = value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter == @value
+      end
+      
+      def mocha_inspect
+        @value.mocha_inspect
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entries(entries) -> parameter_matcher
+    #
+    # Matches +Hash+ containing all +entries+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 2, 'key_3' => 3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
+    #   object.method_1('key_1' => 1, 'key_2' => 99)
+    #   # error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
+    def has_entries(entries)
+      HasEntries.new(entries)
+    end
+    
+    class HasEntries < Base # :nodoc:
+      
+      def initialize(entries)
+        @entries = entries
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @entries.all? { |key, value| parameter[key] == value }
+      end
+      
+      def mocha_inspect
+        "has_entries(#{@entries.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end