puppet 0.9.2

data/test/language/snippets.rb

@@ -0,0 +1,445 @@
+#!/usr/bin/ruby -w
+
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/interpreter'
+require 'puppet/parser/parser'
+require 'puppet/client'
+require 'puppet/server'
+require 'test/unit'
+require 'puppettest'
+
+# so, what kind of things do we want to test?
+
+# we don't need to test function, since we're confident in the
+# library tests.  We do, however, need to test how things are actually
+# working in the language.
+
+# so really, we want to do things like test that our ast is correct
+# and test whether we've got things in the right scopes
+
+class TestSnippets < Test::Unit::TestCase
+	include TestPuppet
+    $snippetbase = File.join($puppetbase, "examples", "code", "snippets")
+    
+    def file2ast(file)
+        parser = Puppet::Parser::Parser.new()
+        parser.file = file
+        ast = parser.parse
+
+        return ast
+    end
+
+    def snippet2ast(text)
+        parser = Puppet::Parser::Parser.new()
+        parser.string = text
+        ast = parser.parse
+
+        return ast
+    end
+
+    def client
+        args = {
+            :Listen => false
+        }
+        Puppet::Client.new(args)
+    end
+
+    def ast2scope(ast)
+        interp = Puppet::Parser::Interpreter.new(
+            :ast => ast,
+            :client => client()
+        )
+        scope = Puppet::Parser::Scope.new()
+        ast.evaluate(scope)
+
+        return scope
+    end
+
+    def scope2objs(scope)
+        objs = scope.to_trans
+    end
+
+    def snippet2scope(snippet)
+        ast = snippet2ast(snippet)
+        scope = ast2scope(ast)
+    end
+
+    def snippet2objs(snippet)
+        ast = snippet2ast(snippet)
+        scope = ast2scope(ast)
+        objs = scope2objs(scope)
+    end
+
+    def states(type)
+        states = type.validstates
+    end
+
+    def metaparams(type)
+        mparams = []
+        Puppet::Type.eachmetaparam { |param|
+            mparams.push param
+        }
+
+        mparams
+    end
+
+    def params(type)
+        params = []
+        type.parameters.each { |name,state|
+            params.push name
+        }
+
+        params
+    end
+
+    def randthing(thing,type)
+        list = self.send(thing,type)
+        list[rand(list.length)]
+    end
+
+    def randeach(type)
+        [:states, :metaparams, :params].collect { |thing|
+            randthing(thing,type)
+        }
+    end
+
+    @@snippets = {
+        true => [
+            %{File { mode => 755 }}
+        ],
+    }
+
+    def disabled_test_defaults
+        Puppet::Type.eachtype { |type|
+            next if type.name == :puppet or type.name == :component
+            
+            rands = randeach(type)
+
+            name = type.name.to_s.capitalize
+
+            [0..1, 0..2].each { |range|
+                params = rands[range]
+                paramstr = params.collect { |param|
+                    "%s => fake" % param
+                }.join(", ")
+
+                str = "%s { %s }" % [name, paramstr]
+
+                scope = nil
+                assert_nothing_raised {
+                    scope = snippet2scope(str)
+                }
+
+                defaults = nil
+                assert_nothing_raised {
+                    defaults = scope.lookupdefaults(name)
+                }
+
+                p defaults
+
+                params.each { |param|
+                    puts "%s => '%s'" % [name,param]
+                    assert(defaults.include?(param))
+                }
+            }
+        }
+    end
+
+    # this is here in case no tests get defined; otherwise we get a warning
+    def test_nothing
+    end
+
+    def snippet_filecreate(trans)
+        %w{a b c d}.each { |letter|
+            file = "/tmp/create%stest" % letter
+            Puppet.info "testing %s" % file
+            assert(Puppet::Type::PFile[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)
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+        %w{a b c d}.each { |letter|
+            file = "/tmp/create%stest" % letter
+            assert(! FileTest.exists?(file), "File %s still exists" % file)
+        }
+    end
+
+    def snippet_simpledefaults(trans)
+        file = "/tmp/defaulttest"
+        @@tmpfiles << file
+        assert(FileTest.exists?(file), "File %s does not exist" % file)
+        assert(File.stat(file).mode & 007777 == 0755)
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+        assert(! FileTest.exists?(file))
+    end
+
+    def snippet_simpleselector(trans)
+        files = %w{a b c d}.collect { |letter|
+            "/tmp/snippetselect%stest" % letter
+        }
+        @@tmpfiles += files
+
+        files.each { |file|
+            assert(FileTest.exists?(file))
+            assert(File.stat(file).mode & 007777 == 0755)
+            @@tmpfiles << file
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+        files.each { |file|
+            assert(! FileTest.exists?(file))
+        }
+    end
+
+    def snippet_classpathtest(trans)
+        file = "/tmp/classtest"
+        @@tmpfiles << file
+
+        assert(FileTest.exists?(file))
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Puppet::Type::PFile[file]
+        }
+
+        assert_nothing_raised {
+            assert_equal(
+                "//testing/component[componentname]/file=/tmp/classtest",
+                obj.path)
+            #Puppet.err obj.path
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+        assert(! FileTest.exists?(file))
+    end
+
+    def snippet_argumentdefaults(trans)
+        file1 = "/tmp/argumenttest1"
+        file2 = "/tmp/argumenttest2"
+        @@tmpfiles << file1
+        @@tmpfiles << file2
+
+        assert(FileTest.exists?(file1))
+        assert(File.stat(file1).mode & 007777 == 0755)
+        
+        assert(FileTest.exists?(file2))
+        assert(File.stat(file2).mode & 007777 == 0644)
+    end
+
+    def snippet_casestatement(trans)
+        files = %w{
+            /tmp/existsfile
+            /tmp/existsfile2
+            /tmp/existsfile3
+        }
+
+        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)
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+    end
+
+    def snippet_implicititeration(trans)
+        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)
+
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+
+        files.each { |file|
+            assert(! FileTest.exists?(file), "file %s still exists" % file)
+        }
+    end
+
+    def snippet_multipleinstances(trans)
+        files = %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)
+
+        }
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+
+        files.each { |file|
+            assert(! FileTest.exists?(file), "file %s still exists" % file)
+        }
+    end
+
+    def snippet_namevartest(trans)
+        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)
+    end
+
+    def snippet_scopetest(trans)
+        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)
+    end
+
+    def snippet_failmissingexecpath(trans)
+        file = "/tmp/exectesting1"
+        execfile = "/tmp/execdisttesting"
+        @@tmpfiles << file
+        @@tmpfiles << execfile
+        assert(!FileTest.exists?(execfile), "File %s exists" % execfile)
+    end
+
+    def snippet_selectorvalues(trans)
+        nums = %w{1 2 3}
+        files = nums.collect { |n|
+            "/tmp/selectorvalues%s" % n
+        }
+
+        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)
+        }
+    end
+
+    def snippet_falsevalues(trans)
+        file = "/tmp/falsevaluesfalse"
+        @@tmpfiles << file
+        assert(FileTest.exists?(file), "File %s does not exist" % file)
+    end
+
+    def disabled_snippet_classargtest(trans)
+        [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)
+        }
+    end
+
+    def snippet_classheirarchy(trans)
+        [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)
+        }
+    end
+
+    def snippet_classincludes(trans)
+        [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)
+        }
+    end
+
+    def disabled_snippet_dirchmod(trans)
+        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)
+
+        assert_nothing_raised {
+            trans.rollback
+        }
+    end
+
+    # XXX this is the answer
+    Dir.entries($snippetbase).sort.each { |file|
+        next if file =~ /^\./
+
+
+        mname = "snippet_" + file.sub(/\.pp$/, '')
+        if self.method_defined?(mname)
+            #eval("alias %s %s" % [testname, mname])
+            testname = ("test_" + mname).intern
+            self.send(:define_method, testname) {
+                # first parse the file
+                server = Puppet::Server::Master.new(
+                    :File => File.join($snippetbase, file),
+                    :Local => true
+                )
+                client = Puppet::Client::MasterClient.new(
+                    :Master => server,
+                    :Cache => false
+                )
+
+                assert(client.local)
+                assert_nothing_raised {
+                    client.getconfig()
+                }
+                trans = nil
+                assert_nothing_raised {
+                    trans = client.apply()
+                }
+
+                Puppet::Type.eachtype { |type|
+                    type.each { |obj|
+                        unless obj.name == "puppet[top]"
+                            assert(obj.parent, "%s has no parent" % obj.name)
+                        end
+                        assert(obj.name)
+                    }
+                }
+                assert_nothing_raised {
+                    self.send(mname, trans)
+                }
+            }
+            mname = mname.intern
+            #eval("alias %s %s" % [testname, mname])
+        end
+    }
+end

data/test/other/events.rb

@@ -0,0 +1,111 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: events.rb 724 2005-10-22 22:27:20Z luke $
+
+class TestEvents < Test::Unit::TestCase
+	include TestPuppet
+    def teardown
+        super
+        Puppet::Event::Subscription.clear
+    end
+
+    def test_simplesubscribe
+        file = Puppet::Type::PFile.create(
+            :name => "/tmp/eventtestingA",
+            :create => true
+        )
+        exec = Puppet::Type::Exec.create(
+            :name => "echo true",
+            :path => "/usr/bin:/bin",
+            :refreshonly => true,
+            :subscribe => [[file.class.name, file.name]] 
+        )
+
+        @@tmpfiles << "/tmp/eventtestingA"
+
+        comp = newcomp("eventtesting", file, exec)
+
+        trans = assert_events(comp, [:file_created], "events")
+
+        assert_equal(1, trans.triggered?(exec, :refresh))
+    end
+
+    def test_simplerequire
+        file = Puppet::Type::PFile.create(
+            :name => "/tmp/eventtestingA",
+            :create => true
+        )
+        exec = Puppet::Type::Exec.create(
+            :name => "echo true",
+            :path => "/usr/bin:/bin",
+            :refreshonly => true,
+            :require => [[file.class.name, file.name]] 
+        )
+
+        @@tmpfiles << "/tmp/eventtestingA"
+
+        comp = Puppet::Type::Component.create(
+            :name => "eventtesting"
+        )
+        comp.push exec
+        trans = comp.evaluate
+        events = nil
+        assert_nothing_raised {
+            events = trans.evaluate
+        }
+
+        assert_equal(1, events.length)
+
+        assert_equal(0, trans.triggered?(exec, :refresh))
+    end
+
+    def test_zladderrequire
+        comps = {}
+        objects = {}
+        fname = "/tmp/eventtestfuntest"
+        [:a, :b].each { |l|
+            case l
+            when :a
+                name = "/tmp/eventtesting%s" % l
+                objects[l] = Puppet::Type::PFile.create(
+                    :name => name,
+                    :create => true
+                )
+                @@tmpfiles << name
+            when :b
+                objects[l] = Puppet::Type::Exec.create(
+                    :name => "touch %s" % fname,
+                    :path => "/usr/bin:/bin",
+                    :refreshonly => true
+                )
+                @@tmpfiles << fname
+            end
+
+
+            comps[l] = Puppet::Type::Component.create(
+                :name => "eventtesting%s" % l
+            )
+
+            comps[l].push objects[l]
+        }
+
+        comps[:b][:subscribe] = [[comps[:a].class.name, comps[:a].name]]
+
+        trans = comps[:a].evaluate
+        events = nil
+        assert_nothing_raised {
+            events = trans.evaluate
+        }
+
+        assert(FileTest.exists?(fname))
+        #assert_equal(events.length, trans.triggered?(objects[:b], :refresh))
+    end
+end