redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/lib/mocha/expectation_error.rb

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

data/lib/openssl/mocha/lib/mocha/expectation_list.rb

@@ -0,0 +1,45 @@
+module Mocha # :nodoc:
+
+  class ExpectationList
+
+    def initialize
+      @expectations = []
+    end
+
+    def add(expectation)
+      @expectations << expectation
+    end
+
+    def respond_to?(method_name)
+      @expectations.any? { |expectation| expectation.method_name == 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
+    end
+
+    def similar(method_name)
+      @expectations.select { |expectation| expectation.method_name == method_name }
+    end
+
+    def verify(&block)
+      @expectations.each { |expectation| expectation.verify(&block) }
+    end
+
+    def to_a
+      @expectations
+    end
+
+    def to_set
+      @expectations.to_set
+    end
+
+    def size
+      @expectations.size
+    end
+
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/infinite_range.rb

@@ -0,0 +1,25 @@
+class Range
+  
+  def self.at_least(minimum_value)
+    Range.new(minimum_value, infinite)
+  end
+  
+  def self.at_most(maximum_value)
+    Range.new(-infinite, maximum_value, false)
+  end
+  
+  def self.infinite
+    1/0.0
+  end
+  
+  def mocha_inspect
+    if first.respond_to?(:to_f) and first.to_f.infinite? then
+      return "at most #{last}"
+    elsif last.respond_to?(:to_f) and last.to_f.infinite? then
+      return "at least #{first}"
+    else
+      to_s
+    end
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/inspect.rb

@@ -0,0 +1,39 @@
+require 'date'
+
+class Object
+  def mocha_inspect
+    address = self.__id__ * 2
+    address += 0x100000000 if address < 0
+    inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+  end
+end
+
+class String
+  def mocha_inspect
+    inspect.gsub(/\"/, "'")
+  end
+end
+
+class Array
+  def mocha_inspect
+    "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+  end
+end
+
+class Hash
+  def mocha_inspect
+    "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+  end
+end
+
+class Time
+  def mocha_inspect
+    "#{inspect} (#{to_f} secs)"
+  end
+end
+
+class Date
+  def mocha_inspect
+    to_s
+  end
+end

data/lib/openssl/mocha/lib/mocha/instance_method.rb

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

data/lib/openssl/mocha/lib/mocha/is_a.rb

@@ -0,0 +1,9 @@
+class Object
+
+  # :stopdoc:
+
+  alias_method :__is_a__, :is_a?
+
+  # :startdoc:
+  
+end

data/lib/openssl/mocha/lib/mocha/metaclass.rb

@@ -0,0 +1,7 @@
+class Object
+  
+  def __metaclass__
+    class << self; self; end
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/missing_expectation.rb

@@ -0,0 +1,27 @@
+require 'mocha/expectation'
+
+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)
+    end
+
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/mock.rb

@@ -0,0 +1,200 @@
+require 'mocha/expectation'
+require 'mocha/expectation_list'
+require 'mocha/stub'
+require 'mocha/missing_expectation'
+require 'mocha/metaclass'
+
+module Mocha # :nodoc:
+  
+  # Traditional mock object.
+  #
+  # 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
+    #
+    # 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 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)
+    #
+    # Aliased by <tt>\_\_expects\_\_</tt>
+    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))
+        end
+      else
+        add_expectation(Expectation.new(self, method_name_or_hash, backtrace))
+      end
+    end
+    
+    # :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 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
+    #
+    #   object = mock()
+    #   object.stubs(:method1).returns(:result1)
+    #   object.stubs(:method2).returns(:result2)
+    #
+    # Aliased by <tt>\_\_stubs\_\_</tt>
+    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))
+        end
+      else
+        add_expectation(Stub.new(self, method_name_or_hash, backtrace))
+      end
+    end
+    
+    # :call-seq: responds_like(responder) -> mock
+    #
+    # Constrains the +mock+ so that it can only expect or stub methods to which +responder+ responds. The constraint is only applied at method invocation time.
+    #
+    # A +NoMethodError+ will be raised if the +responder+ does not <tt>respond_to?</tt> a method invocation (even if the method has been expected or stubbed).
+    #
+    # The +mock+ will delegate its <tt>respond_to?</tt> method to the +responder+.
+    #   class Sheep
+    #     def chew(grass); end
+    #     def self.number_of_legs; end
+    #   end
+    #
+    #   sheep = mock('sheep')
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => true
+    #   sheep.chew
+    #   sheep.foo
+    #   # no error raised
+    #
+    #   sheep = mock('sheep')
+    #   sheep.responds_like(Sheep.new)
+    #   sheep.expects(:chew)
+    #   sheep.expects(:foo)
+    #   sheep.respond_to?(:chew) # => true
+    #   sheep.respond_to?(:foo) # => false
+    #   sheep.chew
+    #   sheep.foo # => raises NoMethodError exception
+    #
+    #   sheep_class = mock('sheep_class')
+    #   sheep_class.responds_like(Sheep)
+    #   sheep_class.stubs(:number_of_legs).returns(4)
+    #   sheep_class.expects(:foo)
+    #   sheep_class.respond_to?(:number_of_legs) # => true
+    #   sheep_class.respond_to?(:foo) # => false
+    #   assert_equal 4, sheep_class.number_of_legs
+    #   sheep_class.foo # => raises NoMethodError exception
+    #
+    # Aliased by +quacks_like+
+    def responds_like(object)
+      @responder = object
+      self
+    end
+    
+    # :stopdoc:
+
+    alias_method :__expects__, :expects
+
+    alias_method :__stubs__, :stubs
+    
+    alias_method :quacks_like, :responds_like
+
+    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 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}"
+      end
+      matching_expectation = @expectations.detect(symbol, *arguments)
+      if matching_expectation then
+        matching_expectation.invoke(&block)
+      elsif stub_everything then
+        return
+      else
+        unexpected_method_called(symbol, *arguments)
+      end
+    end
+    
+    def respond_to?(symbol)
+      if @responder then
+        @responder.respond_to?(symbol)
+      else
+        @expectations.respond_to?(symbol)
+      end
+    end
+  
+    def unexpected_method_called(symbol, *arguments)
+      MissingExpectation.new(self, symbol).with(*arguments).verify
+    end
+  
+    def verify(&block)
+      @expectations.verify(&block)
+    end
+  
+    def mocha_inspect
+      address = self.__id__ * 2
+      address += 0x100000000 if address < 0
+      @mock_name ? "#<Mock:#{@mock_name}>" : "#<Mock:0x#{'%x' % address}>"
+    end
+    
+    def inspect
+      mocha_inspect
+    end
+
+    def similar_expectations(method_name)
+      @expectations.similar(method_name)
+    end
+
+    # :startdoc:
+
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/multiple_yields.rb

@@ -0,0 +1,20 @@
+module Mocha # :nodoc:
+  
+  class MultipleYields # :nodoc:
+    
+    attr_reader :parameter_groups
+    
+    def initialize(*parameter_groups)
+      @parameter_groups = parameter_groups
+    end
+    
+    def each
+      @parameter_groups.each do |parameter_group|
+        yield(parameter_group)
+      end
+    end
+    
+  end
+  
+end
+    

data/lib/openssl/mocha/lib/mocha/no_yields.rb

@@ -0,0 +1,11 @@
+module Mocha # :nodoc:
+  
+  class NoYields # :nodoc:
+    
+    def each
+    end
+    
+  end
+  
+end
+    

data/lib/openssl/mocha/lib/mocha/object.rb

@@ -0,0 +1,110 @@
+require 'mocha/mock'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/any_instance_method'
+
+# 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.
+class Object
+  
+  def mocha # :nodoc:
+    @mocha ||= Mocha::Mock.new
+  end
+  
+  def reset_mocha # :nodoc:
+    @mocha = nil
+  end
+  
+  def stubba_method # :nodoc:
+    Mocha::InstanceMethod
+  end
+  
+  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
+  #
+  # 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) 
+    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
+  #
+  # 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) 
+    method = stubba_method.new(stubba_object, symbol)
+    $stubba.stub(method)
+    mocha.stubs(symbol, caller)
+  end
+  
+  def verify # :nodoc:
+    mocha.verify
+  end
+  
+end
+
+class Module # :nodoc:
+  
+  def stubba_method
+    Mocha::ClassMethod
+  end
+    
+end
+  
+class Class
+  
+  def stubba_method # :nodoc:
+    Mocha::ClassMethod
+  end
+
+  class AnyInstance # :nodoc:
+    
+    def initialize(klass)
+      @stubba_object = klass
+    end
+    
+    def stubba_method
+      Mocha::AnyInstanceMethod
+    end
+    
+    def stubba_object
+      @stubba_object
+    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
+