puppet 0.18.4 → 0.22.4

data/test/lib/mocha/expectation_error.rb

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

data/test/lib/mocha/infinite_range.rb

@@ -0,0 +1,27 @@
+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
+  
+  alias_method :__to_s__, :to_s
+
+  def to_s
+    if first.to_f.infinite? then
+      return "at most #{last}"
+    elsif last.to_f.infinite? then
+      return "at least #{first}"
+    else
+      __to_s__
+    end
+  end
+  
+end

data/test/lib/mocha/inspect.rb

@@ -0,0 +1,37 @@
+require 'date'
+
+class Object
+  def mocha_inspect
+    inspect =~ /#</ ? "#<#{self.class}:0x#{self.__id__.to_s(16)}>" : 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

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

data/test/lib/mocha/metaclass.rb

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

data/test/lib/mocha/mock.rb

@@ -0,0 +1,20 @@
+require 'mocha/mock_methods'
+
+module Mocha
+
+  class Mock
+    
+    include MockMethods
+
+    def initialize(stub_everything = false, name = nil)
+      @stub_everything = stub_everything
+      @mock_name = name
+    end
+
+    def mocha_inspect
+      @mock_name ? "#<Mock:#{@mock_name}>" : "#<Mock:0x#{__id__.to_s(16)}>"
+    end
+
+  end
+
+end

data/test/lib/mocha/mock_methods.rb

@@ -0,0 +1,122 @@
+require 'mocha/expectation'
+require 'mocha/metaclass'
+
+module Mocha
+  # Methods added to mock objects.
+  # These methods all return an expectation which can be further modified by methods on Mocha::Expectation.
+  module MockMethods
+    
+    # :stopdoc:
+    
+    attr_reader :stub_everything
+  
+    def expectations
+      @expectations ||= []
+    end
+
+    # :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 Mocha::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)
+    def expects(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Expectation.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
+      expectations.last
+    end
+
+    alias_method :__expects__, :expects
+
+    # :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 Mocha::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)
+    def stubs(method_names, backtrace = nil)
+      method_names = method_names.is_a?(Hash) ? method_names : { method_names => nil }
+      method_names.each do |method_name, return_value|
+        expectations << Stub.new(self, method_name, backtrace).returns(return_value)
+        self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+      end
+      expectations.last
+    end
+    
+    alias_method :__stubs__, :stubs
+
+    # :stopdoc:
+
+    def method_missing(symbol, *arguments, &block)
+      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)
+  	  expectations.any? { |expectation| expectation.method_name == symbol }
+	  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
+  
+    # :startdoc:
+
+  end
+end

data/test/lib/mocha/object.rb

@@ -0,0 +1,100 @@
+require 'mocha/mock'
+require 'mocha/instance_method'
+require 'mocha/class_method'
+require 'mocha/any_instance_method'
+
+# Methods added all Objects.
+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
+  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
+  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
+

data/test/lib/mocha/pretty_parameters.rb

@@ -0,0 +1,28 @@
+require 'mocha/inspect'
+
+module Mocha
+
+  class PrettyParameters
+  
+    def initialize(params)
+      @params = params
+      @params_string = params.mocha_inspect
+    end
+  
+    def pretty
+      remove_outer_array_braces!
+      remove_outer_hash_braces!
+      @params_string
+    end
+  
+    def remove_outer_array_braces!
+      @params_string = @params_string.gsub(/^\[|\]$/, '')
+    end
+  
+    def remove_outer_hash_braces!
+      @params_string = @params_string.gsub(/^\{|\}$/, '') if @params.size == 1
+    end
+  
+  end
+  
+end

data/test/lib/mocha/setup_and_teardown.rb

@@ -0,0 +1,23 @@
+require 'mocha/central'
+
+module Mocha
+  
+  module SetupAndTeardown
+  
+    def setup_stubs
+      $stubba = Mocha::Central.new
+    end
+    
+    def verify_stubs
+      $stubba.verify_all { yield if block_given? } if $stubba
+    end
+  
+    def teardown_stubs
+      if $stubba then
+        $stubba.unstub_all
+        $stubba = nil
+      end
+    end
+
+  end
+end

data/test/lib/mocha/standalone.rb

@@ -0,0 +1,30 @@
+require 'mocha/auto_verify'
+require 'mocha/setup_and_teardown'
+
+module Mocha
+  
+  module Standalone
+    
+    include AutoVerify
+    include SetupAndTeardown
+    
+    def mocha_setup
+      setup_stubs
+    end
+    
+    def mocha_verify(&block)
+      verify_mocks(&block)
+      verify_stubs(&block)
+    end
+    
+    def mocha_teardown
+      begin
+        teardown_mocks
+      ensure
+        teardown_stubs
+      end
+    end
+    
+  end
+  
+end

data/test/lib/mocha/test_case_adapter.rb

@@ -0,0 +1,49 @@
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module TestCaseAdapter
+
+    def self.included(base)
+      base.class_eval do
+
+        alias_method :run_before_mocha_test_case_adapter, :run
+
+        def run(result)
+          yield(Test::Unit::TestCase::STARTED, name)
+          @_result = result
+          begin
+            mocha_setup
+            begin
+              setup
+              __send__(@method_name)
+              mocha_verify { add_assertion }
+            rescue Mocha::ExpectationError => e
+              add_failure(e.message, e.backtrace)
+            rescue Test::Unit::AssertionFailedError => e
+              add_failure(e.message, e.backtrace)
+            rescue StandardError, ScriptError => e
+              add_error(e)
+            ensure
+              begin
+                teardown
+              rescue Test::Unit::AssertionFailedError => e
+                add_failure(e.message, e.backtrace)
+              rescue StandardError, ScriptError
+                add_error($!)
+              end
+            end
+          ensure
+            mocha_teardown
+          end
+          result.add_run
+          yield(Test::Unit::TestCase::FINISHED, name)
+        end
+                
+      end
+      
+    end
+    
+  end
+  
+end