puppet 0.23.2 → 0.24.0

data/test/lib/spec/runner/specification.rb

@@ -1,114 +0,0 @@
-module Spec
-  module Runner
-    class Specification
-
-      class << self
-        attr_accessor :current, :generated_description
-        protected :current=
-
-        callback_events :before_setup, :after_teardown
-      end
-
-      attr_reader :spec_block
-      callback_events :before_setup, :after_teardown
-
-      def initialize(name, opts={}, &spec_block)
-        @from = caller(0)[3]
-        @description = name
-        @options = opts
-        @spec_block = spec_block
-        @description_generated_callback = lambda { |desc| @generated_description = desc }
-      end
-
-      def run(reporter, setup_block, teardown_block, dry_run, execution_context)
-        reporter.spec_started(name) if reporter
-        return reporter.spec_finished(name) if dry_run
-
-        errors = []
-        begin
-          set_current
-          setup_ok = setup_spec(execution_context, errors, &setup_block)
-          spec_ok = execute_spec(execution_context, errors) if setup_ok
-          teardown_ok = teardown_spec(execution_context, errors, &teardown_block)
-        ensure
-          clear_current
-        end
-
-        SpecShouldRaiseHandler.new(@from, @options).handle(errors)
-        reporter.spec_finished(name, errors.first, failure_location(setup_ok, spec_ok, teardown_ok)) if reporter
-      end
-      
-      def matches?(matcher, description)
-        matcher.spec_desc = name
-        matcher.matches?(description)
-      end
-      
-      private
-      def name
-        @description == :__generate_description ? generated_description : @description
-      end
-      
-      def generated_description
-        @generated_description || "NAME NOT GENERATED"
-      end
-      
-      def setup_spec(execution_context, errors, &setup_block)
-        notify_before_setup(errors)
-        execution_context.instance_eval(&setup_block) if setup_block
-        return errors.empty?
-      rescue => e
-        errors << e
-        return false
-      end
-
-      def execute_spec(execution_context, errors)
-        begin
-          execution_context.instance_eval(&spec_block)
-          return true
-        rescue Exception => e
-          errors << e
-          return false
-        end
-      end
-
-      def teardown_spec(execution_context, errors, &teardown_block)
-        execution_context.instance_eval(&teardown_block) if teardown_block
-        notify_after_teardown(errors)
-        return errors.empty?
-      rescue => e
-        errors << e
-        return false
-      end
-
-      def notify_before_setup(errors)
-        notify_class_callbacks(:before_setup, self, &append_errors(errors))
-        notify_callbacks(:before_setup, self, &append_errors(errors))
-      end
-      
-      def notify_after_teardown(errors)
-        notify_callbacks(:after_teardown, self, &append_errors(errors))
-        notify_class_callbacks(:after_teardown, self, &append_errors(errors))
-      end
-      
-      def append_errors(errors)
-        proc {|error| errors << error}
-      end
-      
-      def set_current
-        Spec::Matchers.description_generated(&@description_generated_callback)
-        self.class.send(:current=, self)
-      end
-
-      def clear_current
-        Spec::Matchers.unregister_callback(:description_generated, @description_generated_callback)
-        self.class.send(:current=, nil)
-      end
-
-      def failure_location(setup_ok, spec_ok, teardown_ok)
-        return 'setup' unless setup_ok
-        return name unless spec_ok
-        return 'teardown' unless teardown_ok
-      end
-    end
-  end
-end

data/test/lib/spec/translator.rb

@@ -1,87 +0,0 @@
-require 'fileutils'
-
-module Spec
-  class Translator
-    def translate_dir(from, to)
-      from = File.expand_path(from)
-      to = File.expand_path(to)
-      if File.directory?(from)
-        FileUtils.mkdir_p(to) unless File.directory?(to)
-        Dir["#{from}/*"].each do |sub_from|
-          path = sub_from[from.length+1..-1]
-          sub_to = File.join(to, path)
-          translate_dir(sub_from, sub_to)
-        end
-      else
-        translate_file(from, to)
-      end
-    end
-    
-    def translate_file(from, to)
-      translation = ""
-      File.open(from) do |io|
-        io.each_line do |line|
-          translation << translate(line)
-        end
-      end
-      File.open(to, "w") do |io|
-        io.write(translation)
-      end
-    end
-
-    def translate(line)
-      return line if line =~ /(should_not|should)_receive/
-      
-      if line =~ /(.*\.)(should_not|should)(?:_be)(?!_)(.*)/m
-        pre = $1
-        should = $2
-        post = $3
-        be_or_equal = post =~ /(<|>)/ ? "be" : "equal"
-        
-        return "#{pre}#{should} #{be_or_equal}#{post}"
-      end
-      
-      if line =~ /(.*\.)(should_not|should)_(?!not)(.*)/m
-        pre = $1
-        should = $2
-        post = $3
-        
-        post.gsub!(/^raise/, 'raise_error')
-        post.gsub!(/^throw/, 'throw_symbol')
-        
-        unless standard_matcher?(post)
-          post = "be_#{post}"
-        end
-        
-        line = "#{pre}#{should} #{post}"
-      end
-
-      line
-    end
-    
-    def standard_matcher?(matcher)
-      patterns = [
-        /^be/, 
-        /^be_close/,
-        /^eql/, 
-        /^equal/, 
-        /^has/, 
-        /^have/, 
-        /^change/, 
-        /^include/,
-        /^match/, 
-        /^raise_error/, 
-        /^respond_to/, 
-        /^satisfy/, 
-        /^throw_symbol/,
-        # Extra ones that we use in spec_helper
-        /^pass/,
-        /^fail/,
-        /^fail_with/,
-      ]
-      matched = patterns.detect{ |p| matcher =~ p }
-      !matched.nil?
-    end
-    
-  end
-end

data/test/lib/spec/version.rb

@@ -1,30 +0,0 @@
-module Spec
-  module VERSION
-    def self.build_tag
-      tag = "REL_" + [MAJOR, MINOR, TINY].join('_')
-      if defined?(RELEASE_CANDIDATE)
-        tag << "_" << RELEASE_CANDIDATE
-      end
-      tag
-    end
-
-    unless defined? MAJOR
-      MAJOR  = 0
-      MINOR  = 8
-      TINY   = 2
-      # RELEASE_CANDIDATE = "RC1"
-      
-      # RANDOM_TOKEN: 0.375509844656552
-      REV = "$LastChangedRevision: 2283 $".match(/LastChangedRevision: (\d+)/)[1]
-
-      STRING = [MAJOR, MINOR, TINY].join('.')
-      FULL_VERSION = "#{STRING} (r#{REV})"
-      TAG = build_tag
-
-      NAME   = "RSpec"
-      URL    = "http://rspec.rubyforge.org/"  
-    
-      DESCRIPTION = "#{NAME}-#{FULL_VERSION} - BDD for Ruby\n#{URL}"
-    end
-  end
-end

data/test/network/handler/facts.rb

@@ -1,112 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'mocha'
-require 'puppet/network/handler/facts'
-
-class TestFactsHandler < Test::Unit::TestCase
-    include PuppetTest::ServerTest
-
-    def setup
-        super
-
-        @class = Puppet::Network::Handler.handler(:facts)
-
-        @@client_facts = {}
-
-        unless Puppet::Util::FactStore.store(:testing)
-            Puppet::Util::FactStore.newstore(:testing) do
-                def get(node)
-                    @@client_facts[node]
-                end
-
-                def set(node, facts)
-                    @@client_facts[node] = facts
-                end
-            end
-        end
-
-        Puppet[:factstore] = :testing
-
-        @handler = @class.new
-
-        @facts = {:a => :b, :c => :d}
-        @name = "foo"
-
-        @backend = @handler.instance_variable_get("@backend")
-    end
-
-    def teardown
-        @@client_facts.clear
-    end
-
-    def test_strip_internal
-        @facts[:_puppet_one] = "yay"
-        @facts[:_puppet_two] = "boo"
-        @facts[:_puppetthree] = "foo"
-
-        newfacts = nil
-        assert_nothing_raised("Could not call strip_internal") do
-            newfacts = @handler.send(:strip_internal, @facts)
-        end
-
-        [:_puppet_one, :_puppet_two, :_puppetthree].each do |name|
-            assert(@facts.include?(name), "%s was removed in strip_internal from original hash" % name)
-        end
-        [:_puppet_one, :_puppet_two].each do |name|
-            assert(! newfacts.include?(name), "%s was not removed in strip_internal" % name)
-        end
-        assert_equal("foo", newfacts[:_puppetthree], "_puppetthree was removed in strip_internal")
-    end
-
-    def test_add_internal
-        newfacts = nil
-        assert_nothing_raised("Could not call strip_internal") do
-            newfacts = @handler.send(:add_internal, @facts)
-        end
-
-        assert_instance_of(Time, newfacts[:_puppet_timestamp], "Did not set timestamp in add_internal")
-        assert(! @facts.include?(:_puppet_timestamp), "Modified original hash in add_internal")
-    end
-
-    def test_set
-        newfacts = @facts.dup
-        newfacts[:_puppet_timestamp] = Time.now
-        @handler.expects(:add_internal).with(@facts).returns(newfacts)
-        @backend.expects(:set).with(@name, newfacts).returns(nil)
-
-        assert_nothing_raised("Could not set facts") do
-            assert_nil(@handler.set(@name, @facts), "handler.set did not return nil")
-        end
-    end
-
-    def test_get
-        prefacts = @facts.dup
-        prefacts[:_puppet_timestamp] = Time.now
-        @@client_facts[@name] = prefacts
-        @handler.expects(:strip_internal).with(prefacts).returns(@facts)
-        @backend.expects(:get).with(@name).returns(prefacts)
-
-        assert_nothing_raised("Could not retrieve facts") do
-            assert_equal(@facts,  @handler.get(@name), "did not get correct answer from handler.get")
-        end
-
-        @handler = @class.new
-        assert_nothing_raised("Failed to call 'get' with no stored facts") do
-            @handler.get("nosuchname")
-        end
-    end
-
-    def test_store_date
-        time = Time.now
-        @facts[:_puppet_timestamp] = time
-
-        @handler.expects(:get).with(@name).returns(@facts)
-
-        assert_equal(time.to_i, @handler.store_date(@name), "Did not retrieve timestamp correctly")
-    end
-end
-
-# $Id: facts.rb 2457 2007-05-03 05:24:13Z luke $

data/test/other/pgraph.rb

@@ -1,290 +0,0 @@
-#!/usr/bin/env ruby
-#
-#  Created by Luke Kanies on 2006-11-16.
-#  Copyright (c) 2006. All rights reserved.
-
-$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppettest/graph'
-
-class TestPGraph < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::Graph
-	
-	Edge = Puppet::Relationship
-	
-	def test_clear
-	    graph = Puppet::PGraph.new
-	    graph.add_edge!("a", "b")
-	    graph.add_vertex! "c"
-	    assert_nothing_raised do
-	        graph.clear
-        end
-        assert(graph.vertices.empty?, "Still have vertices after clear")
-        assert(graph.edges.empty?, "still have edges after clear")
-    end
-	    
-	
-	def test_matching_edges
-	    graph = Puppet::PGraph.new
-	    
-	    event = Puppet::Event.new(:source => "a", :event => :yay)
-	    none = Puppet::Event.new(:source => "a", :event => :NONE)
-	    
-	    edges = {}
-	    
-	    edges["a/b"] = Edge["a", "b", {:event => :yay, :callback => :refresh}]
-	    edges["a/c"] = Edge["a", "c", {:event => :yay, :callback => :refresh}]
-	    
-	    graph.add_edge!(edges["a/b"])
-	    
-	    # Try it for the trivial case of one target and a matching event
-	    assert_equal([edges["a/b"]], graph.matching_edges([event]))
-	    
-	    # Make sure we get nothing with a different event
-	    assert_equal([], graph.matching_edges([none]))
-	    
-	    # Set up multiple targets and make sure we get them all back
-	    graph.add_edge!(edges["a/c"])
-	    assert_equal([edges["a/b"], edges["a/c"]].sort, graph.matching_edges([event]).sort)
-	    assert_equal([], graph.matching_edges([none]))
-    end
-    
-    def test_dependencies
-        graph = Puppet::PGraph.new
-        
-        graph.add_edge!("a", "b")
-        graph.add_edge!("a", "c")
-        graph.add_edge!("b", "d")
-        
-        assert_equal(%w{b c d}.sort, graph.dependents("a").sort)
-        assert_equal(%w{d}.sort, graph.dependents("b").sort)
-        assert_equal([].sort, graph.dependents("c").sort)
-        
-        assert_equal(%w{a b}, graph.dependencies("d").sort)
-        assert_equal(%w{a}, graph.dependencies("b").sort)
-        assert_equal(%w{a}, graph.dependencies("c").sort)
-        assert_equal([], graph.dependencies("a").sort)
-        
-    end
-    
-    # Test that we can take a containment graph and rearrange it by dependencies
-    def test_splice
-        one, two, three, middle, top = build_tree
-        empty = Container.new("empty", [])
-        # Also, add an empty container to top
-        top.push empty
-
-        contgraph = top.to_graph
-
-        # Now add a couple of child files, so that we can test whether all
-        # containers get spliced, rather than just components.
-
-        # Now make a dependency graph
-        deps = Puppet::PGraph.new
-
-        contgraph.vertices.each do |v|
-            deps.add_vertex(v)
-        end
-
-        # We have to specify a relationship to our empty container, else it
-        # never makes it into the dep graph in the first place.
-        {one => two, "f" => "c", "h" => middle, "c" => empty}.each do |source, target|
-            deps.add_edge!(source, target, :callback => :refresh)
-        end
-        
-        #contgraph.to_jpg(File.expand_path("~/Desktop/pics"), "main")
-        #deps.to_jpg(File.expand_path("~/Desktop/pics"), "before")
-        assert_nothing_raised { deps.splice!(contgraph, Container) }
-        
-        assert(! deps.cyclic?, "Created a cyclic graph")
-
-        # Make sure there are no container objects remaining
-        #deps.to_jpg(File.expand_path("~/Desktop/pics"), "after")
-        c = deps.vertices.find_all { |v| v.is_a?(Container) }
-        assert(c.empty?, "Still have containers %s" % c.inspect)
-        
-        # Now make sure the containers got spliced correctly.
-        contgraph.leaves(middle).each do |leaf|
-            assert(deps.edge?("h", leaf), "no edge for h => %s" % leaf)
-        end
-        one.each do |oobj|
-            two.each do |tobj|
-                assert(deps.edge?(oobj, tobj), "no %s => %s edge" % [oobj, tobj])
-            end
-        end
-        
-        nons = deps.vertices.find_all { |v| ! v.is_a?(String) }
-        assert(nons.empty?,
-            "still contain non-strings %s" % nons.inspect)
-        
-        deps.edges.each do |edge|
-            assert_equal({:callback => :refresh}, edge.label,
-                "Label was not copied for %s => %s" % [edge.source, edge.target])
-        end
-
-        # Now add some relationships to three, but only add labels to one of
-        # the relationships.
-
-        # Add a simple, label-less relationship
-        deps.add_edge!(two, three)
-        assert_nothing_raised { deps.splice!(contgraph, Container) }
-
-        # And make sure it stuck, with no labels.
-        assert_equal({}, deps.edge_label("c", "i"),
-            "label was created for c => i")
-
-        # Now add some edges with labels, in a way that should overwrite
-        deps.add_edge!("c", three, {:callback => :refresh})
-        assert_nothing_raised { deps.splice!(contgraph, Container) }
-
-        # And make sure the label got copied.
-        assert_equal({:callback => :refresh}, deps.edge_label("c", "i"),
-            "label was not copied for c => i")
-
-        # Lastly, add some new label-less edges and make sure the label stays.
-        deps.add_edge!(middle, three)
-        assert_nothing_raised { deps.splice!(contgraph, Container) }
-        assert_equal({:callback => :refresh}, deps.edge_label("c", "i"),
-            "label was lost for c => i")
-        
-        # Now make sure the 'three' edges all have the label we've used.
-        # Note that this will not work when we support more than one type of
-        # subscription.
-        three.each do |child|
-            edge = deps.edge_class.new("c", child)
-            assert(deps.edge?(edge), "no c => %s edge" % child)
-            assert_equal({:callback => :refresh}, deps[edge],
-                "label was not retained for c => %s" % child)
-        end
-    end
-
-    def test_copy_label
-        graph = Puppet::PGraph.new
-
-        # First make an edge with no label
-        graph.add_edge!(:a, :b)
-        assert_nil(graph.edge_label(:a, :b), "Created a label")
-
-        # Now try to copy an empty label in.
-        graph.copy_label(:a, :b, {})
-
-        # It should just do nothing, since we copied an empty label.
-        assert_nil(graph.edge_label(:a, :b), "Created a label")
-
-        # Now copy in a real label.
-        graph.copy_label(:a, :b, {:callback => :yay})
-        assert_equal({:callback => :yay},
-            graph.edge_label(:a, :b), "Did not copy label")
-
-        # Now copy in a nil label
-        graph.copy_label(:a, :b, nil)
-        assert_equal({:callback => :yay},
-            graph.edge_label(:a, :b), "lost label")
-
-        # And an empty one.
-        graph.copy_label(:a, :b, {})
-        assert_equal({:callback => :yay},
-            graph.edge_label(:a, :b), "lost label")
-    end
-
-    def test_fail_on_cycle
-        {
-            {:a => :b, :b => :a, :c => :a, :d => :c} => true, # larger tree involving a smaller cycle
-            {:a => :b, :b => :c, :c => :a} => true,
-            {:a => :b, :b => :a, :c => :d, :d => :c} => true,
-            {:a => :b, :b => :c} => false,
-        }.each do |hash, result|
-            graph = Puppet::PGraph.new
-            hash.each do |a,b|
-                graph.add_edge!(a, b)
-            end
-
-            if result
-                assert_raise(Puppet::Error, "%s did not fail" % hash.inspect) do
-                   graph.topsort
-                end
-            else
-                assert_nothing_raised("%s failed" % hash.inspect) do
-                    graph.topsort
-                end
-            end
-        end
-    end
-
-    # This isn't really a unit test, it's just a way to do some graphing with
-    # tons of relationships so we can see how it performs.
-    def disabled_test_lots_of_relationships
-        containers = Puppet::PGraph.new
-        relationships = Puppet::PGraph.new
-        labels = %w{a b c d e}
-        conts = {}
-        vertices = {}
-        labels.each do |label|
-            vertices[label] = []
-        end
-        num = 100
-        num.times do |i|
-            labels.each do |label|
-                vertices[label] << ("%s%s" % [label, i])
-            end
-        end
-        labels.each do |label|
-            conts[label] = Container.new(label, vertices[label])
-        end
-
-        conts.each do |label, cont|
-            cont.each do |child|
-                containers.add_edge!(cont, child)
-            end
-        end
-        prev = nil
-        labels.inject(nil) do |prev, label|
-            if prev
-                containers.add_edge!(conts[prev], conts[label])
-            end
-            label
-        end
-
-        containers.to_jpg(File.expand_path("~/Desktop/pics/lots"), "start")
-
-        # Now create the relationship graph
-
-        # Make everything in both b and c require d1
-        %w{b c}.each do |label|
-            conts[label].each do |v|
-                relationships.add_edge!(v, "d1")
-                #relationships.add_edge!(v, conts["d"])
-            end
-        end
-
-        # Make most in b also require the appropriate thing in c
-        conts["b"].each do |v|
-            i = v.split('')[1]
-
-            relationships.add_edge!(v, "c%s" % i)
-        end
-
-        # And make d1 require most of e
-        num.times do |i|
-            relationships.add_edge!("d1", "e%s" % i)
-        end
-
-        containers.vertices.each do |v|
-            relationships.add_vertex!(v)
-        end
-        relationships.to_jpg(File.expand_path("~/Desktop/pics/lots"), "relationships")
-
-        time = Benchmark.realtime do
-            relationships.splice!(containers, Container)
-        end
-        relationships.to_jpg(File.expand_path("~/Desktop/pics/lots"), "final")
-        puts time
-        time = Benchmark.realtime do
-            relationships.topsort
-        end
-    end
-end
-
-# $Id: pgraph.rb 2521 2007-05-17 20:57:24Z luke $