puppet 0.18.4 → 0.22.4

data/test/other/events.rb

@@ -1,21 +1,14 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../../../../language/trunk"
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
 
-# $Id: events.rb 1179 2006-05-05 19:47:15Z luke $
+# $Id: events.rb 1918 2006-12-13 17:59:21Z luke $
 
 class TestEvents < Test::Unit::TestCase
-	include TestPuppet
-    def teardown
-        super
-        Puppet::Event::Subscription.clear
-    end
+	include PuppetTest
 
     def test_simplesubscribe
         name = tempfile()
@@ -32,7 +25,7 @@ class TestEvents < Test::Unit::TestCase
 
         comp = newcomp("eventtesting", file, exec)
 
-        trans = assert_events([:file_created], comp)
+        trans = assert_events([:file_created, :triggered], comp)
 
         assert_equal(1, trans.triggered?(exec, :refresh))
     end
@@ -128,27 +121,41 @@ class TestEvents < Test::Unit::TestCase
         assert(FileTest.exists?(fname), "Exec file did not get created")
     end
 
+    # Make sure refreshing happens mid-transaction, rather than at the end.
     def test_refreshordering
         file = tempfile()
 
         exec1 = Puppet.type(:exec).create(
+            :title => "one",
             :name => "echo one >> %s" % file,
             :path => "/usr/bin:/bin"
         )
 
         exec2 = Puppet.type(:exec).create(
+            :title => "two",
             :name => "echo two >> %s" % file,
             :path => "/usr/bin:/bin",
             :refreshonly => true,
-            :subscribe => ["exec", exec1.name]
+            :subscribe => exec1
         )
 
         exec3 = Puppet.type(:exec).create(
+            :title => "three",
             :name => "echo three >> %s" % file,
-            :path => "/usr/bin:/bin"
+            :path => "/usr/bin:/bin",
+            :require => exec2
         )
+        execs = [exec1, exec2, exec3]
 
         comp = newcomp(exec1,exec2,exec3)
+        
+        trans = comp.evaluate
+        execs.each do |e| assert(trans.resources.vertex?(e), "%s is not in graph" % e.title) end
+        trans.prepare
+        execs.each do |e| assert(trans.relgraph.vertex?(e), "%s is not in relgraph" % e.title) end
+        reverse = trans.relgraph.reversal
+        execs.each do |e| assert(reverse.vertex?(e), "%s is not in reversed graph" % e.title) end
+        
 
         assert_apply(comp)
 

data/test/other/overrides.rb

@@ -1,15 +1,12 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppettest'
-require 'test/unit'
 
 class TestOverrides < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
     def mksubdirs(basedir, level)
         @@tmpfiles << basedir
         dir = basedir.dup
@@ -30,6 +27,7 @@ class TestOverrides < Test::Unit::TestCase
         basefile = File.join(basedir, "file")
         assert_nothing_raised("Could not create base obj") {
             baseobj = Puppet.type(:file).create(
+                :title => "base",
                 :path => basedir,
                 :recurse => true,
                 :mode => "755"
@@ -41,23 +39,20 @@ class TestOverrides < Test::Unit::TestCase
         subfile = File.join(subdir, "file")
         assert_nothing_raised("Could not create sub obj") {
             subobj = Puppet.type(:file).create(
+                :title => "sub",
                 :path => subdir,
                 :recurse => true,
                 :mode => "644"
             )
         }
 
-        comp = newcomp("overrides", baseobj, subobj)
-        assert_nothing_raised("Could not eval component") {
-            trans = comp.evaluate
-            trans.evaluate
-        }
+        assert_apply(baseobj, subobj)
 
         assert(File.stat(basefile).mode & 007777 == 0755)
         assert(File.stat(subfile).mode & 007777 == 0644)
     end
 
-    def test_zdeepoverride
+    def test_deepoverride
         basedir = File.join(tmpdir(), "deepoverridetesting")
         mksubdirs(basedir, 10)
 
@@ -112,4 +107,4 @@ class TestOverrides < Test::Unit::TestCase
     end
 end
 
-# $Id: overrides.rb 787 2006-01-08 00:02:23Z luke $
+# $Id: overrides.rb 1896 2006-12-01 04:11:11Z luke $

data/test/other/pgraph.rb

@@ -0,0 +1,289 @@
+#!/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_check_cycle
+        {
+            {:a => :b, :b => :a} => true,
+            {:a => :b, :b => :c, :c => :a} => 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.check_cycle(graph.topsort)
+                end
+            else
+                assert_nothing_raised("%s failed" % hash.inspect) do
+                    graph.check_cycle(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 2230 2007-02-27 20:34:32Z luke $

data/test/other/propertychange.rb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke A. Kanies on 2006-12-21.
+#  Copyright (c) 2006. All rights reserved.
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+class TestPropertyChange < Test::Unit::TestCase
+	include PuppetTest
+	class FakeProperty < Puppet::Type::Property
+	    attr_accessor :is, :should, :parent
+	    attr_reader :noop
+	    def change_to_s
+	        "fake change"
+        end
+	    def insync?
+	        @is == @should
+        end
+        def log(msg)
+            Puppet::Util::Log.create(
+                :level => :info,
+                :source => self,
+                :message => msg
+            )
+        end
+        def noop
+            if defined? @noop
+                @noop
+            else
+                false
+            end
+        end
+        def path
+            "fakechange"
+        end
+        def should_to_s
+            @should.to_s
+        end
+        def sync
+            if insync?
+                return nil
+            else
+                @is = @should
+                return :fake_change
+            end
+        end
+        def to_s
+            path
+        end
+    end
+    
+    def mkchange
+        property = FakeProperty.new :parent => "fakeparent"
+        property.is = :start
+        property.should = :finish
+        property.parent = :parent
+        change = nil
+        assert_nothing_raised do
+            change = Puppet::PropertyChange.new(property)
+        end
+        change.transaction = :trans
+        
+        assert_equal(:start, change.is, "@is did not get copied")
+        assert_equal(:finish, change.should, "@should did not get copied")
+        assert_equal(%w{fakechange change}, change.path, "path did not get set correctly")
+        
+        assert(! change.changed?, "change defaulted to already changed")
+        
+        return change
+    end
+    
+	def test_go
+	    change = mkchange
+	    
+	    coll = logcollector()
+	    
+	    events = nil
+	    # First make sure we get an immediate return 
+	    assert_nothing_raised do
+    	    events = change.go
+	    end
+	    assert_instance_of(Array, events, "events were not returned in an array")
+	    assert_instance_of(Puppet::Event, events[0], "event array did not contain events")
+
+	    event = events.shift
+	    {:event => :fake_change, :transaction => :trans, :source => :parent}.each do |method, val|
+	        assert_equal(val, event.send(method), "Event did not set %s correctly" % method)
+        end
+	    
+        # Disabled, because it fails when running the whole suite at once.
+        #assert(coll.detect { |l| l.message == "fake change" }, "Did not log change")
+	    assert_equal(change.property.is, change.property.should, "did not call sync method")
+	    
+	    # Now make sure that proxy sources can be set.
+	    assert_nothing_raised do
+    	    change.proxy = :other
+	    end
+	    # Reset, so we change again
+	    change.property.is = :start
+	    change.is = :start
+	    assert_nothing_raised do
+	        events = change.go
+        end
+        
+	    assert_instance_of(Array, events, "events were not returned in an array")
+	    assert_instance_of(Puppet::Event, events[0], "event array did not contain events")
+
+	    event = events.shift
+	    {:event => :fake_change, :transaction => :trans, :source => :other}.each do |method, val|
+	        assert_equal(val, event.send(method), "Event did not set %s correctly" % method)
+        end
+	    
+	    #assert(coll.detect { |l| l.message == "fake change" }, "Did not log change")
+	    assert_equal(change.property.is, change.property.should, "did not call sync method")
+    end
+
+    # Related to #542.  Make sure changes in noop mode produce the :noop event.
+    def test_noop_event
+        change = mkchange
+
+        assert(! change.skip?, "Change is already being skipped")
+
+        Puppet[:noop] = true
+
+        change.property.noop = true
+        p change.property.noop
+        assert(change.noop, "did not set noop")
+        assert(change.skip?, "setting noop did not mark change for skipping")
+
+        event = nil
+        assert_nothing_raised("Could not generate noop event") do
+            event = change.forward
+        end
+
+        assert_equal(1, event.length, "got wrong number of events")
+        assert_equal(:noop, event[0].event, "did not generate noop mode when in noop")
+    end
+end
+
+# $Id: propertychange.rb 2286 2007-03-17 23:16:37Z luke $