puppet 0.24.1 → 0.24.2

data/test/lib/mocha/expectation_error.rb

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

data/test/lib/mocha/infinite_range.rb

@@ -1,25 +0,0 @@
-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/test/lib/mocha/inspect.rb

@@ -1,39 +0,0 @@
-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/test/lib/mocha/instance_method.rb

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

data/test/lib/mocha/is_a.rb

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

data/test/lib/mocha/metaclass.rb

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

data/test/lib/mocha/missing_expectation.rb

@@ -1,27 +0,0 @@
-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 = similar_expectations.collect { |expectation| expectation.method_signature }.join("\n")
-      msg << "\nSimilar expectations:\n#{similar_expectations_list}" unless similar_expectations.empty?
-      error = ExpectationError.new(msg)
-      error.set_backtrace(filtered_backtrace)
-      raise error if @invoked_count
-    end
-
-    def similar_expectations
-      @mock.expectations.select { |expectation| expectation.method_name == self.method_name }
-    end
-
-  end
-
-end

data/test/lib/mocha/mock.rb

@@ -1,207 +0,0 @@
-require 'mocha/expectation'
-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 = []
-      @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 << 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 = matching_expectation(symbol, *arguments)
-      if matching_expectation then
-        matching_expectation.invoke(&block)
-      elsif stub_everything then
-        return
-      else
-        begin
-          super_method_missing(symbol, *arguments, &block)
-    		rescue NoMethodError
-    			unexpected_method_called(symbol, *arguments)
-    		end
-  		end
-  	end
-  	
-  	def respond_to?(symbol)
-	    if @responder then
-	      @responder.respond_to?(symbol)
-      else
-    	  @expectations.any? { |expectation| expectation.method_name == symbol }
-  	  end
-	  end
-	
-  	def super_method_missing(symbol, *arguments, &block)
-  	  raise NoMethodError
-    end
-
-  	def unexpected_method_called(symbol, *arguments)
-      MissingExpectation.new(self, symbol).with(*arguments).verify
-    end
-	
-  	def matching_expectation(symbol, *arguments)
-      @expectations.reverse.detect { |expectation| expectation.match?(symbol, *arguments) }
-    end
-  
-    def verify(&block)
-      @expectations.each { |expectation| expectation.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
-
-    # :startdoc:
-
-  end
-
-end

data/test/lib/mocha/multiple_yields.rb

@@ -1,20 +0,0 @@
-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/test/lib/mocha/no_yields.rb

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

data/test/lib/mocha/object.rb

@@ -1,110 +0,0 @@
-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
-