puppet 0.23.2 → 0.24.0

data/test/language/node.rb

@@ -1,126 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppet'
-require 'puppet/parser/parser'
-require 'puppettest'
-
-class TestParser < Test::Unit::TestCase
-    include PuppetTest::ParserTesting
-
-    def setup
-        super
-        Puppet[:parseonly] = true
-    end
-
-    def test_simple_hostname
-        check_parseable "host1"
-        check_parseable "'host2'"
-        check_parseable "\"host3\""
-        check_parseable [ "'host1'",  "host2" ]
-        check_parseable [ "'host1'",  "'host2'" ]
-        check_parseable [ "'host1'",  "\"host2\"" ]
-        check_parseable [ "\"host1\"",  "host2" ]
-        check_parseable [ "\"host1\"",  "'host2'" ]
-        check_parseable [ "\"host1\"",  "\"host2\"" ]
-    end
-
-    def test_qualified_hostname
-        check_parseable "'host.example.com'"
-        check_parseable "\"host.example.com\""
-        check_parseable [ "'host.example.com'", "host1" ]
-        check_parseable [ "\"host.example.com\"", "host1" ]
-        check_parseable "'host-1.37examples.example.com'"
-        check_parseable "\"host-1.37examples.example.com\""
-        check_parseable "'svn.23.nu'"
-        check_parseable "\"svn.23.nu\""
-        check_parseable "'HOST'"
-        check_parseable "\"HOST\""
-    end
-    
-    def test_inherits_from_default
-        check_parseable(["default", "host1"], "node default {}\nnode host1 inherits default {}")
-    end
-
-    def test_reject_hostname
-        check_nonparseable "host.example.com"
-        check_nonparseable "host@example.com"
-        check_nonparseable "'$foo.example.com'"
-        check_nonparseable "\"$foo.example.com\""
-        check_nonparseable "'host1 host2'"
-        check_nonparseable "\"host1 host2\""
-        check_nonparseable "HOST"
-    end
-
-    AST = Puppet::Parser::AST
-
-    def check_parseable(hostnames, code = nil)
-        unless hostnames.is_a?(Array)
-            hostnames = [ hostnames ]
-        end
-        interp = nil
-        code ||= "node #{hostnames.join(", ")} { }"
-        parser = mkparser
-        parser.string = code
-        # Strip quotes
-        hostnames.map! { |s| s.sub(/^['"](.*)['"]$/, "\\1") }
-
-        # parse
-        assert_nothing_raised("Could not parse '%s'" % code) {
-            parser.parse
-        }
-
-        # Now make sure we can look up each of the names
-        hostnames.each do |name|
-            assert(parser.findnode(name),
-                "Could not find node %s" % name.inspect)
-        end
-    end
-
-    def check_nonparseable(hostname)
-        interp = nil
-        parser = mkparser
-        parser.string = "node #{hostname} { }"
-        assert_raise(Puppet::DevError, Puppet::ParseError, "#{hostname} passed") {
-            parser.parse
-        }
-    end
-
-    # Make sure we can find default nodes if there's no other entry
-    def test_default_node
-        Puppet[:parseonly] = false
-
-        fileA = tempfile()
-        fileB = tempfile()
-        code = %{
-node mynode {
-    file { "#{fileA}": ensure => file }
-}
-
-node default {
-    file { "#{fileB}": ensure => file }
-}
-}
-        interp = nil
-        assert_nothing_raised {
-            interp = mkinterp :Code => code
-        }
-
-        # First make sure it parses
-        assert_nothing_raised {
-            interp.send(:parsefiles)
-        }
-
-        # Make sure we find our normal node
-        assert(interp.nodesearch("mynode"),
-            "Did not find normal node")
-
-        # Now look for the default node
-        default = interp.nodesearch("someother")
-        assert(default,
-            "Did not find default node")
-
-        assert_equal("default", default.classname)
-    end
-end

data/test/lib/mocha/mock_methods.rb

@@ -1,122 +0,0 @@
-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/puppettest/graph.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke A. Kanies on 2006-11-24.
-#  Copyright (c) 2006. All rights reserved.
-
-require 'puppet/util/graph'
-
-class Container
-    include Puppet::Util::Graph
-    include Enumerable
-    attr_accessor :name
-    def each
-        @children.each do |c| yield c end
-    end
-    
-    def initialize(name, ary)
-        @name = name
-        @children = ary
-    end
-    
-    def push(*ary)
-        ary.each { |c| @children.push(c)}
-    end
-    
-    def to_s
-        @name
-    end
-end
-    
-module PuppetTest::Graph
-    def build_tree
-        one = Container.new("one", %w{a b})
-        two = Container.new("two", ["c", "d"])
-        three = Container.new("three", ["i", "j"])
-        middle = Container.new("middle", ["e", "f", two])
-        top = Container.new("top", ["g", "h", middle, one, three])
-        return one, two, three, middle, top
-    end
-end
-
-# $Id: graph.rb 1982 2006-12-29 00:05:03Z luke $

data/test/lib/spec.rb

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

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

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

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

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

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

data/test/lib/spec/expectations.rb

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