puppet 0.22.4 → 0.23.0

data/test/language/lexer.rb

@@ -242,6 +242,18 @@ class TestLexer < Test::Unit::TestCase
             end
         end
     end
+
+    # Make sure the expected stack works as it should
+    def test_expected
+        @lexer.string = "[a{"
+        expected = @lexer.instance_variable_get("@expected")
+        @lexer.scan {}
+        assert_equal("}", @lexer.expected, "expected value is wrong")
+
+        @lexer.string = "}"
+        @lexer.scan {}
+        assert_equal("]", @lexer.expected, "expected value is wrong after pop")
+    end
 end
 
-# $Id: lexer.rb 2393 2007-04-19 18:34:03Z luke $
+# $Id: lexer.rb 2531 2007-05-25 00:31:28Z luke $

data/test/language/node.rb

@@ -110,6 +110,6 @@ node default {
         assert(default,
             "Did not find default node")
 
-        assert_equal("default", default.fqname)
+        assert_equal("default", default.classname)
     end
 end

data/test/language/parser.rb

@@ -397,7 +397,7 @@ file { "/tmp/yayness":
         }
         sub = interp.findclass("", "container::deep::sub")
         assert(sub, "Could not find sub")
-        assert_equal("base", sub.parentclass.type)
+        assert_equal("base", sub.parentobj.classname)
         
         # Now try it with a parent class being a fq class
         assert_nothing_raised {
@@ -405,7 +405,7 @@ file { "/tmp/yayness":
         }
         sub = interp.findclass("", "container::one")
         assert(sub, "Could not find one")
-        assert_equal("sub", sub.parentclass.type)
+        assert_equal("container::deep::sub", sub.parentobj.classname)
         
         # Finally, try including a qualified class
         assert_nothing_raised("Could not include fully qualified class") {
@@ -431,7 +431,7 @@ file { "/tmp/yayness":
         assert_nothing_raised do
             out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
             assert_instance_of(AST::ASTArray, out)
-            assert_equal("", parser.interp.findclass("", "").type)
+            assert_equal("", parser.interp.findclass("", "").classname)
             assert_equal("", parser.interp.findclass("", "").namespace)
             assert_equal(out.object_id, parser.interp.findclass("", "").code.object_id)
         end
@@ -763,6 +763,19 @@ file { "/tmp/yayness":
             parser.import("%s/*" % dir)
         end
     end
+
+    # #629 - undef keyword
+    def test_undef
+        parser = mkparser
+        result = nil
+        assert_nothing_raised("Could not parse assignment to undef") {
+            result = parser.parse %{$variable = undef}
+        }
+
+        children = result.children
+        assert_instance_of(AST::VarDef, result.children[0])
+        assert_instance_of(AST::Undef, result.children[0].value)
+    end
 end
 
-# $Id: parser.rb 2404 2007-04-20 16:40:47Z luke $
+# $Id: parser.rb 2522 2007-05-17 21:43:51Z luke $

data/test/language/resource.rb

@@ -4,15 +4,14 @@ $:.unshift("../lib").unshift("../../lib") if __FILE__ =~ /\.rb$/
 
 require 'puppettest'
 require 'puppettest/resourcetesting'
-require 'puppettest/railstesting'
 
-class TestResource < Test::Unit::TestCase
+class TestResource < PuppetTest::TestCase
 	include PuppetTest
     include PuppetTest::ParserTesting
     include PuppetTest::ResourceTesting
-    include PuppetTest::RailsTesting
     Parser = Puppet::Parser
     AST = Parser::AST
+    Reference = Puppet::Parser::Resource::Reference
 
     def setup
         super
@@ -133,10 +132,15 @@ class TestResource < Test::Unit::TestCase
     end
 
     def test_to_trans
-        # First try translating a builtin resource
+        # First try translating a builtin resource.  Make sure we use some references
+        # and arrays, to make sure they translate correctly.
+        refs = []
+        4.times { |i| refs << Puppet::Parser::Resource::Reference.new(:title => "file%s" % i, :type => "file") }
         res = Parser::Resource.new :type => "file", :title => "/tmp",
             :source => @source, :scope => @scope,
-            :params => paramify(@source, :owner => "nobody", :mode => "644")
+            :params => paramify(@source, :owner => "nobody", :group => %w{you me},
+            :require => refs[0], :ignore => %w{svn},
+            :subscribe => [refs[1], refs[2]], :notify => [refs[3]])
 
         obj = nil
         assert_nothing_raised do
@@ -149,8 +153,12 @@ class TestResource < Test::Unit::TestCase
         assert_equal(obj.name, res.title)
 
         # TransObjects use strings, resources use symbols
-        hash = obj.to_hash.inject({}) { |h,a| h[a[0].intern] = a[1]; h }
-        assert_equal(hash, res.to_hash)
+        assert_equal("nobody", obj["owner"], "Single-value string was not passed correctly")
+        assert_equal(%w{you me}, obj["group"], "Array of strings was not passed correctly")
+        assert_equal("svn", obj["ignore"], "Array with single string was not turned into single value")
+        assert_equal(["file", refs[0].title], obj["require"], "Resource reference was not passed correctly")
+        assert_equal([["file", refs[1].title], ["file", refs[2].title]], obj["subscribe"], "Array of resource references was not passed correctly")
+        assert_equal(["file", refs[3].title], obj["notify"], "Array with single resource reference was not turned into single value")
     end
 
     def test_adddefaults
@@ -360,99 +368,6 @@ class TestResource < Test::Unit::TestCase
 
         assert_nil(ref.builtintype, "Component was considered builtin")
     end
-    if Puppet.features.rails?
-
-    # Compare a parser resource to a rails resource.
-    def compare_resources(host, res, updating, options = {})
-        # to_rails now expects to be passed a resource, else it will create a new one
-        newobj = host.resources.find_by_restype_and_title(res.type, res.title)
-        assert_nothing_raised do
-            newobj = res.to_rails(host, newobj)
-        end
-
-        assert_instance_of(Puppet::Rails::Resource, newobj)
-        newobj.save
-
-        if updating
-            tail = "on update"
-        else
-            tail = ""
-        end
-
-        # Make sure we find our object and only our object
-        count = 0
-        obj = nil
-        Puppet::Rails::Resource.find(:all).each do |obj|
-            assert_equal(newobj.id, obj.id, "Found object has a different id than generated object %s" % tail)
-            count += 1
-            [:title, :restype, :line, :exported].each do |param|
-                if param == :restype
-                    method = :type
-                else
-                    method = param
-                end
-                assert_equal(res.send(method), obj[param], 
-                    "attribute %s was not set correctly in rails %s" % [param, tail])
-            end
-        end
-        assert_equal(1, count, "Got too many resources %s" % tail)
-        # Now make sure we can find it again
-        assert_nothing_raised do
-            obj = Puppet::Rails::Resource.find_by_restype_and_title(
-                res.type, res.title, :include => :param_names
-            )
-        end
-        assert_instance_of(Puppet::Rails::Resource, obj)
-
-        # Make sure we get the parameters back
-        params = options[:params] || [obj.param_names.collect { |p| p.name },
-            res.to_hash.keys].flatten.collect { |n| n.to_s }.uniq
-
-        params.each do |name|
-            param = obj.param_names.find_by_name(name)
-            if res[name]
-                assert(param, "resource did not keep %s %s" % [name, tail])
-            else
-                assert(! param, "resource did not delete %s %s" % [name, tail])
-            end
-            if param
-                values = param.param_values.collect { |pv| pv.value }
-                should = res[param.name]
-                should = [should] unless should.is_a?(Array)
-                assert_equal(should, values,
-                    "%s was different %s" % [param.name, tail])
-            end
-        end
-    end
-
-    def test_to_rails
-        railsteardown
-        railsinit
-        res = mkresource :type => "file", :title => "/tmp/testing",
-            :source => @source, :scope => @scope,
-            :params => {:owner => "root", :source => ["/tmp/A", "/tmp/B"],
-                :mode => "755"}
-
-        res.line = 50
-
-        # We also need a Rails Host to store under
-        host = Puppet::Rails::Host.new(:name => Facter.hostname)
-
-        compare_resources(host, res, false, :params => %w{owner source mode})
-
-        # Now make some changes to our resource.  We're removing the mode,
-        # changing the source, and adding 'check'.
-        res = mkresource :type => "file", :title => "/tmp/testing",
-            :source => @source, :scope => @scope,
-            :params => {:owner => "bin", :source => ["/tmp/A", "/tmp/C"],
-            :check => "checksum"}
-
-        res.line = 75
-        res.exported = true
-
-        compare_resources(host, res, true, :params => %w{owner source mode check})
-    end
-    end
 
     # #472.  Really, this still isn't the best behaviour, but at least
     # it's consistent with what we have elsewhere.
@@ -530,6 +445,57 @@ class TestResource < Test::Unit::TestCase
             end
         end
     end
+
+    # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
+    def test_undef_and_to_hash
+        res = mkresource :type => "file", :title => "/tmp/testing",
+            :source => @source, :scope => @scope,
+            :params => {:owner => :undef, :mode => "755"}
+
+        hash = nil
+        assert_nothing_raised("Could not convert resource with undef to hash") do
+            hash = res.to_hash
+        end
+
+        assert_nil(hash[:owner], "got a value for an undef parameter")
+    end
+
+    # #643 - Make sure virtual defines result in virtual resources
+    def test_virtual_defines
+        define = @interp.newdefine("yayness",
+            :code => resourcedef("file", varref("name"),
+                "mode" => "644"))
+
+        res = mkresource :type => "yayness", :title => "foo", :params => {}
+        res.virtual = true
+
+        result = nil
+        assert_nothing_raised("Could not evaluate defined resource") do
+            result = res.evaluate
+        end
+
+        scope = res.scope
+        newres = scope.findresource("File[foo]")
+        assert(newres, "Could not find resource")
+
+        assert(newres.virtual?, "Virtual defined resource generated non-virtual resources")
+
+        # Now try it with exported resources
+        res = mkresource :type => "yayness", :title => "bar", :params => {}
+        res.exported = true
+
+        result = nil
+        assert_nothing_raised("Could not evaluate exported resource") do
+            result = res.evaluate
+        end
+
+        scope = res.scope
+        newres = scope.findresource("File[bar]")
+        assert(newres, "Could not find resource")
+
+        assert(newres.exported?, "Exported defined resource generated non-exported resources")
+        assert(newres.virtual?, "Exported defined resource generated non-virtual resources")
+    end
 end
 
-# $Id: resource.rb 2439 2007-04-30 19:21:59Z luke $
+# $Id: resource.rb 2597 2007-06-17 21:41:50Z luke $

data/test/language/scope.rb

@@ -412,7 +412,7 @@ class TestScope < Test::Unit::TestCase
 
         [myclass, otherclass].each do |klass|
             assert(scope.setclass?(klass),
-                "%s was not set" % klass.fqname)
+                "%s was not set" % klass.classname)
         end
     end
 
@@ -445,6 +445,8 @@ class TestScope < Test::Unit::TestCase
             "Empty strings considered true")
         assert_equal(false, Puppet::Parser::Scope.true?(false),
             "false considered true")
+        assert_equal(false, Puppet::Parser::Scope.true?(:undef),
+            "undef considered true")
     end
 
     # Verify scope context is handled correctly.
@@ -611,7 +613,7 @@ Host <<||>>"
         end
 
         # Now make sure good tags make it through.
-        tags = %w{good-tag yaytag GoodTag another_tag}
+        tags = %w{good-tag yaytag GoodTag another_tag a ab A}
         tags.each do |tag|
             assert_nothing_raised("Tag #{tag} was considered invalid") do
                 scope.tag tag
@@ -745,6 +747,19 @@ Host <<||>>"
         scope.add_namespace("b")
         assert_nothing_raised { test.call([["a", "testing"], ["b", "testing"]]) }
     end
+
+    # #629 - undef should be "" or :undef
+    def test_lookupvar_with_undef
+        scope = mkscope
+
+        scope.setvar("testing", :undef)
+
+        assert_equal(:undef, scope.lookupvar("testing", false),
+            "undef was not returned as :undef when not string")
+
+        assert_equal("", scope.lookupvar("testing", true),
+            "undef was not returned as '' when string")
+    end
 end
 
-# $Id: scope.rb 2418 2007-04-26 19:09:24Z luke $
+# $Id: scope.rb 2523 2007-05-17 21:51:36Z luke $

data/test/language/snippets.rb

@@ -13,10 +13,32 @@ class TestSnippets < Test::Unit::TestCase
 	include PuppetTest
     include ObjectSpace
 
+    def setup
+        super
+        @file = Puppet::Type.type(:file)
+    end
+
     def self.snippetdir
         PuppetTest.datadir "snippets"
     end
 
+    def assert_file(path, msg = nil)
+        unless file = @file[path]
+            msg ||= "Could not find file %s" % path
+            raise msg
+        end
+    end
+
+    def assert_mode_equal(mode, path)
+        unless file = @file[path]
+            raise "Could not find file %s" % path
+        end
+
+        unless mode == file.should(:mode)
+            raise "Mode for %s is incorrect: %o vs %o" % [path, mode, file.should(:mode)]
+        end
+    end
+
     def snippet(name)
         File.join(self.class.snippetdir, name)
     end
@@ -151,73 +173,57 @@ class TestSnippets < Test::Unit::TestCase
 
     def snippet_filecreate
         %w{a b c d}.each { |letter|
-            file = "/tmp/create%stest" % letter
-            Puppet.info "testing %s" % file
-            assert(Puppet.type(:file)[file], "File %s does not exist" % file)
-            assert(FileTest.exists?(file))
-            @@tmpfiles << file
-        }
-        %w{a b}.each { |letter|
-            file = "/tmp/create%stest" % letter
-            assert(File.stat(file).mode & 007777 == 0755)
+            path = "/tmp/create%stest" % letter
+            assert_file(path)
+            if %w{a b}.include?(letter)
+                assert_mode_equal(0755, path)
+            end
         }
     end
 
     def snippet_simpledefaults
-        file = "/tmp/defaulttest"
-        @@tmpfiles << file
-        assert(FileTest.exists?(file), "File %s does not exist" % file)
-        assert(File.stat(file).mode & 007777 == 0755)
+        path = "/tmp/defaulttest"
+        assert_file(path)
+        assert_mode_equal(0755, path)
     end
 
     def snippet_simpleselector
         files = %w{a b c d}.collect { |letter|
-            "/tmp/snippetselect%stest" % letter
-        }
-        @@tmpfiles += files
-
-        files.each { |file|
-            assert(FileTest.exists?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is the incorrect mode" % file)
-            @@tmpfiles << file
+            path = "/tmp/snippetselect%stest" % letter
+            assert_file(path)
+            assert_mode_equal(0755, path)
         }
     end
 
     def snippet_classpathtest
-        file = "/tmp/classtest"
-        @@tmpfiles << file
-
-        assert(FileTest.exists?(file))
+        path = "/tmp/classtest"
 
-        obj = nil
-        assert_nothing_raised {
-            obj = Puppet.type(:file)[file]
-        }
+        file = @file[path]
+        assert(file, "did not create file %s" % path)
 
         assert_nothing_raised {
             assert_equal(
                 "//testing/component[componentname]/File[/tmp/classtest]",
-                obj.path)
-            #Puppet.err obj.path
+                file.path)
         }
     end
 
     def snippet_argumentdefaults
-        file1 = "/tmp/argumenttest1"
-        file2 = "/tmp/argumenttest2"
-        @@tmpfiles << file1
-        @@tmpfiles << file2
+        path1 = "/tmp/argumenttest1"
+        path2 = "/tmp/argumenttest2"
 
-        assert(FileTest.exists?(file1))
-        assert(File.stat(file1).mode & 007777 == 0755)
-        
-        assert(FileTest.exists?(file2))
-        assert(File.stat(file2).mode & 007777 == 0644)
+        file1 = @file[path1]
+        file2 = @file[path2]
+
+        assert_file(path1)
+        assert_mode_equal(0755, path1)
+
+        assert_file(path2)
+        assert_mode_equal(0644, path2)
     end
 
     def snippet_casestatement
-        files = %w{
+        paths = %w{
             /tmp/existsfile
             /tmp/existsfile2
             /tmp/existsfile3
@@ -225,32 +231,29 @@ class TestSnippets < Test::Unit::TestCase
             /tmp/existsfile5
         }
 
-        files.each { |file|
-            assert(FileTest.exists?(file), "File %s is missing" % file)
-            assert(File.stat(file).mode & 007777 == 0755, "File %s is not 755" % file)
+        paths.each { |path|
+            file = @file[path]
+            assert(file, "File %s is missing" % path)
+            assert_mode_equal(0755, path)
         }
     end
 
     def snippet_implicititeration
-        files = %w{a b c d e f g h}.collect { |l| "/tmp/iteration%stest" % l }
-
-        files.each { |file|
-            @@tmpfiles << file
-            assert(FileTest.exists?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is not 755" % file)
+        paths = %w{a b c d e f g h}.collect { |l| "/tmp/iteration%stest" % l }
 
+        paths.each { |path|
+            file = @file[path]
+            assert_file(path)
+            assert_mode_equal(0755, path)
         }
     end
 
     def snippet_multipleinstances
-        files = %w{a b c}.collect { |l| "/tmp/multipleinstances%s" % l }
+        paths = %w{a b c}.collect { |l| "/tmp/multipleinstances%s" % l }
 
-        files.each { |file|
-            @@tmpfiles << file
-            assert(FileTest.exists?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is not 755" % file)
+        paths.each { |path|
+            assert_file(path)
+            assert_mode_equal(0755, path)
 
         }
     end
@@ -258,26 +261,23 @@ class TestSnippets < Test::Unit::TestCase
     def snippet_namevartest
         file = "/tmp/testfiletest"
         dir = "/tmp/testdirtest"
-        @@tmpfiles << file
-        @@tmpfiles << dir
-        assert(FileTest.file?(file), "File %s does not exist" % file)
-        assert(FileTest.directory?(dir), "Directory %s does not exist" % dir)
+        assert_file(file)
+        assert_file(dir)
+        assert_equal(:directory, @file[dir].should(:ensure), "Directory is not set to be a directory")
     end
 
     def snippet_scopetest
         file = "/tmp/scopetest"
-        @@tmpfiles << file
-        assert(FileTest.file?(file), "File %s does not exist" % file)
-        assert(File.stat(file).mode & 007777 == 0755,
-            "File %s is not 755" % file)
+        assert_file(file)
+        assert_mode_equal(0755, file)
     end
 
     def snippet_failmissingexecpath
         file = "/tmp/exectesting1"
         execfile = "/tmp/execdisttesting"
-        @@tmpfiles << file
-        @@tmpfiles << execfile
-        assert(!FileTest.exists?(execfile), "File %s exists" % execfile)
+        assert_file(file)
+
+        assert_nil(Puppet::Type.type(:exec)["exectest"], "invalid exec was created")
     end
 
     def snippet_selectorvalues
@@ -287,10 +287,8 @@ class TestSnippets < Test::Unit::TestCase
         }
 
         files.each { |f|
-            @@tmpfiles << f
-            assert(FileTest.exists?(f), "File %s does not exist" % f)
-            assert(File.stat(f).mode & 007777 == 0755,
-                "File %s is not 755" % f)
+            assert_file(f)
+            assert_mode_equal(0755, f)
         }
     end
 
@@ -301,66 +299,56 @@ class TestSnippets < Test::Unit::TestCase
         }
 
         files.each { |f|
-            @@tmpfiles << f
-            assert(FileTest.exists?(f), "File %s does not exist" % f)
-            assert(File.stat(f).mode & 007777 == 0755,
-                "File %s is not 755" % f)
+            assert_file(f)
+            assert_mode_equal(0755, f)
         }
     end
 
     def snippet_falsevalues
         file = "/tmp/falsevaluesfalse"
-        @@tmpfiles << file
-        assert(FileTest.exists?(file), "File %s does not exist" % file)
+        assert_file(file)
     end
 
     def disabled_snippet_classargtest
         [1,2].each { |num|
             file = "/tmp/classargtest%s" % num
-            @@tmpfiles << file
-            assert(FileTest.file?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is not 755" % file)
+            assert_file(file)
+            assert_mode_equal(0755, file)
         }
     end
 
     def snippet_classheirarchy
         [1,2,3].each { |num|
             file = "/tmp/classheir%s" % num
-            @@tmpfiles << file
-            assert(FileTest.file?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is not 755" % file)
+            assert_file(file)
+            assert_mode_equal(0755, file)
         }
     end
 
     def snippet_singleary
         [1,2,3,4].each { |num|
             file = "/tmp/singleary%s" % num
-            @@tmpfiles << file
-            assert(FileTest.file?(file), "File %s does not exist" % file)
+            assert_file(file)
         }
     end
 
     def snippet_classincludes
         [1,2,3].each { |num|
             file = "/tmp/classincludes%s" % num
-            @@tmpfiles << file
-            assert(FileTest.file?(file), "File %s does not exist" % file)
-            assert(File.stat(file).mode & 007777 == 0755,
-                "File %s is not 755" % file)
+            assert_file(file)
+            assert_mode_equal(0755, file)
         }
     end
 
     def snippet_componentmetaparams
         ["/tmp/component1", "/tmp/component2"].each { |file|
-            assert(FileTest.file?(file), "File %s does not exist" % file)
+            assert_file(file)
         }
     end
 
     def snippet_aliastest
         %w{/tmp/aliastest /tmp/aliastest2 /tmp/aliastest3}.each { |file|
-            assert(FileTest.file?(file), "File %s does not exist" % file)
+            assert_file(file)
         }
     end
 
@@ -369,17 +357,14 @@ class TestSnippets < Test::Unit::TestCase
             2 => 'some "\yayness\"'
         }.each { |count, str|
             path = "/tmp/singlequote%s" % count
-            assert(FileTest.exists?(path), "File %s is missing" % path)
-            text = File.read(path)
-
-            assert_equal(str, text)
+            assert_file(path)
+            assert_equal(str, @file[path].should(:content))
         }
     end
 
     # There's no way to actually retrieve the list of classes from the
     # transaction.
     def snippet_tag
-        @@tmpfiles << "/tmp/settestingness"
     end
 
     # Make sure that set tags are correctly in place, yo.
@@ -388,25 +373,21 @@ class TestSnippets < Test::Unit::TestCase
             "both" => false, "bothtrue" => true, "define" => true}
 
         tags.each do |tag, retval|
-            @@tmpfiles << "/tmp/tagged#{tag}true"
-            @@tmpfiles << "/tmp/tagged#{tag}false"
-
-            assert(FileTest.exists?("/tmp/tagged#{tag}#{retval.to_s}"),
-                "'tagged' did not return %s with %s" % [retval, tag])
+            assert_file("/tmp/tagged#{tag}#{retval.to_s}")
         end
     end
 
     def snippet_defineoverrides
         file = "/tmp/defineoverrides1"
-        assert(FileTest.exists?(file), "File does not exist")
-        assert_equal(0755, filemode(file))
+        assert_file(file)
+        assert_mode_equal(0755, file)
     end
 
     def snippet_deepclassheirarchy
         5.times { |i|
             i += 1
             file = "/tmp/deepclassheir%s" % i
-            assert(FileTest.exists?(file), "File %s does not exist" % file)
+            assert_file(file)
         }
     end
 
@@ -415,70 +396,56 @@ class TestSnippets < Test::Unit::TestCase
     end
 
     def snippet_emptyexec
-        assert(FileTest.exists?("/tmp/emptyexectest"),
-            "Empty exec was ignored")
-
-        @@tmpfiles << "/tmp/emptyexextest"
+        assert(Puppet::Type.type(:exec)["touch /tmp/emptyexectest"],
+            "Did not create exec")
     end
 
     def snippet_multisubs
         path = "/tmp/multisubtest"
-        assert(FileTest.exists?(path), "Did not create file")
-        assert_equal("sub2", File.read(path), "sub2 did not override content")
-        assert_equal(0755, filemode(path), "sub1 did not override mode")
+        assert_file(path)
+        file = @file[path]
+        assert_equal("sub2", file.should(:content), "sub2 did not override content")
+        assert_mode_equal(0755, path)
     end
 
     def snippet_collection
-        assert(FileTest.exists?("/tmp/colltest1"), "Did not collect file")
-        assert(! FileTest.exists?("/tmp/colltest2"), "Incorrectly collected file")
+        assert_file("/tmp/colltest1")
+        assert_nil(@file["/tmp/colltest2"], "Incorrectly collected file")
     end
 
     def snippet_virtualresources
         %w{1 2 3 4}.each do |num|
-            assert(FileTest.exists?("/tmp/virtualtest#{num}"),
-                "Did not collect file #{num}")
+            assert_file("/tmp/virtualtest#{num}")
         end
     end
     
     def snippet_componentrequire
         %w{1 2}.each do |num|
-            assert(FileTest.exists?("/tmp/testing_component_requires#{num}"),
+            assert_file("/tmp/testing_component_requires#{num}",
                 "#{num} does not exist")
-            end
+        end
     end
 
     def snippet_realize_defined_types
-        assert(FileTest.exists?("/tmp/realize_defined_test1"),
-            "Did not make file from realized defined type")
-        assert(FileTest.exists?("/tmp/realize_defined_test2"),
-            "Did not make file from realized file inside defined type")
+        assert_file("/tmp/realize_defined_test1")
+        assert_file("/tmp/realize_defined_test2")
     end
 
     def snippet_fqparents
-        assert(FileTest.exists?("/tmp/fqparent1"),
-            "Did not make file from parent class")
-        assert(FileTest.exists?("/tmp/fqparent2"),
-            "Did not make file from subclass")
+        assert_file("/tmp/fqparent1", "Did not make file from parent class")
+        assert_file("/tmp/fqparent2", "Did not make file from subclass")
     end
 
     def snippet_fqdefinition
-        assert(FileTest.exists?("/tmp/fqdefinition"),
+        assert_file("/tmp/fqdefinition",
             "Did not make file from fully-qualified definition")
     end
 
-    def snippet_dirchmod
-        dirs = %w{a b}.collect { |letter|
-            "/tmp/dirchmodtest%s" % letter
-        }
-
-        @@tmpfiles << dirs
-
-        dirs.each { |dir|
-            assert(FileTest.directory?(dir))
-        }
-
-        assert(File.stat("/tmp/dirchmodtesta").mode & 007777 == 0755)
-        assert(File.stat("/tmp/dirchmodtestb").mode & 007777 == 0700)
+    def snippet_subclass_name_duplication
+        assert_file("/tmp/subclass_name_duplication1",
+            "Did not make first file from duplicate subclass names")
+        assert_file("/tmp/subclass_name_duplication2",
+            "Did not make second file from duplicate subclass names")
     end
 
     # Iterate across each of the snippets and create a test.
@@ -517,9 +484,9 @@ class TestSnippets < Test::Unit::TestCase
                 assert_nothing_raised {
                     client.getconfig()
                 }
-                assert_nothing_raised {
-                    trans = client.apply()
-                }
+                #assert_nothing_raised {
+                #    trans = client.apply()
+                #}
 
                 Puppet::Type.eachtype { |type|
                     type.each { |obj|
@@ -529,10 +496,6 @@ class TestSnippets < Test::Unit::TestCase
                         #    assert(obj.parent, "%s has no parent" % obj.name)
                         #end
                         assert(obj.name)
-
-                        if obj.is_a?(Puppet.type(:file))
-                            @@tmpfiles << obj[:path]
-                        end
                     }
                 }
                 assert_nothing_raised {
@@ -546,4 +509,4 @@ class TestSnippets < Test::Unit::TestCase
     }
 end
 
-# $Id: snippets.rb 2259 2007-03-06 19:03:05Z luke $
+# $Id: snippets.rb 2463 2007-05-04 23:09:34Z luke $