puppet 0.18.4 → 0.22.4

data/test/other/report.rb

@@ -1,30 +1,27 @@
-if __FILE__ == $0
-    $:.unshift '..'
-    $:.unshift '../../lib'
-    $puppetbase = "../.."
-end
+#!/usr/bin/env ruby
+
+$:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppet'
 require 'puppet/transaction/report'
 require 'puppettest'
-require 'test/unit'
+require 'puppettest/reporttesting'
 
 class TestReports < Test::Unit::TestCase
-	include TestPuppet
+	include PuppetTest
+	include PuppetTest::Reporttesting
 
     # Make sure we can use reports as log destinations.
     def test_reports_as_log_destinations
-        report = nil
-        assert_nothing_raised {
-            report = Puppet::Transaction::Report.new
-        }
+        report = fakereport
 
         assert_nothing_raised {
-            Puppet::Log.newdestination(report)
+            Puppet::Util::Log.newdestination(report)
         }
 
         # Now make a file for testing logging
         file = Puppet::Type.newfile(:path => tempfile(), :ensure => "file")
+        file.finish
 
         log = nil
         assert_nothing_raised {
@@ -33,12 +30,12 @@ class TestReports < Test::Unit::TestCase
 
         assert(report.logs.include?(log), "Report did not get log message")
 
-        log = Puppet.info "This is a non-sourced message"
+        log = Puppet.warning "This is a non-sourced message"
 
         assert(! report.logs.include?(log), "Report got log message")
 
         assert_nothing_raised {
-            Puppet::Log.close(report)
+            Puppet::Util::Log.close(report)
         }
 
         log = file.log "This is another message, yo"
@@ -60,12 +57,43 @@ class TestReports < Test::Unit::TestCase
         }
     end
 
-    if Puppet::Metric.haverrd?
+    def test_store_report
+        # Create a bunch of log messages in an array.
+        report = Puppet::Transaction::Report.new
+        
+        # We have to reuse reporting here because of something going on in the
+        # server/report.rb file
+        Puppet.config.use(:reporting)
+
+        3.times { |i|
+            log = Puppet.warning("Report test message %s" % i)
+            log.tags = %w{a list of tags}
+            log.tags << "tag%s" % i
+
+            report.newlog(log)
+        }
+
+        assert_nothing_raised do
+            report.extend(Puppet::Network::Handler.report.report(:store))
+        end
+
+        yaml = YAML.dump(report)
+
+        file = nil
+        assert_nothing_raised {
+            file = report.process(yaml)
+        }
+
+        assert(FileTest.exists?(file), "report file did not get created")
+        assert_equal(yaml, File.read(file), "File did not get written")
+    end
+
+    if Puppet.features.rrd?
     def test_rrdgraph_report
         Puppet.config.use(:metrics)
         # First do some work
         objects = []
-        25.times do |i|
+        6.times do |i|
             file = tempfile()
 
             # Make every third file
@@ -88,19 +116,120 @@ class TestReports < Test::Unit::TestCase
             trans.evaluate
         }
 
-        method = Puppet::Server::Report.report("rrdgraph")
-        server = nil
-        assert_nothing_raised {
-            server = Puppet::Server::Report.new()
-        }
+        report = trans.generate_report
+
+        assert(! report.metrics.empty?, "Did not receive any metrics")
+
+        assert_nothing_raised do
+            report.extend(Puppet::Network::Handler.report.report(:rrdgraph))
+        end
 
         assert_nothing_raised {
-            server.report_rrdgraph(trans.report)
+            report.process
         }
+
+        hostdir = nil
+        assert_nothing_raised do
+            hostdir = report.hostdir
+        end
+
+        assert(hostdir, "Did not get hostdir back")
+
+        assert(FileTest.directory?(hostdir), "Host rrd dir did not get created")
+        index = File.join(hostdir, "index.html")
+        assert(FileTest.exists?(index), "index file was not created")
+
+        # Now make sure it creaets each of the rrd files
+        %w{changes resources time}.each do |type|
+            file = File.join(hostdir, "%s.rrd" % type)
+            assert(FileTest.exists?(file), "Did not create rrd file for %s" % type)
+
+            daily = file.sub ".rrd", "-daily.png"
+            assert(FileTest.exists?(daily),
+                "Did not make daily graph for %s" % type)
+        end
+
     end
     else
     $stderr.puts "Install RRD for metric reporting tests"
     end
+    
+    def test_tagmail_parsing
+        report = Object.new
+        report.extend(Puppet::Network::Handler.report.report(:tagmail))
+        
+        passers = File.join(datadir, "reports", "tagmail_passers.conf")
+        assert(FileTest.exists?(passers), "no passers file %s" % passers)
+        
+        File.readlines(passers).each do |line|
+            assert_nothing_raised("Could not parse %s" % line.inspect) do
+                report.parse(line)
+            end
+        end
+        
+        # Now make sure the failers fail
+        failers = File.join(datadir, "reports", "tagmail_failers.conf")
+        assert(FileTest.exists?(failers), "no failers file %s" % failers)
+        
+        File.readlines(failers).each do |line|
+            assert_raise(ArgumentError, "Parsed %s" % line.inspect) do
+                report.parse(line)
+            end
+        end
+    end
+    
+    def test_tagmail_parsing_results
+        report = Object.new
+        report.extend(Puppet::Network::Handler.report.report(:tagmail))
+        # Now test a few specific lines to make sure we get the results we want
+        {
+            "tag: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, []],
+            "tag, other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag other}, []],
+            "tag-other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag-other}, []],
+            "tag, !other: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag}, %w{other}],
+            "tag, !other, one, !two: abuse@domain.com" => [%w{abuse@domain.com}, %w{tag one}, %w{other two}],
+            "tag: abuse@domain.com, other@domain.com" => [%w{abuse@domain.com other@domain.com}, %w{tag}, []]
+            
+        }.each do |line, results|
+            assert_nothing_raised("Failed to parse %s" % line.inspect) do
+                assert_equal(results, report.parse(line).shift, "line %s returned incorrect results %s" % [line.inspect, results.inspect])
+            end
+        end
+    end
+    
+    def test_tagmail_matching
+        report = Puppet::Transaction::Report.new
+        Puppet::Util::Log.close
+        [%w{one}, %w{one two}, %w{one two three}, %w{one two three four}].each do |tags|
+            log = Puppet::Util::Log.new(:level => :notice, :message => tags.join(" "), :tags => tags)
+            
+            report << log
+        end
+        
+        list = report.logs.collect { |l| l.to_report }
+        
+        report.extend(Puppet::Network::Handler.report.report(:tagmail))
+        
+        {
+            [%w{abuse@domain.com}, %w{all}, []] => list,
+            [%w{abuse@domain.com}, %w{all}, %w{three}] => list[0..1],
+            [%w{abuse@domain.com}, %w{one}, []] => list,
+            [%w{abuse@domain.com}, %w{two}, []] => list[1..3],
+            [%w{abuse@domain.com}, %w{two}, %w{three}] => list[1..1],
+            [%w{abuse@domain.com}, %w{}, %w{one}] => nil
+        }.each do |args, expected|
+            results = nil
+            assert_nothing_raised("Could not match with %s" % args.inspect) do
+                results = report.match([args])
+            end
+            
+            if expected
+                assert_equal([args[0], expected.join("\n")], results[0], "did get correct results for %s" % args.inspect)
+            else
+                assert_nil(results[0], "got a report for %s" % args.inspect)
+            end
+        end
+    end
 end
 
-# $Id: report.rb 1359 2006-07-04 16:27:35Z luke $
+# $Id: report.rb 2438 2007-04-30 18:15:01Z luke $

data/test/other/transactions.rb

@@ -1,20 +1,71 @@
-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'
+require 'mocha'
+require 'puppettest/support/resources'
 
-# $Id: transactions.rb 1358 2006-07-04 16:07:47Z luke $
+# $Id: transactions.rb 2372 2007-03-30 00:47:03Z luke $
 
 class TestTransactions < Test::Unit::TestCase
-	include FileTesting
-
-    # In case they're not in more than one group
-    def test_nothing
+    include PuppetTest::FileTesting
+    include PuppetTest::Support::Resources
+    class Fakeprop <Puppet::Type::Property
+        attr_accessor :path, :is, :should, :name
+        def should_to_s
+            @should.to_s
+        end
+        def insync?
+            true
+        end
+        def info(*args)
+            false
+        end
+    end
+    
+    
+    def mkgenerator(&block)
+        $finished = []
+        cleanup { $finished = nil }
+        
+        # Create a bogus type that generates new instances with shorter
+        type = Puppet::Type.newtype(:generator) do
+            newparam(:name, :namevar => true)
+            def finish
+                $finished << self.name
+            end
+        end
+        if block
+            type.class_eval(&block)
+        end
+        cleanup do
+            Puppet::Type.rmtype(:generator)
+        end
+        
+        return type
+    end
+    
+    # Create a new type that generates instances with shorter names.
+    def mkreducer(&block)
+        type = mkgenerator() do
+            def eval_generate
+                ret = []
+                if title.length > 1
+                    ret << self.class.create(:title => title[0..-2])
+                else
+                    return nil
+                end
+                ret
+            end
+        end
+        
+        if block
+            type.class_eval(&block)
+        end
+        
+        return type
     end
 
     def test_reports
@@ -35,14 +86,14 @@ class TestTransactions < Test::Unit::TestCase
         report = nil
 
         assert_nothing_raised {
-            report = trans.report
+            report = trans.generate_report
         }
 
         # First test the report logs
         assert(report.logs.length > 0, "Did not get any report logs")
 
         report.logs.each do |obj|
-            assert_instance_of(Puppet::Log, obj)
+            assert_instance_of(Puppet::Util::Log, obj)
         end
 
         # Then test the metrics
@@ -51,12 +102,74 @@ class TestTransactions < Test::Unit::TestCase
         assert(metrics, "Did not get any metrics")
         assert(metrics.length > 0, "Did not get any metrics")
 
-        assert(metrics.has_key?("objects"), "Did not get object metrics")
+        assert(metrics.has_key?("resources"), "Did not get object metrics")
         assert(metrics.has_key?("changes"), "Did not get change metrics")
 
         metrics.each do |name, metric|
-            assert_instance_of(Puppet::Metric, metric)
+            assert_instance_of(Puppet::Util::Metric, metric)
+        end
+    end
+
+    def test_prefetch
+        # Create a type just for testing prefetch
+        name = :prefetchtesting
+        $prefetched = false
+        type = Puppet::Type.newtype(name) do
+            newparam(:name) {}
+        end
+        
+        cleanup do
+            Puppet::Type.rmtype(name)
+        end
+
+        # Now create a provider
+        type.provide(:prefetch) do
+            def self.prefetch
+                $prefetched = true
+            end
+        end
+
+        # Now create an instance
+        inst = type.create :name => "yay"
+        
+        # Create a transaction
+        trans = Puppet::Transaction.new(newcomp(inst))
+
+        # Make sure prefetch works
+        assert_nothing_raised do
+            trans.prefetch
+        end
+
+        assert_equal(true, $prefetched, "type prefetch was not called")
+
+        # Now make sure it gets called from within evaluate()
+        $prefetched = false
+        assert_nothing_raised do
+            trans.evaluate
         end
+
+        assert_equal(true, $prefetched, "evaluate did not call prefetch")
+    end
+
+    def test_refreshes_generate_events
+        path = tempfile()
+        firstpath = tempfile()
+        secondpath = tempfile()
+        file = Puppet::Type.newfile(:title => "file", :path => path, :content => "yayness")
+        first = Puppet::Type.newexec(:title => "first",
+                                     :command => "/bin/echo first > #{firstpath}",
+                                     :subscribe => [:file, path],
+                                     :refreshonly => true
+        )
+        second = Puppet::Type.newexec(:title => "second",
+                                     :command => "/bin/echo second > #{secondpath}",
+                                     :subscribe => [:exec, "first"],
+                                     :refreshonly => true
+        )
+
+        assert_apply(file, first, second)
+
+        assert(FileTest.exists?(secondpath), "Refresh did not generate an event")
     end
 
     unless %x{groups}.chomp.split(/ /).length > 1
@@ -110,18 +223,6 @@ class TestTransactions < Test::Unit::TestCase
         }
     end
 
-    def newservice
-        assert_nothing_raised() {
-            return Puppet.type(:service).create(
-                :name => "sleeper",
-                :type => "init",
-                :path => File.join($puppetbase,"examples/root/etc/init.d"),
-                :hasstatus => true,
-                :check => [:ensure]
-            )
-        }
-    end
-
     def newexec(file)
         assert_nothing_raised() {
             return Puppet.type(:exec).create(
@@ -137,7 +238,7 @@ class TestTransactions < Test::Unit::TestCase
         transaction = nil
         file = newfile()
 
-        states = {}
+        properties = {}
         check = [:group,:mode]
         file[:check] = check
 
@@ -146,9 +247,9 @@ class TestTransactions < Test::Unit::TestCase
         }
 
         assert_nothing_raised() {
-            check.each { |state|
-                assert(file[state])
-                states[state] = file[state]
+            check.each { |property|
+                assert(file[property])
+                properties[property] = file[property]
             }
         }
 
@@ -174,33 +275,13 @@ class TestTransactions < Test::Unit::TestCase
         assert_nothing_raised() {
             file.retrieve
         }
-        states.each { |state,value|
+        properties.each { |property,value|
             assert_equal(
-                value,file.is(state), "File %s remained %s" % [state, file.is(state)]
+                value,file.is(property), "File %s remained %s" % [property, file.is(property)]
             )
         }
     end
 
-    # start a service, and then roll the modification back
-    # Disabled, because it wasn't really worth the effort.
-    def disabled_test_servicetrans
-        transaction = nil
-        service = newservice()
-
-        component = newcomp("service",service)
-
-        assert_nothing_raised() {
-            service[:ensure] = 1
-        }
-        service.retrieve
-        assert(service.insync?, "Service did not start")
-        system("ps -ef | grep ruby")
-        trans = assert_events([:service_started], component)
-        service.retrieve
-
-        assert_rollback_events(trans, [:service_stopped], "service")
-    end
-
     # test that services are correctly restarted and that work is done
     # in the right order
     def test_refreshing
@@ -208,9 +289,12 @@ class TestTransactions < Test::Unit::TestCase
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness")
         exec = newexec(execfile)
-        states = {}
+        properties = {}
         check = [:group,:mode]
         file[:check] = check
+        file[:group] = @groups[0]
+
+        assert_apply(file)
 
         @@tmpfiles << execfile
 
@@ -225,14 +309,14 @@ class TestTransactions < Test::Unit::TestCase
             exec.retrieve
         }
 
-        check.each { |state|
-            states[state] = file[state]
+        check.each { |property|
+            properties[property] = file[property]
         }
         assert_nothing_raised() {
             file[:mode] = "755"
         }
 
-        trans = assert_events([:file_changed], component)
+        trans = assert_events([:file_changed, :triggered], component)
 
         assert(FileTest.exists?(execfile), "Execfile does not exist")
         File.unlink(execfile)
@@ -240,19 +324,23 @@ class TestTransactions < Test::Unit::TestCase
             file[:group] = @groups[1]
         }
 
-        trans = assert_events([:file_changed], component)
+        trans = assert_events([:file_changed, :triggered], component)
         assert(FileTest.exists?(execfile), "Execfile does not exist")
     end
 
-    def test_refreshAcrossTwoComponents
+    # Verify that one component requiring another causes the contained
+    # resources in the requiring component to get refreshed.
+    def test_refresh_across_two_components
         transaction = nil
         file = newfile()
         execfile = File.join(tmpdir(), "exectestingness2")
         @@tmpfiles << execfile
         exec = newexec(execfile)
-        states = {}
+        properties = {}
         check = [:group,:mode]
         file[:check] = check
+        file[:group] = @groups[0]
+        assert_apply(file)
 
         fcomp = newcomp("file",file)
         ecomp = newcomp("exec",exec)
@@ -261,7 +349,7 @@ class TestTransactions < Test::Unit::TestCase
 
         # 'subscribe' expects an array of arrays
         #component[:require] = [[file.class.name,file.name]]
-        ecomp[:subscribe] = [[fcomp.class.name,fcomp.name]]
+        ecomp[:subscribe] = fcomp
         exec[:refreshonly] = true
 
         trans = assert_events([], component)
@@ -271,8 +359,7 @@ class TestTransactions < Test::Unit::TestCase
             file[:mode] = "755"
         }
 
-        trans = assert_events([:file_changed, :file_changed], component)
-
+        trans = assert_events([:file_changed, :file_changed, :triggered], component)
     end
 
     # Make sure that multiple subscriptions get triggered.
@@ -311,25 +398,29 @@ class TestTransactions < Test::Unit::TestCase
             :path => path,
             :ensure => "file"
         )
-        svc = Puppet.type(:service).create(
-            :name => "thisservicedoesnotexist",
-            :subscribe => [:file, path]
+        exec1 = Puppet.type(:exec).create(
+            :path => ENV["PATH"],
+            :command => "touch /this/cannot/possibly/exist",
+            :logoutput => true,
+            :refreshonly => true,
+            :subscribe => file,
+            :title => "one"
         )
-        exec = Puppet.type(:exec).create(
+        exec2 = Puppet.type(:exec).create(
             :path => ENV["PATH"],
             :command => "touch %s" % newfile,
             :logoutput => true,
             :refreshonly => true,
-            :subscribe => [:file, path]
+            :subscribe => [file, exec1],
+            :title => "two"
         )
 
-        assert_apply(file, svc, exec)
-        assert(FileTest.exists?(path), "File did not get created")
+        assert_apply(file, exec1, exec2)
         assert(FileTest.exists?(newfile), "Refresh file did not get created")
     end
 
     # Make sure that unscheduled and untagged objects still respond to events
-    def test_unscheduledanduntaggedresponse
+    def test_unscheduled_and_untagged_response
         Puppet::Type.type(:schedule).mkdefaultschedules
         Puppet[:ignoreschedules] = false
         file = Puppet.type(:file).create(
@@ -359,7 +450,7 @@ class TestTransactions < Test::Unit::TestCase
 
         file[:content] = "some content"
 
-        assert_events([:file_changed], comp)
+        assert_events([:file_changed, :triggered], comp)
         assert(FileTest.exists?(fname), "File did not get recreated")
 
         # Now remove it, so it can get created again
@@ -377,30 +468,685 @@ class TestTransactions < Test::Unit::TestCase
 
         assert(! file.insync?, "Uh, file is in sync?")
 
-        assert_events([:file_changed], comp)
+        assert_events([:file_changed, :triggered], comp)
         assert(FileTest.exists?(fname), "File did not get recreated")
     end
 
     def test_failed_reqs_mean_no_run
         exec = Puppet::Type.type(:exec).create(
             :command => "/bin/mkdir /this/path/cannot/possibly/exit",
-            :name => "mkdir"
+            :title => "mkdir"
         )
 
-        file = Puppet::Type.type(:file).create(
+        file1 = Puppet::Type.type(:file).create(
+            :title => "file1",
             :path => tempfile(),
-            :require => ["exec", "mkdir"],
+            :require => exec,
             :ensure => :file
         )
 
-        comp = newcomp(exec, file)
+        file2 = Puppet::Type.type(:file).create(
+            :title => "file2",
+            :path => tempfile(),
+            :require => file1,
+            :ensure => :file
+        )
+
+        comp = newcomp(exec, file1, file2)
 
         comp.finalize
 
         assert_apply(comp)
 
-        assert(! FileTest.exists?(file[:path]),
+        assert(! FileTest.exists?(file1[:path]),
             "File got created even tho its dependency failed")
+        assert(! FileTest.exists?(file2[:path]),
+            "File got created even tho its deep dependency failed")
+    end
+    end
+    
+    def f(n)
+        Puppet::Type.type(:file)["/tmp/#{n.to_s}"]
+    end
+    
+    def test_relationship_graph
+        one, two, middle, top = mktree
+        
+        {one => two, "f" => "c", "h" => middle}.each do |source, target|
+            if source.is_a?(String)
+                source = f(source)
+            end
+            if target.is_a?(String)
+                target = f(target)
+            end
+            target[:require] = source
+        end
+        
+        trans = Puppet::Transaction.new(top)
+        
+        graph = nil
+        assert_nothing_raised do
+            graph = trans.relationship_graph
+        end
+        
+        assert_instance_of(Puppet::PGraph, graph,
+            "Did not get relationship graph")
+        
+        # Make sure all of the components are gone
+        comps = graph.vertices.find_all { |v| v.is_a?(Puppet::Type::Component)}
+        assert(comps.empty?, "Deps graph still contains components %s" %
+            comps.collect { |c| c.ref }.join(","))
+        
+        assert_equal([], comps, "Deps graph still contains components")
+        
+        # It must be reversed because of how topsort works
+        sorted = graph.topsort.reverse
+        
+        # Now make sure the appropriate edges are there and are in the right order
+        assert(graph.dependents(f(:f)).include?(f(:c)),
+            "c not marked a dep of f")
+        assert(sorted.index(f(:c)) < sorted.index(f(:f)),
+            "c is not before f")
+            
+        one.each do |o|
+            two.each do |t|
+                assert(graph.dependents(o).include?(t),
+                    "%s not marked a dep of %s" % [t.ref, o.ref])
+                assert(sorted.index(t) < sorted.index(o),
+                    "%s is not before %s" % [t.ref, o.ref])
+            end
+        end
+        
+        trans.resources.leaves(middle).each do |child|
+            assert(graph.dependents(f(:h)).include?(child),
+                "%s not marked a dep of h" % [child.ref])
+            assert(sorted.index(child) < sorted.index(f(:h)),
+                "%s is not before h" % child.ref)
+        end
+        
+        # Lastly, make sure our 'g' vertex made it into the relationship
+        # graph, since it's not involved in any relationships.
+        assert(graph.vertex?(f(:g)),
+            "Lost vertexes with no relations")
+
+        # Now make the reversal graph and make sure all of the vertices made it into that
+        reverse = graph.reversal
+        %w{a b c d e f g h}.each do |letter|
+            file = f(letter)
+            assert(reverse.vertex?(file), "%s did not make it into reversal" % letter)
+        end
+    end
+    
+    # Test pre-evaluation generation
+    def test_generate
+        mkgenerator() do
+            def generate
+                ret = []
+                if title.length > 1
+                    ret << self.class.create(:title => title[0..-2])
+                else
+                    return nil
+                end
+                ret
+            end
+        end
+        
+        yay = Puppet::Type.newgenerator :title => "yay"
+        rah = Puppet::Type.newgenerator :title => "rah"
+        comp = newcomp(yay, rah)
+        trans = comp.evaluate
+        
+        assert_nothing_raised do
+            trans.generate
+        end
+        
+        %w{ya ra y r}.each do |name|
+            assert(trans.resources.vertex?(Puppet::Type.type(:generator)[name]),
+                "Generated %s was not a vertex" % name)
+            assert($finished.include?(name), "%s was not finished" % name)
+        end
+        
+        # Now make sure that cleanup gets rid of those generated types.
+        assert_nothing_raised do
+            trans.cleanup
+        end
+        
+        %w{ya ra y r}.each do |name|
+            assert(!trans.resources.vertex?(Puppet::Type.type(:generator)[name]),
+                "Generated vertex %s was not removed from graph" % name)
+            assert_nil(Puppet::Type.type(:generator)[name],
+                "Generated vertex %s was not removed from class" % name)
+        end
+    end
+    
+    # Test mid-evaluation generation.
+    def test_eval_generate
+        $evaluated = []
+        cleanup { $evaluated = nil }
+        type = mkreducer() do
+            def evaluate
+                $evaluated << self.title
+                return []
+            end
+        end
+
+        yay = Puppet::Type.newgenerator :title => "yay"
+        rah = Puppet::Type.newgenerator :title => "rah", :subscribe => yay
+        comp = newcomp(yay, rah)
+        trans = comp.evaluate
+        
+        trans.prepare
+        
+        # Now apply the resources, and make sure they appropriately generate
+        # things.
+        assert_nothing_raised("failed to apply yay") do
+            trans.eval_resource(yay)
+        end
+        ya = type["ya"]
+        assert(ya, "Did not generate ya")
+        assert(trans.relgraph.vertex?(ya),
+            "Did not add ya to rel_graph")
+        
+        # Now make sure the appropriate relationships were added
+        assert(trans.relgraph.edge?(yay, ya),
+            "parent was not required by child")
+        assert(! trans.relgraph.edge?(ya, rah),
+            "generated child ya inherited depencency on rah")
+        
+        # Now make sure it in turn eval_generates appropriately
+        assert_nothing_raised("failed to apply yay") do
+            trans.eval_resource(type["ya"])
+        end
+
+        %w{y}.each do |name|
+            res = type[name]
+            assert(res, "Did not generate %s" % name)
+            assert(trans.relgraph.vertex?(res),
+                "Did not add %s to rel_graph" % name)
+            assert($finished.include?("y"), "y was not finished")
+        end
+        
+        assert_nothing_raised("failed to eval_generate with nil response") do
+            trans.eval_resource(type["y"])
+        end
+        assert(trans.relgraph.edge?(yay, ya), "no edge was created for ya => yay")
+        
+        assert_nothing_raised("failed to apply rah") do
+            trans.eval_resource(rah)
+        end
+
+        ra = type["ra"]
+        assert(ra, "Did not generate ra")
+        assert(trans.relgraph.vertex?(ra),
+            "Did not add ra to rel_graph" % name)
+        assert($finished.include?("ra"), "y was not finished")
+        
+        # Now make sure this generated resource has the same relationships as
+        # the generating resource
+        assert(! trans.relgraph.edge?(yay, ra),
+           "rah passed its dependencies on to its children")
+        assert(! trans.relgraph.edge?(ya, ra),
+            "children have a direct relationship")
+        
+        # Now make sure that cleanup gets rid of those generated types.
+        assert_nothing_raised do
+            trans.cleanup
+        end
+        
+        %w{ya ra y r}.each do |name|
+            assert(!trans.relgraph.vertex?(type[name]),
+                "Generated vertex %s was not removed from graph" % name)
+            assert_nil(type[name],
+                "Generated vertex %s was not removed from class" % name)
+        end
+        
+        # Now, start over and make sure that everything gets evaluated.
+        trans = comp.evaluate
+        $evaluated.clear
+        assert_nothing_raised do
+            trans.evaluate
+        end
+        
+        assert_equal(%w{yay ya y rah ra r}, $evaluated,
+            "Not all resources were evaluated or not in the right order")
+    end
+    
+    def test_tags
+        res = Puppet::Type.newfile :path => tempfile()
+        comp = newcomp(res)
+        
+        # Make sure they default to none
+        assert_equal([], comp.evaluate.tags)
+        
+        # Make sure we get the main tags
+        Puppet[:tags] = %w{this is some tags}
+        assert_equal(%w{this is some tags}, comp.evaluate.tags)
+        
+        # And make sure they get processed correctly
+        Puppet[:tags] = ["one", "two,three", "four"]
+        assert_equal(%w{one two three four}, comp.evaluate.tags)
+        
+        # lastly, make sure we can override them
+        trans = comp.evaluate
+        trans.tags = ["one", "two,three", "four"]
+        assert_equal(%w{one two three four}, comp.evaluate.tags)
+    end
+    
+    def test_tagged?
+        res = Puppet::Type.newfile :path => tempfile()
+        comp = newcomp(res)
+        trans = comp.evaluate
+        
+        assert(trans.tagged?(res), "tagged? defaulted to false")
+        
+        # Now set some tags
+        trans.tags = %w{some tags}
+        
+        # And make sure it's false
+        assert(! trans.tagged?(res), "matched invalid tags")
+        
+        # Set ignoretags and make sure it sticks
+        trans.ignoretags = true
+        assert(trans.tagged?(res), "tags were not ignored")
+        
+        # Now make sure we actually correctly match tags
+        res[:tag] = "mytag"
+        trans.ignoretags = false
+        trans.tags = %w{notag}
+        
+        assert(! trans.tagged?(res), "tags incorrectly matched")
+        
+        trans.tags = %w{mytag yaytag}
+        assert(trans.tagged?(res), "tags should have matched")
+    end
+    
+    # Make sure changes generated by eval_generated resources have proxies
+    # set to the top-level resource.
+    def test_proxy_resources
+        type = mkreducer do
+            def evaluate
+                return Puppet::PropertyChange.new(Fakeprop.new(
+                    :path => :path, :is => :is, :should => :should, :name => self.name, :parent => "a parent"))
+            end
+        end
+        
+        resource = type.create :name => "test"
+        comp = newcomp(resource)
+        trans = comp.evaluate
+        trans.prepare
+
+        assert_nothing_raised do
+            trans.eval_resource(resource)
+        end
+        
+        changes = trans.instance_variable_get("@changes")
+        
+        assert(changes.length > 0, "did not get any changes")
+        
+        changes.each do |change|
+            assert_equal(resource, change.source, "change did not get proxy set correctly")
+        end
+    end
+    
+    # Make sure changes in contained files still generate callback events.
+    def test_generated_callbacks
+        dir = tempfile()
+        maker = tempfile()
+        Dir.mkdir(dir)
+        file = File.join(dir, "file")
+        File.open(file, "w") { |f| f.puts "" }
+        File.chmod(0644, file)
+        File.chmod(0755, dir) # So only the child file causes a change
+        
+        dirobj = Puppet::Type.type(:file).create :mode => "755", :recurse => true, :path => dir
+        exec = Puppet::Type.type(:exec).create :title => "make",
+            :command => "touch #{maker}", :path => ENV['PATH'], :refreshonly => true,
+            :subscribe => dirobj
+        
+        assert_apply(dirobj, exec)
+        assert(FileTest.exists?(maker), "Did not make callback file")
+    end
+
+    # Yay, this out to be fun.
+    def test_trigger
+        $triggered = []
+        cleanup { $triggered = nil }
+        trigger = Class.new do
+            attr_accessor :name
+            include Puppet::Util::Logging
+            def initialize(name)
+                @name = name
+            end
+            def ref
+                self.name
+            end
+            def refresh
+                $triggered << self.name
+            end
+
+            def to_s
+                self.name
+            end
+        end
+
+        # Make a graph with some stuff in it.
+        graph = Puppet::PGraph.new
+
+        # Add a non-triggering edge.
+        a = trigger.new(:a)
+        b = trigger.new(:b)
+        c = trigger.new(:c)
+        nope = Puppet::Relationship.new(a, b)
+        yep = Puppet::Relationship.new(a, c, {:callback => :refresh})
+        graph.add_edge!(nope)
+
+        # And a triggering one.
+        graph.add_edge!(yep)
+
+        # Create our transaction
+        trans = Puppet::Transaction.new(graph)
+
+        # Set the non-triggering on
+        assert_nothing_raised do
+            trans.set_trigger(nope)
+        end
+
+        assert(! trans.targeted?(b), "b is incorrectly targeted")
+
+        # Now set the other
+        assert_nothing_raised do
+            trans.set_trigger(yep)
+        end
+        assert(trans.targeted?(c), "c is not targeted")
+
+        # Now trigger our three resources
+        assert_nothing_raised do
+            assert_nil(trans.trigger(a), "a somehow triggered something")
+        end
+        assert_nothing_raised do
+            assert_nil(trans.trigger(b), "b somehow triggered something")
+        end
+        assert_equal([], $triggered,"got something in triggered")
+        result = nil
+        assert_nothing_raised do
+            result = trans.trigger(c)
+        end
+        assert(result, "c did not trigger anything")
+        assert_instance_of(Array, result)
+        event = result.shift
+        assert_instance_of(Puppet::Event, event)
+        assert_equal(:triggered, event.event, "event was not set correctly")
+        assert_equal(c, event.source, "source was not set correctly")
+        assert_equal(trans, event.transaction, "transaction was not set correctly")
+
+        assert(trans.triggered?(c, :refresh),
+            "Transaction did not store the trigger")
     end
+
+    def test_graph
+        Puppet.config.use(:puppet)
+        # Make a graph
+        graph = Puppet::PGraph.new
+        graph.add_edge!("a", "b")
+
+        # Create our transaction
+        trans = Puppet::Transaction.new(graph)
+
+        assert_nothing_raised do
+            trans.graph(graph, :testing)
+        end
+
+        dotfile = File.join(Puppet[:graphdir], "testing.dot")
+        assert(! FileTest.exists?(dotfile), "Enabled graphing even tho disabled")
+
+        # Now enable graphing
+        Puppet[:graph] = true
+
+        assert_nothing_raised do
+            trans.graph(graph, :testing)
+        end
+        assert(FileTest.exists?(dotfile), "Did not create graph.")
+    end
+
+    def test_created_graphs
+        FileUtils.mkdir_p(Puppet[:graphdir])
+        file = Puppet::Type.newfile(:path => tempfile, :content => "yay")
+        exec = Puppet::Type.type(:exec).create(:command => "echo yay", :path => ENV['PATH'],
+            :require => file)
+
+        Puppet[:graph] = true
+        assert_apply(file, exec)
+
+        %w{resources relationships expanded_relationships}.each do |name|
+            file = File.join(Puppet[:graphdir], "%s.dot" % name)
+            assert(FileTest.exists?(file), "graph for %s was not created" % name)
+        end
+    end
+    
+    def test_set_target
+        file = Puppet::Type.newfile(:path => tempfile(), :content => "yay")
+        exec1 = Puppet::Type.type(:exec).create :command => "/bin/echo exec1"
+        exec2 = Puppet::Type.type(:exec).create :command => "/bin/echo exec2"
+        trans = Puppet::Transaction.new(newcomp(file, exec1, exec2))
+        
+        # First try it with an edge that has no callback
+        edge = Puppet::Relationship.new(file, exec1)
+        assert_nothing_raised { trans.set_trigger(edge) }
+        assert(! trans.targeted?(exec1), "edge with no callback resulted in a target")
+        
+        # Now with an edge that has an unsupported callback
+        edge = Puppet::Relationship.new(file, exec1, :callback => :nosuchmethod, :event => :ALL_EVENTS)
+        assert_nothing_raised { trans.set_trigger(edge) }
+        assert(! trans.targeted?(exec1), "edge with invalid callback resulted in a target")
+        
+        # Lastly, with an edge with a supported callback
+        edge = Puppet::Relationship.new(file, exec1, :callback => :refresh, :event => :ALL_EVENTS)
+        assert_nothing_raised { trans.set_trigger(edge) }
+        assert(trans.targeted?(exec1), "edge with valid callback did not result in a target")
+    end
+    
+    # Testing #401 -- transactions are calling refresh() on classes that don't support it.
+    def test_callback_availability
+        $called = []
+        klass = Puppet::Type.newtype(:norefresh) do
+            newparam(:name, :namevar => true) {}
+            def method_missing(method, *args)
+                $called << method
+            end
+        end
+        cleanup do
+            $called = nil
+            Puppet::Type.rmtype(:norefresh)
+        end
+
+        file = Puppet::Type.newfile :path => tempfile(), :content => "yay"
+        one = klass.create :name => "one", :subscribe => file
+        
+        assert_apply(file, one)
+        
+        assert(! $called.include?(:refresh), "Called refresh when it wasn't set as a method")
+    end
+
+    # Testing #437 - cyclic graphs should throw failures.
+    def test_fail_on_cycle
+        one = Puppet::Type.type(:exec).create(:name => "/bin/echo one")
+        two = Puppet::Type.type(:exec).create(:name => "/bin/echo two")
+        one[:require] = two
+        two[:require] = one
+
+        trans = newcomp(one, two).evaluate
+        assert_raise(Puppet::Error) do
+            trans.prepare
+        end
+    end
+
+    def test_errors_during_generation
+        type = Puppet::Type.newtype(:failer) do
+            newparam(:name) {}
+            def eval_generate
+                raise ArgumentError, "Invalid value"
+            end
+            def generate
+                raise ArgumentError, "Invalid value"
+            end
+        end
+        cleanup { Puppet::Type.rmtype(:failer) }
+
+        obj = type.create(:name => "testing")
+
+        assert_apply(obj)
+    end
+    
+    def test_self_refresh_causes_triggering
+        type = Puppet::Type.newtype(:refresher, :self_refresh => true) do
+            attr_accessor :refreshed, :testing
+            newparam(:name) {}
+            newproperty(:testing) do
+                def sync
+                    self.is = self.should
+                    :ran_testing
+                end
+            end
+            def refresh
+                @refreshed = true
+            end
+        end
+        cleanup { Puppet::Type.rmtype(:refresher)}
+        
+        obj = type.create(:name => "yay", :testing => "cool")
+        
+        assert(! obj.insync?, "fake object is already in sync")
+        
+        # Now make sure it gets refreshed when the change happens
+        assert_apply(obj)
+        assert(obj.refreshed, "object was not refreshed during transaction")
+    end
+    
+    # Testing #433
+    def test_explicit_dependencies_beat_automatic
+        # Create a couple of different resource sets that have automatic relationships and make sure the manual relationships win
+        rels = {}
+        # First users and groups
+        group = Puppet::Type.type(:group).create(:name => nonrootgroup.name, :ensure => :present)
+        user = Puppet::Type.type(:user).create(:name => nonrootuser.name, :ensure => :present, :gid => group.title)
+        
+        # Now add the explicit relationship
+        group[:require] = user
+        rels[group] = user
+        # Now files
+        d = tempfile()
+        f = File.join(d, "file")
+        file = Puppet::Type.newfile(:path => f, :content => "yay")
+        dir = Puppet::Type.newfile(:path => d, :ensure => :directory, :require => file)
+        
+        rels[dir] = file
+        rels.each do |after, before|
+            comp = newcomp(before, after)
+            trans = comp.evaluate
+            str = "from %s to %s" % [before, after]
+        
+            assert_nothing_raised("Failed to create graph %s" % str) do
+                trans.prepare
+            end
+        
+            graph = trans.relgraph
+            assert(graph.edge?(before, after), "did not create manual relationship %s" % str)
+            assert(! graph.edge?(after, before), "created automatic relationship %s" % str)
+        end
+    end
+
+    def test_labeled_deps_beat_unlabeled
+        one = Puppet::Type.type(:exec).create :command => "/bin/echo one"
+        two = Puppet::Type.type(:exec).create :command => "/bin/echo two"
+
+        one[:require] = two
+        one[:subscribe] = two
+
+        comp = newcomp(one, two)
+        trans = Puppet::Transaction.new(comp)
+        graph = trans.relationship_graph
+
+        label = graph.edge_label(two, one)
+        assert(label, "require beat subscribe")
+        assert_equal(:refresh, label[:callback],
+            "did not get correct callback from subscribe")
+
+        one.delete(:require)
+        one.delete(:subscribe)
+
+        two[:before] = one
+        two[:notify] = one
+
+        trans = Puppet::Transaction.new(comp)
+        graph = trans.relationship_graph
+
+        label = graph.edge_label(two, one)
+        assert(label, "before beat notify")
+        assert_equal(:refresh, label[:callback],
+            "did not get correct callback from notify")
+    end
+
+    # #542 - make sure resources in noop mode still notify their resources,
+    # so that users know if a service will get restarted.
+    def test_noop_with_notify
+        path = tempfile
+        epath = tempfile
+        spath = tempfile
+        file = Puppet::Type.newfile(:path => path, :ensure => :file,
+            :title => "file")
+        exec = Puppet::Type.type(:exec).create(:command => "touch %s" % epath,
+            :path => ENV["PATH"], :subscribe => file, :refreshonly => true,
+            :title => 'exec1')
+        exec2 = Puppet::Type.type(:exec).create(:command => "touch %s" % spath,
+            :path => ENV["PATH"], :subscribe => exec, :refreshonly => true,
+            :title => 'exec2')
+
+        Puppet[:noop] = true
+
+        assert(file.noop, "file not in noop")
+        assert(exec.noop, "exec not in noop")
+
+        @logs.clear
+        assert_apply(file, exec, exec2)
+
+        assert(! FileTest.exists?(path), "Created file in noop")
+        assert(! FileTest.exists?(epath), "Executed exec in noop")
+        assert(! FileTest.exists?(spath), "Executed second exec in noop")
+
+        assert(@logs.detect { |l|
+            l.message =~ /should be/  and l.source == file.property(:ensure).path},
+                "did not log file change")
+        assert(@logs.detect { |l|
+            l.message =~ /Would have/ and l.source == exec.path },
+                "did not log first exec trigger")
+        assert(@logs.detect { |l|
+            l.message =~ /Would have/ and l.source == exec2.path },
+                "did not log second exec trigger")
+    end
+
+    def test_only_stop_purging_with_relations
+        files = []
+        paths = []
+        3.times do |i|
+            path = tempfile
+            paths << path
+            file = Puppet::Type.newfile(:path => path, :ensure => :absent,
+                :backup => false, :title => "file%s" % i)
+            File.open(path, "w") { |f| f.puts "" }
+            files << file
+        end
+
+        files[0][:ensure] = :file
+        files[0][:require] = files[1..2]
+
+        # Mark the second as purging
+        files[1].purging
+
+        assert_apply(*files)
+
+        assert(FileTest.exists?(paths[1]), "Deleted required purging file")
+        assert(! FileTest.exists?(paths[2]), "Did not delete non-purged file")
     end
 end
+
+# $Id: transactions.rb 2372 2007-03-30 00:47:03Z luke $