floehopper-mocha 0.9.3.20081220175348

data/lib/mocha/object.rb

@@ -0,0 +1,187 @@
+require 'mocha/mockery'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/module_method'
+require 'mocha/any_instance_method'
+require 'mocha/argument_iterator'
+
+module Mocha
+  
+  # Methods added all objects to allow mocking and stubbing on real objects.
+  #
+  # Methods return a Mocha::Expectation which can be further modified by methods on Mocha::Expectation.
+  module ObjectMethods
+  
+    def mocha # :nodoc:
+      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+    end
+  
+    def reset_mocha # :nodoc:
+      @mocha = nil
+    end
+  
+    def stubba_method # :nodoc:
+      Mocha::InstanceMethod
+    end
+  
+    def stubba_object # :nodoc:
+      self
+    end
+  
+    # :call-seq: expects(method_name) -> expectation
+    #            expects(method_names_vs_return_values) -> last expectation
+    #
+    # 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.
+    #   product = Product.new
+    #   product.expects(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # 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.
+    #
+    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   product = Product.new
+    #   product.expects(:valid? => true, :save => true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.expects(:valid?).returns(true)
+    #   product.expects(:save).returns(true)
+    def expects(method_name_or_hash)
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.expects(method_name, caller)
+        expectation.returns(args.shift) if args.length > 0
+      }
+      expectation
+    end
+  
+    # :call-seq: stubs(method_name) -> expectation
+    #            stubs(method_names_vs_return_values) -> 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.
+    #   product = Product.new
+    #   product.stubs(:save).returns(true)
+    #   assert_equal true, product.save
+    #
+    # 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.
+    #
+    # If +method_names_vs_return_values+ is a +Hash+, an expectation will be set up for each entry using the key as +method_name+ and value as +return_value+.
+    #   product = Product.new
+    #   product.stubs(:valid? => true, :save => true)
+    #
+    #   # exactly equivalent to
+    #
+    #   product = Product.new
+    #   product.stubs(:valid?).returns(true)
+    #   product.stubs(:save).returns(true)
+    def stubs(method_name_or_hash)
+      expectation = nil
+      mockery = Mocha::Mockery.instance
+      iterator = ArgumentIterator.new(method_name_or_hash)
+      iterator.each { |*args|
+        method_name = args.shift
+        mockery.on_stubbing(self, method_name)
+        method = stubba_method.new(stubba_object, method_name)
+        mockery.stubba.stub(method)
+        expectation = mocha.stubs(method_name, caller)
+        expectation.returns(args.shift) if args.length > 0
+      }
+      expectation
+    end
+  
+    def method_exists?(method, include_public_methods = true) # :nodoc:
+      if include_public_methods
+        return true if public_methods(include_superclass_methods = true).include?(method)
+        return true if respond_to?(method.to_sym)
+      end
+      return true if protected_methods(include_superclass_methods = true).include?(method)
+      return true if private_methods(include_superclass_methods = true).include?(method)
+      return false
+    end
+  
+  end
+  
+  module ModuleMethods # :nodoc:
+    
+    def stubba_method
+      Mocha::ModuleMethod
+    end
+    
+  end
+  
+  # Methods added all classes to allow mocking and stubbing on real objects.
+  module ClassMethods
+    
+    def stubba_method # :nodoc:
+      Mocha::ClassMethod
+    end
+
+    class AnyInstance # :nodoc:
+    
+      def initialize(klass)
+        @stubba_object = klass
+      end
+    
+      def mocha
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      end
+
+      def stubba_method
+        Mocha::AnyInstanceMethod
+      end
+    
+      def stubba_object
+        @stubba_object
+      end
+    
+      def method_exists?(method, include_public_methods = true)
+        if include_public_methods
+          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
+        end
+        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
+        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
+        return false
+      end
+    
+    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
+  
+  end
+  
+end
+
+class Object # :nodoc:
+  include Mocha::ObjectMethods
+end
+
+class Module # :nodoc:
+  include Mocha::ModuleMethods
+end
+
+class Class # :nodoc:
+  include Mocha::ClassMethods
+end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: all_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if all +parameter_matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 3])
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(all_of(includes(1), includes(3)))
+    #   object.method_1([1, 2])
+    #   # error raised, because method_1 was not called with object including 1 and 3
+    def all_of(*matchers)
+      AllOf.new(*matchers)
+    end
+    
+    class AllOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.all? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/any_of.rb

@@ -0,0 +1,47 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: any_of(*parameter_matchers) -> parameter_matcher
+    #
+    # Matches if any +parameter_matchers+ match.
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(1)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(3)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(any_of(1, 3))
+    #   object.method_1(2)
+    #   # error raised, because method_1 was not called with 1 or 3
+    def any_of(*matchers)
+      AnyOf.new(*matchers)
+    end
+    
+    class AnyOf < Base # :nodoc:
+      
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        @matchers.any? { |matcher| matcher.to_matcher.matches?([parameter]) }
+      end
+      
+      def mocha_inspect
+        "any_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,33 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: anything() -> parameter_matcher
+    #
+    # Matches any object.
+    #   object = mock()
+    #   object.expects(:method_1).with(anything)
+    #   object.method_1('foo')
+    #   # no error raised
+    def anything
+      Anything.new
+    end
+    
+    class Anything < Base # :nodoc:
+    
+      def matches?(available_parameters)
+        available_parameters.shift
+        return true
+      end
+      
+      def mocha_inspect
+        "anything"
+      end
+      
+    end
+    
+  end
+  
+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,45 @@
+require 'mocha/parameter_matchers/base'
+require 'mocha/parameter_matchers/all_of'
+require 'mocha/parameter_matchers/has_entry'
+
+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
+        has_entry_matchers = @entries.map { |key, value| HasEntry.new(key, value) }
+        AllOf.new(*has_entry_matchers).matches?([parameter])
+      end
+      
+      def mocha_inspect
+        "has_entries(#{@entries.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -0,0 +1,56 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: has_entry(key, value) -> parameter_matcher
+    #            has_entry(key => value) -> parameter_matcher
+    #
+    # Matches +Hash+ containing entry with +key+ and +value+.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1', 1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1' => 1))
+    #   object.method_1('key_1' => 1, 'key_2' => 2)
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1', 1))
+    #   object.method_1('key_1' => 2, 'key_2' => 1)
+    #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(has_entry('key_1' => 1))
+    #   object.method_1('key_1' => 2, 'key_2' => 1)
+    #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
+    def has_entry(*options)
+      key, value = options.shift, options.shift
+      key, value = key.to_a[0][0..1] if key.is_a?(Hash)
+      HasEntry.new(key, value)
+    end
+    
+    class HasEntry < Base # :nodoc:
+      
+      def initialize(key, value)
+        @key, @value = key, value
+      end
+      
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        matching_keys = parameter.keys.select { |key| @key.to_matcher.matches?([key]) }
+        matching_keys.any? { |key| @value.to_matcher.matches?([parameter[key]]) }
+      end
+      
+      def mocha_inspect
+        "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/mocha/parameter_matchers/has_key.rb

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

data/lib/mocha/parameter_matchers/has_value.rb

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

data/lib/mocha/parameter_matchers/includes.rb

@@ -0,0 +1,40 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: includes(item) -> parameter_matcher
+    #
+    # Matches any object that responds true to include?(item)
+    #   object = mock()
+    #   object.expects(:method_1).with(includes('foo'))
+    #   object.method_1(['foo', 'bar'])
+    #   # no error raised
+    #
+    #   object.method_1(['baz'])
+    #   # error raised, because ['baz'] does not include 'foo'.
+    def includes(item)
+      Includes.new(item)
+    end
+
+    class Includes < Base # :nodoc:
+
+      def initialize(item)
+        @item = item
+      end
+
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return parameter.include?(@item)
+      end
+
+      def mocha_inspect
+        "includes(#{@item.mocha_inspect})"
+      end
+
+    end
+
+  end
+  
+end

data/lib/mocha/parameter_matchers/instance_of.rb

@@ -0,0 +1,42 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  
+  module ParameterMatchers
+
+    # :call-seq: instance_of(klass) -> parameter_matcher
+    #
+    # Matches any object that is an instance of +klass+
+    #   object = mock()
+    #   object.expects(:method_1).with(instance_of(String))
+    #   object.method_1('string')
+    #   # no error raised
+    #
+    #   object = mock()
+    #   object.expects(:method_1).with(instance_of(String))
+    #   object.method_1(99)
+    #   # error raised, because method_1 was not called with an instance of String
+    def instance_of(klass)
+      InstanceOf.new(klass)
+    end
+    
+    class InstanceOf < Base # :nodoc:
+      
+      def initialize(klass)
+        @klass = klass
+      end
+    
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        parameter.instance_of?(@klass)
+      end
+      
+      def mocha_inspect
+        "instance_of(#{@klass.mocha_inspect})"
+      end
+      
+    end
+    
+  end
+  
+end