puppet 0.24.9 → 0.25.0

data/test/other/report.rb

@@ -9,8 +9,8 @@ require 'puppettest'
 require 'puppettest/reporttesting'
 
 class TestReports < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::Reporttesting
+    include PuppetTest
+    include PuppetTest::Reporttesting
 
     def mkreport
         # First do some work
@@ -21,7 +21,7 @@ class TestReports < Test::Unit::TestCase
             # Make every third file
             File.open(file, "w") { |f| f.puts "" } if i % 3 == 0
 
-            objects << Puppet::Type.type(:file).create(
+            objects << Puppet::Type.type(:file).new(
                 :path => file,
                 :ensure => "file"
             )
@@ -44,7 +44,7 @@ class TestReports < Test::Unit::TestCase
         }
 
         # Now make a file for testing logging
-        file = Puppet::Type.type(:file).create(:path => tempfile(), :ensure => "file")
+        file = Puppet::Type.type(:file).new(:path => tempfile(), :ensure => "file")
         file.finish
 
         log = nil
@@ -80,10 +80,10 @@ class TestReports < Test::Unit::TestCase
     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.settings.use(:main, :reporting)
+        Puppet.settings.use(:main, :puppetmasterd)
 
         3.times { |i|
             log = Puppet.warning("Report test message %s" % i)
@@ -97,10 +97,7 @@ class TestReports < Test::Unit::TestCase
 
         yaml = YAML.dump(report)
 
-        file = nil
-        assert_nothing_raised {
-            file = report.process
-        }
+        file = report.process
 
         assert(FileTest.exists?(file), "report file did not get created")
         assert_equal(yaml, File.read(file), "File did not get written")
@@ -146,31 +143,31 @@ class TestReports < Test::Unit::TestCase
     else
     $stderr.puts "Install RRD for metric reporting tests"
     end
-    
+
     def test_tagmail_parsing
         report = Object.new
         report.extend(Puppet::Reports.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::Reports.report(:tagmail))
@@ -182,27 +179,27 @@ class TestReports < Test::Unit::TestCase
             "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::Reports.report(:tagmail))
-        
+
         {
             [%w{abuse@domain.com}, %w{all}, []] => list,
             [%w{abuse@domain.com}, %w{all}, %w{three}] => list[0..1],
@@ -215,7 +212,7 @@ class TestReports < Test::Unit::TestCase
             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

data/test/other/transactions.rb

@@ -13,6 +13,8 @@ class TestTransactions < Test::Unit::TestCase
     include PuppetTest::Support::Resources
     include PuppetTest::Support::Utils
     class Fakeprop <Puppet::Property
+        initvars()
+
         attr_accessor :path, :is, :should, :name
         def should_to_s(value)
             value.to_s
@@ -23,13 +25,20 @@ class TestTransactions < Test::Unit::TestCase
         def info(*args)
             false
         end
+
+        def set(value)
+            # eh
+        end
+
+        def log(msg)
+        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)
@@ -43,28 +52,28 @@ class TestTransactions < Test::Unit::TestCase
         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])
+                    ret << self.class.new(:title => title[0..-2])
                 else
                     return nil
                 end
                 ret
             end
         end
-        
+
         if block
             type.class_eval(&block)
         end
-        
+
         return type
     end
 
@@ -72,11 +81,11 @@ class TestTransactions < Test::Unit::TestCase
         path1 = tempfile()
         path2 = tempfile()
         objects = []
-        objects << Puppet::Type.type(:file).create(
+        objects << Puppet::Type.type(:file).new(
             :path => path1,
             :content => "yayness"
         )
-        objects << Puppet::Type.type(:file).create(
+        objects << Puppet::Type.type(:file).new(
             :path => path2,
             :content => "booness"
         )
@@ -117,7 +126,7 @@ class TestTransactions < Test::Unit::TestCase
         type = Puppet::Type.newtype(name) do
             newparam(:name) {}
         end
-        
+
         cleanup do
             Puppet::Type.rmtype(name)
         end
@@ -130,8 +139,8 @@ class TestTransactions < Test::Unit::TestCase
         end
 
         # Now create an instance
-        inst = type.create :name => "yay"
-        
+        inst = type.new :name => "yay"
+
         # Create a transaction
         trans = Puppet::Transaction.new(mk_catalog(inst))
 
@@ -155,15 +164,15 @@ class TestTransactions < Test::Unit::TestCase
         path = tempfile()
         firstpath = tempfile()
         secondpath = tempfile()
-        file = Puppet::Type.type(:file).create(:title => "file", :path => path, :content => "yayness")
-        first = Puppet::Type.newexec(:title => "first",
+        file = Puppet::Type.type(:file).new(:title => "file", :path => path, :content => "yayness")
+        first = Puppet::Type.type(:exec).new(:title => "first",
                                      :command => "/bin/echo first > #{firstpath}",
-                                     :subscribe => [:file, path],
+                                     :subscribe => Puppet::Resource::Reference.new(:file, path),
                                      :refreshonly => true
         )
-        second = Puppet::Type.newexec(:title => "second",
+        second = Puppet::Type.type(:exec).new(:title => "second",
                                      :command => "/bin/echo second > #{secondpath}",
-                                     :subscribe => [:exec, "first"],
+                                     :subscribe => Puppet::Resource::Reference.new(:exec, "first"),
                                      :refreshonly => true
         )
 
@@ -219,13 +228,13 @@ class TestTransactions < Test::Unit::TestCase
 
         hash[:name] = tmpfile
         assert_nothing_raised() {
-            return Puppet.type(:file).create(hash)
+            return Puppet::Type.type(:file).new(hash)
         }
     end
 
     def newexec(file)
         assert_nothing_raised() {
-            return Puppet.type(:exec).create(
+            return Puppet::Type.type(:exec).new(
                 :name => "touch %s" % file,
                 :path => "/bin:/usr/bin:/sbin:/usr/sbin",
                 :returns => 0
@@ -301,7 +310,7 @@ class TestTransactions < Test::Unit::TestCase
         @@tmpfiles << execfile
 
         # 'subscribe' expects an array of arrays
-        exec[:subscribe] = [[file.class.name,file.name]]
+        exec[:subscribe] = Puppet::Resource::Reference.new(file.class.name,file.name)
         exec[:refreshonly] = true
 
         assert_nothing_raised() {
@@ -346,13 +355,13 @@ class TestTransactions < Test::Unit::TestCase
         file[:group] = @groups[0]
         assert_apply(file)
 
-        config = Puppet::Node::Catalog.new
-        fcomp = Puppet::Type.type(:component).create(:name => "file")
+        config = Puppet::Resource::Catalog.new
+        fcomp = Puppet::Type.type(:component).new(:name => "file")
         config.add_resource fcomp
         config.add_resource file
         config.add_edge(fcomp, file)
 
-        ecomp = Puppet::Type.type(:component).create(:name => "exec")
+        ecomp = Puppet::Type.type(:component).new(:name => "exec")
         config.add_resource ecomp
         config.add_resource exec
         config.add_edge(ecomp, exec)
@@ -377,21 +386,21 @@ class TestTransactions < Test::Unit::TestCase
         path = tempfile()
         file1 = tempfile()
         file2 = tempfile()
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => path,
             :ensure => "file"
         )
-        exec1 = Puppet.type(:exec).create(
+        exec1 = Puppet::Type.type(:exec).new(
             :path => ENV["PATH"],
             :command => "touch %s" % file1,
             :refreshonly => true,
-            :subscribe => [:file, path]
+            :subscribe => Puppet::Resource::Reference.new(:file, path)
         )
-        exec2 = Puppet.type(:exec).create(
+        exec2 = Puppet::Type.type(:exec).new(
             :path => ENV["PATH"],
             :command => "touch %s" % file2,
             :refreshonly => true,
-            :subscribe => [:file, path]
+            :subscribe => Puppet::Resource::Reference.new(:file, path)
         )
 
         assert_apply(file, exec1, exec2)
@@ -404,11 +413,11 @@ class TestTransactions < Test::Unit::TestCase
     def test_failedrefreshes
         path = tempfile()
         newfile = tempfile()
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :path => path,
             :ensure => "file"
         )
-        exec1 = Puppet.type(:exec).create(
+        exec1 = Puppet::Type.type(:exec).new(
             :path => ENV["PATH"],
             :command => "touch /this/cannot/possibly/exist",
             :logoutput => true,
@@ -416,7 +425,7 @@ class TestTransactions < Test::Unit::TestCase
             :subscribe => file,
             :title => "one"
         )
-        exec2 = Puppet.type(:exec).create(
+        exec2 = Puppet::Type.type(:exec).new(
             :path => ENV["PATH"],
             :command => "touch %s" % newfile,
             :logoutput => true,
@@ -433,18 +442,18 @@ class TestTransactions < Test::Unit::TestCase
     def test_unscheduled_and_untagged_response
         Puppet::Type.type(:schedule).mkdefaultschedules
         Puppet[:ignoreschedules] = false
-        file = Puppet.type(:file).create(
+        file = Puppet::Type.type(:file).new(
             :name => tempfile(),
             :ensure => "file",
             :backup => false
         )
 
         fname = tempfile()
-        exec = Puppet.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :name => "touch %s" % fname,
             :path => "/usr/bin:/bin",
             :schedule => "monthly",
-            :subscribe => ["file", file.name]
+            :subscribe => Puppet::Resource::Reference.new("file", file.name)
         )
 
         config = mk_catalog(file, exec)
@@ -484,19 +493,19 @@ class TestTransactions < Test::Unit::TestCase
     end
 
     def test_failed_reqs_mean_no_run
-        exec = Puppet::Type.type(:exec).create(
+        exec = Puppet::Type.type(:exec).new(
             :command => "/bin/mkdir /this/path/cannot/possibly/exit",
             :title => "mkdir"
         )
 
-        file1 = Puppet::Type.type(:file).create(
+        file1 = Puppet::Type.type(:file).new(
             :title => "file1",
             :path => tempfile(),
             :require => exec,
             :ensure => :file
         )
 
-        file2 = Puppet::Type.type(:file).create(
+        file2 = Puppet::Type.type(:file).new(
             :title => "file2",
             :path => tempfile(),
             :require => file1,
@@ -513,208 +522,6 @@ class TestTransactions < Test::Unit::TestCase
             "File got created even tho its deep dependency failed")
     end
     end
-    
-    def test_relationship_graph
-        config = mktree
-
-        config.meta_def(:f) do |name|
-            self.resource("File[%s]" % name)
-        end
-        
-        {"one" => "two", "File[f]" => "File[c]", "File[h]" => "middle"}.each do |source_ref, target_ref|
-            source = config.resource(source_ref) or raise "Missing %s" % source_ref
-            target = config.resource(target_ref) or raise "Missing %s" % target_ref
-            target[:require] = source
-        end
-        
-        trans = Puppet::Transaction.new(config)
-        
-        graph = nil
-        assert_nothing_raised do
-            graph = trans.relationship_graph
-        end
-
-        assert_instance_of(Puppet::Node::Catalog, 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(config.f(:f)).include?(config.f(:c)),
-            "c not marked a dep of f")
-        assert(sorted.index(config.f(:c)) < sorted.index(config.f(:f)),
-            "c is not before f")
-            
-        config.resource("one").each do |o|
-            config.resource("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.catalog.leaves(config.resource("middle")).each do |child|
-            assert(graph.dependents(config.f(:h)).include?(child),
-                "%s not marked a dep of h" % [child.ref])
-            assert(sorted.index(child) < sorted.index(config.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?(config.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 = config.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"
-        config = mk_catalog(yay, rah)
-        trans = Puppet::Transaction.new(config)
-        
-        assert_nothing_raised do
-            trans.generate
-        end
-        
-        %w{ya ra y r}.each do |name|
-            assert(trans.catalog.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.catalog.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
-        config = mk_catalog(yay, rah)
-        trans = Puppet::Transaction.new(config)
-        
-        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.relationship_graph.vertex?(ya),
-            "Did not add ya to rel_graph")
-        
-        # Now make sure the appropriate relationships were added
-        assert(trans.relationship_graph.edge?(yay, ya),
-            "parent was not required by child")
-        assert(! trans.relationship_graph.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.relationship_graph.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.relationship_graph.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.relationship_graph.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.relationship_graph.edge?(yay, ra),
-           "rah passed its dependencies on to its children")
-        assert(! trans.relationship_graph.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.relationship_graph.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 = Puppet::Transaction.new(config)
-        $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
 
     # We need to generate resources before we prefetch them, else generated
     # resources that require prefetching don't work.
@@ -729,7 +536,7 @@ class TestTransactions < Test::Unit::TestCase
         trans.prepare
         return
 
-        resource = Puppet::Type.type(:file).create :ensure => :present, :path => tempfile()
+        resource = Puppet::Type.type(:file).new :ensure => :present, :path => tempfile()
         other_resource = mock 'generated'
         def resource.generate
             [other_resource]
@@ -738,17 +545,17 @@ class TestTransactions < Test::Unit::TestCase
 
         config = mk_catalog(yay, rah)
         trans = Puppet::Transaction.new(config)
-        
+
         assert_nothing_raised do
             trans.generate
         end
-        
+
         %w{ya ra y r}.each do |name|
             assert(trans.catalog.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
@@ -756,7 +563,7 @@ class TestTransactions < Test::Unit::TestCase
     end
 
     def test_ignore_tags?
-        config = Puppet::Node::Catalog.new
+        config = Puppet::Resource::Catalog.new
         config.host_config = true
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.ignore_tags?, "Ignoring tags when applying a host catalog")
@@ -765,10 +572,10 @@ class TestTransactions < Test::Unit::TestCase
         transaction = Puppet::Transaction.new(config)
         assert(transaction.ignore_tags?, "Not ignoring tags when applying a non-host catalog")
     end
-    
+
     def test_missing_tags?
         resource = stub 'resource', :tagged? => true
-        config = Puppet::Node::Catalog.new
+        config = Puppet::Resource::Catalog.new
 
         # Mark it as a host config so we don't care which test is first
         config.host_config = true
@@ -781,7 +588,7 @@ class TestTransactions < Test::Unit::TestCase
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when not running a host catalog")
 
-        # 
+        #
         config.host_config = true
         transaction = Puppet::Transaction.new(config)
         assert(! transaction.missing_tags?(resource), "Considered a resource to be missing tags when running a host catalog and all tags are present")
@@ -790,18 +597,18 @@ class TestTransactions < Test::Unit::TestCase
         resource.stubs :tagged? => false
         assert(transaction.missing_tags?(resource), "Considered a resource not to be missing tags when running a host catalog and tags are missing")
     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::Transaction::Change.new(Fakeprop.new(
-                    :path => :path, :is => :is, :should => :should, :name => self.name, :resource => "a parent"), :is)
+                    :path => :path, :is => "start_value", :should => "desired_value", :name => self.name, :resource => "fake_parent"), :is)
             end
         end
-        
-        resource = type.create :name => "test"
+
+        resource = type.new :name => "test"
         config = mk_catalog(resource)
         trans = Puppet::Transaction.new(config)
         trans.prepare
@@ -811,14 +618,14 @@ class TestTransactions < Test::Unit::TestCase
         end
 
         changes = trans.instance_variable_get("@changes")
-        
+
         assert(changes.length > 0, "did not get any changes")
-        
+
         changes.each do |change|
-            assert_equal(resource, change.resource, "change did not get proxy set correctly")
+            assert_equal(resource.object_id, change.resource.object_id, "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()
@@ -828,12 +635,12 @@ class TestTransactions < Test::Unit::TestCase
         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",
+
+        dirobj = Puppet::Type.type(:file).new :mode => "755", :recurse => true, :path => dir
+        exec = Puppet::Type.type(:exec).new :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
@@ -861,7 +668,7 @@ class TestTransactions < Test::Unit::TestCase
         end
 
         # Make a graph with some stuff in it.
-        graph = Puppet::Node::Catalog.new
+        graph = Puppet::Resource::Catalog.new
 
         # Add a non-triggering edge.
         a = trigger.new(:a)
@@ -912,29 +719,29 @@ class TestTransactions < Test::Unit::TestCase
         assert(trans.triggered?(c, :refresh),
             "Transaction did not store the trigger")
     end
-    
+
     def test_set_target
-        file = Puppet::Type.type(:file).create(:path => tempfile(), :content => "yay")
-        exec1 = Puppet::Type.type(:exec).create :command => "/bin/echo exec1"
-        exec2 = Puppet::Type.type(:exec).create :command => "/bin/echo exec2"
+        file = Puppet::Type.type(:file).new(:path => tempfile(), :content => "yay")
+        exec1 = Puppet::Type.type(:exec).new :command => "/bin/echo exec1"
+        exec2 = Puppet::Type.type(:exec).new :command => "/bin/echo exec2"
         trans = Puppet::Transaction.new(mk_catalog(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 = []
@@ -949,18 +756,18 @@ class TestTransactions < Test::Unit::TestCase
             Puppet::Type.rmtype(:norefresh)
         end
 
-        file = Puppet::Type.type(:file).create :path => tempfile(), :content => "yay"
-        one = klass.create :name => "one", :subscribe => file
-        
+        file = Puppet::Type.type(:file).new :path => tempfile(), :content => "yay"
+        one = klass.new :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 = Puppet::Type.type(:exec).new(:name => "/bin/echo one")
+        two = Puppet::Type.type(:exec).new(:name => "/bin/echo two")
         one[:require] = two
         two[:require] = one
 
@@ -983,16 +790,20 @@ class TestTransactions < Test::Unit::TestCase
         end
         cleanup { Puppet::Type.rmtype(:failer) }
 
-        obj = type.create(:name => "testing")
+        obj = type.new(: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 retrieve
+                    :eh
+                end
+
                 def sync
                     # noop
                     :ran_testing
@@ -1003,43 +814,43 @@ class TestTransactions < Test::Unit::TestCase
             end
         end
         cleanup { Puppet::Type.rmtype(:refresher)}
-        
-        obj = type.create(:name => "yay", :testing => "cool")
-        
+
+        obj = type.new(:name => "yay", :testing => "cool")
+
         assert(! obj.insync?(obj.retrieve), "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)
-        
+        group = Puppet::Type.type(:group).new(:name => nonrootgroup.name, :ensure => :present)
+        user = Puppet::Type.type(:user).new(: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.type(:file).create(:path => f, :content => "yay")
-        dir = Puppet::Type.type(:file).create(:path => d, :ensure => :directory, :require => file)
-        
+        file = Puppet::Type.type(:file).new(:path => f, :content => "yay")
+        dir = Puppet::Type.type(:file).new(:path => d, :ensure => :directory, :require => file)
+
         rels[dir] = file
         rels.each do |after, before|
             config = mk_catalog(before, after)
             trans = Puppet::Transaction.new(config)
             str = "from %s to %s" % [before, after]
-        
+
             assert_nothing_raised("Failed to create graph %s" % str) do
                 trans.prepare
             end
-        
+
             graph = trans.relationship_graph
             assert(graph.edge?(before, after), "did not create manual relationship %s" % str)
             assert(! graph.edge?(after, before), "created automatic relationship %s" % str)
@@ -1052,12 +863,12 @@ class TestTransactions < Test::Unit::TestCase
         path = tempfile
         epath = tempfile
         spath = tempfile
-        file = Puppet::Type.type(:file).create(:path => path, :ensure => :file,
+        file = Puppet::Type.type(:file).new(:path => path, :ensure => :file,
             :title => "file")
-        exec = Puppet::Type.type(:exec).create(:command => "touch %s" % epath,
+        exec = Puppet::Type.type(:exec).new(:command => "touch %s" % epath,
             :path => ENV["PATH"], :subscribe => file, :refreshonly => true,
             :title => 'exec1')
-        exec2 = Puppet::Type.type(:exec).create(:command => "touch %s" % spath,
+        exec2 = Puppet::Type.type(:exec).new(:command => "touch %s" % spath,
             :path => ENV["PATH"], :subscribe => exec, :refreshonly => true,
             :title => 'exec2')
 
@@ -1090,7 +901,7 @@ class TestTransactions < Test::Unit::TestCase
         3.times do |i|
             path = tempfile
             paths << path
-            file = Puppet::Type.type(:file).create(:path => path, :ensure => :absent,
+            file = Puppet::Type.type(:file).new(:path => path, :ensure => :absent,
                 :backup => false, :title => "file%s" % i)
             File.open(path, "w") { |f| f.puts "" }
             files << file
@@ -1109,11 +920,12 @@ class TestTransactions < Test::Unit::TestCase
     end
 
     def test_flush
-        $state = "absent"
+        $state = :absent
         $flushed = 0
         type = Puppet::Type.newtype(:flushtest) do
             newparam(:name)
             newproperty(:ensure) do
+                newvalues :absent, :present, :other
                 def retrieve
                     $state
                 end
@@ -1130,12 +942,12 @@ class TestTransactions < Test::Unit::TestCase
 
         cleanup { Puppet::Type.rmtype(:flushtest) }
 
-        obj = type.create(:name => "test", :ensure => "present")
+        obj = type.new(:name => "test", :ensure => :present)
 
         # first make sure it runs through and flushes
         assert_apply(obj)
 
-        assert_equal("present", $state, "Object did not make a change")
+        assert_equal(:present, $state, "Object did not make a change")
         assert_equal(1, $flushed, "object was not flushed")
 
         # Now run a noop and make sure we don't flush
@@ -1143,7 +955,7 @@ class TestTransactions < Test::Unit::TestCase
         obj[:noop] = true
 
         assert_apply(obj)
-        assert_equal("present", $state, "Object made a change in noop")
+        assert_equal(:present, $state, "Object made a change in noop")
         assert_equal(1, $flushed, "object was flushed in noop")
     end
 end