puppet 0.18.4 → 0.22.4

data/test/lib/puppettest/testcase.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2007-03-05.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'puppettest'
+
+class PuppetTest::TestCase < Test::Unit::TestCase
+	include PuppetTest
+    def self.confine(hash)
+        @confines ||= {}
+        hash.each do |message, result|
+            @confines[message] = result
+        end
+    end
+
+    def self.runnable?
+        @messages ||= []
+        return false unless @messages.empty?
+        return true unless defined? @confines
+        @confines.find_all do |message, result|
+            ! result
+        end.each do |message, result|
+            @messages << message
+        end
+
+        return @messages.empty?
+    end
+
+    def self.suite
+        # Always skip this parent class.  It'd be nice if there were a
+        # "supported" way to do this.
+        if self == PuppetTest::TestCase
+            suite = Test::Unit::TestSuite.new(name)
+            return suite
+        elsif self.runnable?
+            return super
+        else
+            if defined? $console
+                puts "Skipping %s: %s" % [name, @messages.join(", ")]
+            end
+            suite = Test::Unit::TestSuite.new(name)
+            return suite
+        end
+    end
+end
+
+# $Id: testcase.rb 2267 2007-03-08 06:03:36Z luke $

data/test/lib/rake/puppet_test_loader.rb

@@ -0,0 +1,17 @@
+
+require 'test/unit/autorunner'
+require 'getoptlong'
+require 'puppettest'
+
+args = PuppetTest.munge_argv
+
+args.each { |f| require f unless f =~ /^-/  }
+
+runner = Test::Unit::AutoRunner.new(false)
+runner.process_args
+
+unless runner.run
+    exit 14
+end
+
+# $Id: puppet_test_loader.rb 2377 2007-03-31 06:35:23Z luke $

data/test/lib/rake/puppet_testtask.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+module Rake
+    class PuppetTestTask < Rake::TestTask
+        def rake_loader
+            if Integer(RUBY_VERSION.split(/\./)[2]) < 4
+                file = super
+            else
+                file = find_file('rake/puppet_test_loader') or
+                    fail "unable to find rake test loader"
+            end
+            return file
+        end
+    end
+end
+
+# $Id: puppet_testtask.rb 2057 2007-01-05 21:55:18Z luke $

data/test/lib/spec.rb

@@ -0,0 +1,8 @@
+require 'spec/deprecated'
+require 'spec/version'
+require 'spec/callback'
+require 'spec/matchers'
+require 'spec/expectations'
+require 'spec/mocks'
+require 'spec/runner'
+require 'spec/translator'

data/test/lib/spec/callback.rb

@@ -0,0 +1,11 @@
+require 'spec/callback/callback_container'
+require 'spec/callback/extensions/module'
+require 'spec/callback/extensions/object'
+
+# Callback is a fork of Brian Takita's "callback library" (see http://callback.rubyforge.org),
+# which Brian graciously contributed to RSpec in order to avoid the dependency.
+#
+# RSpec uses Callback internally to create hooks to Spec::Runner events. If you're interested
+# in a simple, powerful API for generating callback events, check out http://callback.rubyforge.org.
+module Callback
+end

data/test/lib/spec/callback/callback_container.rb

@@ -0,0 +1,60 @@
+module Callback
+  class CallbackContainer
+    def initialize
+      @callback_registry = Hash.new do |hash, key|
+        hash[key] = Array.new
+      end
+    end
+
+    # Defines the callback with the key in this container.
+    def define(key, callback_proc=nil, &callback_block)
+      callback = extract_callback(callback_block, callback_proc) do
+        raise "You must define the callback that accepts the call method."
+      end
+      @callback_registry[key] << callback
+      callback
+    end
+
+    # Undefines the callback with the key in this container.
+    def undefine(key, callback_proc)
+      callback = extract_callback(callback_proc) do
+        raise "You may only undefine callbacks that use the call method."
+      end
+      @callback_registry[key].delete callback
+      callback
+    end
+
+    # Notifies the callbacks for the key. Arguments may be passed.
+    # An error handler may be passed in as a block. If there is an error, the block is called with
+    # error object as an argument.
+    # An array of the return values of the callbacks is returned.
+    def notify(key, *args, &error_handler)
+      @callback_registry[key].collect do |callback|
+        begin
+          callback.call(*args)
+        rescue Exception => e
+          yield(e) if error_handler
+        end
+      end
+    end
+
+    # Clears all of the callbacks in this container.
+    def clear
+      @callback_registry.clear
+    end
+
+    protected
+    def extract_callback(first_choice_callback, second_choice_callback = nil)
+      callback = nil
+      if first_choice_callback
+        callback = first_choice_callback
+      elsif second_choice_callback
+        callback = second_choice_callback
+      end
+      unless callback.respond_to? :call
+        yield
+      end
+      return callback
+    end
+  end
+end

data/test/lib/spec/callback/extensions/module.rb

@@ -0,0 +1,24 @@
+module Callback
+  module ModuleMethods
+    # For each event_name submitted, defines a callback event with this name.
+    # Client code can then register as a callback listener using object.event_name.
+    def callback_events(*event_names)
+      event_names.each do |event_name|
+        define_callback_event(event_name)
+      end
+    end
+
+    private
+    def define_callback_event(event_name)
+      module_eval <<-EOS
+        def #{event_name}(&block)
+          register_callback(:#{event_name}, &block)
+        end
+      EOS
+    end
+  end
+end
+
+class Module
+  include Callback::ModuleMethods
+end

data/test/lib/spec/callback/extensions/object.rb

@@ -0,0 +1,37 @@
+module Callback
+  module InstanceMethods
+    # Registers a callback for the event on the object. The callback can either be a block or a proc.
+    # When the callbacks are notified, the return value of the proc is passed to the caller.
+    def register_callback(event, callback_proc=nil, &callback_block)
+      callbacks.define(event, callback_proc, &callback_block)
+    end
+
+    # Removes the callback from the event. The callback proc must be the same
+    # object as the one that was passed to register_callback.
+    def unregister_callback(event, callback_proc)
+      callbacks.undefine(event, callback_proc)
+    end
+
+    protected
+    # Notifies the callbacks registered with the event on the object. Arguments can be passed to the callbacks.
+    # An error handler may be passed in as a block. If there is an error, the block is called with
+    # error object as an argument.
+    # An array of the return values of the callbacks is returned.
+    def notify_callbacks(event, *args, &error_handler)
+      callbacks.notify(event, *args, &error_handler)
+    end
+
+    def notify_class_callbacks(event, *args, &error_handler)
+      self.class.send(:notify_callbacks, event, *args, &error_handler)      
+    end
+
+    # The CallbackContainer for this object.
+    def callbacks
+      @callbacks ||= CallbackContainer.new
+    end
+  end
+end
+
+class Object
+  include Callback::InstanceMethods
+end

data/test/lib/spec/deprecated.rb

@@ -0,0 +1,3 @@
+def deprecated(&block)
+  block.call unless ENV['RSPEC_DISABLE_DEPRECATED_FEATURES'] == 'true'
+end

data/test/lib/spec/expectations.rb

@@ -0,0 +1,59 @@
+require 'spec/deprecated'
+require 'spec/matchers'
+require 'spec/expectations/sugar'
+require 'spec/expectations/errors'
+require 'spec/expectations/extensions'
+require 'spec/expectations/should'
+require 'spec/expectations/handler'
+
+module Spec
+  
+  # Spec::Expectations lets you set expectations on your objects.
+  #
+  #   result.should == 37
+  #   team.should have(11).players_on_the_field
+  #
+  # == How Expectations work.
+  #
+  # Spec::Expectations adds two methods to Object:
+  #
+  #   should(matcher=nil)
+  #   should_not(matcher=nil)
+  #
+  # Both methods take an optional Expression Matcher (See Spec::Matchers).
+  #
+  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +true+, the spec passes and execution continues. If it returns
+  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
+  #
+  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
+  # it returns +false+, the spec passes and execution continues. If it returns
+  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
+  #
+  # RSpec ships with a standard set of useful matchers, and writing your own
+  # matchers is quite simple. See Spec::Matchers for details.
+  module Expectations
+    class << self
+      attr_accessor :differ
+
+      # raises a Spec::Expectations::ExpectationNotMetError with message
+      #
+      # When a differ has been assigned and fail_with is passed
+      # <code>expected</code> and <code>target</code>, passes them
+      # to the differ to append a diff message to the failure message.
+      def fail_with(message, expected=nil, target=nil) # :nodoc:
+        if Array === message && message.length == 3
+          message, expected, target = message[0], message[1], message[2]
+        end
+        unless (differ.nil? || expected.nil? || target.nil?)
+          if expected.is_a?(String)
+            message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
+          elsif !target.is_a?(Proc)
+            message << "\nDiff:" << self.differ.diff_as_object(target, expected)
+          end
+        end
+        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+      end
+    end
+  end
+end

data/test/lib/spec/expectations/differs/default.rb

@@ -0,0 +1,62 @@
+begin
+  require 'rubygems'
+  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
+  require 'diff/lcs/hunk'
+rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
+
+require 'pp'
+
+module Spec
+  module Expectations
+    module Differs
+
+      # TODO add colour support
+      # TODO add some rdoc
+      class Default
+        def initialize(format=:unified,context_lines=nil,colour=nil)
+
+          context_lines ||= 3
+          colour        ||= false
+
+          @format,@context_lines,@colour = format,context_lines,colour
+        end
+
+        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+        def diff_as_string(data_old, data_new)
+          data_old = data_old.split(/\n/).map! { |e| e.chomp }
+          data_new = data_new.split(/\n/).map! { |e| e.chomp }
+          output = ""
+          diffs = Diff::LCS.diff(data_old, data_new)
+          return output if diffs.empty?
+          oldhunk = hunk = nil  
+          file_length_difference = 0
+          diffs.each do |piece|
+            begin
+              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @context_lines,
+                                         file_length_difference)
+              file_length_difference = hunk.file_length_difference      
+              next unless oldhunk      
+              # Hunks may overlap, which is why we need to be careful when our
+              # diff includes lines of context. Otherwise, we might print
+              # redundant lines.
+              if (@context_lines > 0) and hunk.overlaps?(oldhunk)
+                hunk.unshift(oldhunk)
+              else
+                output << oldhunk.diff(@format)
+              end
+            ensure
+              oldhunk = hunk
+              output << "\n"
+            end
+          end  
+          #Handle the last remaining hunk
+          output << oldhunk.diff(@format) << "\n"
+        end  
+
+        def diff_as_object(target,expected)
+          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+        end
+      end
+    end
+  end
+end

data/test/lib/spec/expectations/errors.rb

@@ -0,0 +1,6 @@
+module Spec
+  module Expectations
+    class ExpectationNotMetError < StandardError
+    end
+  end
+end

data/test/lib/spec/expectations/extensions.rb

@@ -0,0 +1,3 @@
+require 'spec/expectations/extensions/object'
+require 'spec/expectations/extensions/proc'
+require 'spec/expectations/extensions/string_and_symbol'

data/test/lib/spec/expectations/extensions/object.rb

@@ -0,0 +1,109 @@
+module Spec
+  module Expectations
+    # rspec adds #should and #should_not to every Object (and,
+    # implicitly, every Class).
+    module ObjectExpectations
+
+      # :call-seq:
+      #   should(matcher)
+      #   should == expected
+      #   should =~ expected
+      #
+      #   receiver.should(matcher)
+      #     => Passes if matcher.matches?(receiver)
+      #
+      #   receiver.should == expected #any value
+      #     => Passes if (receiver == expected)
+      #
+      #   receiver.should =~ regexp
+      #     => Passes if (receiver =~ regexp)
+      #
+      # See Spec::Matchers for more information about matchers
+      #
+      # == Warning
+      #
+      # NOTE that this does NOT support receiver.should != expected.
+      # Instead, use receiver.should_not == expected
+      def should(matcher=nil, &block)
+        return ExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        Should::Should.new(self)
+      end
+
+      # :call-seq:
+      #   should_not(matcher)
+      #   should_not == expected
+      #   should_not =~ expected
+      #
+      #   receiver.should_not(matcher)
+      #     => Passes unless matcher.matches?(receiver)
+      #
+      #   receiver.should_not == expected
+      #     => Passes unless (receiver == expected)
+      #
+      #   receiver.should_not =~ regexp
+      #     => Passes unless (receiver =~ regexp)
+      #
+      # See Spec::Matchers for more information about matchers
+      def should_not(matcher=nil, &block)
+        return NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block) if matcher
+        should.not
+      end
+
+      deprecated do
+        # Deprecated: use should have(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have(expected)
+          should.have(expected)
+        end
+        alias_method :should_have_exactly, :should_have
+
+        # Deprecated: use should have_at_least(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_least(expected)
+          should.have.at_least(expected)
+        end
+      
+        # Deprecated: use should have_at_most(n).items (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_have_at_most(expected)
+          should.have.at_most(expected)
+        end
+
+        # Deprecated: use should include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_include(expected)
+          should.include(expected)
+        end
+
+        # Deprecated: use should_not include(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_include(expected)
+          should.not.include(expected)
+        end
+
+        # Deprecated: use should be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_be(expected = :___no_arg)
+          should.be(expected)
+        end
+      
+        # Deprecated: use should_not be(expected) (see Spec::Matchers)
+        # This will be removed in 0.9
+        def should_not_be(expected = :___no_arg)
+          should_not.be(expected)
+        end
+      end
+    end
+  end
+end
+
+class Object
+  include Spec::Expectations::ObjectExpectations
+  deprecated do
+    include Spec::Expectations::UnderscoreSugar
+  end
+end
+
+deprecated do
+  Object.handle_underscores_for_rspec!
+end