puppet 0.9.2

data/test/other/state.rb

@@ -0,0 +1,106 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppettest'
+require 'puppet/storage'
+require 'test/unit'
+
+# $Id: state.rb 724 2005-10-22 22:27:20Z luke $
+
+class StorageTestingClass
+end
+
+class TestStorage < Test::Unit::TestCase
+	include TestPuppet
+    def disabled_setup
+        Puppet[:loglevel] = :debug if __FILE__ == $0
+        Puppet[:checksumfile] = "/var/tmp/puppetteststate"
+
+        @oldconf = Puppet[:puppetconf]
+        Puppet[:puppetconf] = "/tmp/storagetesting"
+        @oldvar = Puppet[:puppetvar]
+        Puppet[:puppetvar] = "/tmp/storagetesting"
+
+        @@tmpfiles << "/tmp/storagetesting"
+    end
+
+    def teardown
+        #system("rm -f %s" % Puppet[:checksumfile])
+        Puppet::Storage.clear
+
+        #Puppet[:puppetconf] = @oldconf
+        #Puppet[:puppetvar] = @oldvar
+        super
+    end
+
+    def test_simple
+        state = nil
+        assert_nothing_raised {
+            Puppet::Storage.load
+        }
+        assert_nothing_raised {
+            state = Puppet::Storage.state(Puppet::Type)
+        }
+        assert(state)
+        state["/etc/passwd"] = ["md5","9ebebe0c02445c40b9dc6871b64ee416"]
+        assert_nothing_raised {
+            Puppet::Storage.store
+        }
+
+        # clear the memory, so we're sure we're hitting the state file
+        assert_nothing_raised {
+            Puppet::Storage.clear
+            Puppet::Storage.init
+        }
+        assert_nothing_raised {
+            Puppet::Storage.load
+        }
+        assert_equal(
+            ["md5","9ebebe0c02445c40b9dc6871b64ee416"],
+            Puppet::Storage.state(Puppet::Type)["/etc/passwd"]
+        )
+    end
+
+    def test_instance
+        file = nil
+        state = nil
+        assert_nothing_raised {
+            file = Puppet::Type::PFile.create(
+                :path => "/etc/passwd"
+            )
+        }
+        assert_nothing_raised {
+            Puppet::Storage.load
+        }
+        assert_nothing_raised {
+            state = Puppet::Storage.state(file)
+        }
+        assert(state)
+    end
+
+    def test_update
+        state = Puppet::Storage.state(StorageTestingClass)
+        state["testing"] = "yayness"
+        Puppet::Storage.store
+        assert(FileTest.exists?(Puppet[:checksumfile]))
+    end
+
+    def test_hashstorage
+        state = Puppet::Storage.state(StorageTestingClass)
+        hash = {
+            :yay => "boo",
+            :rah => "foo"
+        }
+        state["testing"] = hash
+        Puppet::Storage.store
+        Puppet::Storage.clear
+        Puppet::Storage.init
+        Puppet::Storage.load
+        state = Puppet::Storage.state(StorageTestingClass)
+        assert_equal(hash, state["testing"])
+    end
+end

data/test/other/storage.rb

@@ -0,0 +1,39 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestParsedFile < Test::Unit::TestCase
+	include TestPuppet
+
+    def test_storeandretrieve
+        hash = {:a => :b, :c => :d}
+
+        state = nil
+        assert_nothing_raised {
+            state = Puppet::Storage.state(hash)
+        }
+
+        assert(!state.include?("name"))
+
+        assert_nothing_raised {
+            state["name"] = hash
+        }
+
+        assert_nothing_raised {
+            Puppet::Storage.store
+        }
+        assert_nothing_raised {
+            state = Puppet::Storage.state(hash)
+        }
+
+        assert_equal(state["name"], hash)
+    end
+end
+
+# $Id: storage.rb 742 2005-11-16 17:12:11Z luke $

data/test/other/transactions.rb

@@ -0,0 +1,235 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: transactions.rb 747 2005-11-22 03:54:30Z luke $
+
+class TestTransactions < Test::Unit::TestCase
+	include FileTesting
+    def ingroup(gid)
+        require 'etc'
+        begin
+            group = Etc.getgrgid(gid)
+        rescue => detail
+            puts "Could not retrieve info for group %s: %s" % [gid, detail]
+            return nil
+        end
+
+        return @groups.include?(group.name)
+    end
+
+    def setup
+        super
+        @groups = %x{groups}.chomp.split(/ /)
+        unless @groups.length > 1
+            p @groups
+            raise "You must be a member of more than one group to test this"
+        end
+    end
+
+    def teardown
+        Puppet::Type::Service.each { |serv|
+            serv[:running] = false
+            serv.sync
+        }
+        #print "\n\n" if Puppet[:debug]
+        super
+    end
+
+    def newfile(hash = {})
+        tmpfile = tempfile()
+        File.open(tmpfile, "w") { |f| f.puts rand(100) }
+
+        # XXX now, because os x apparently somehow allows me to make a file
+        # owned by a group i'm not a member of, i have to verify that
+        # the file i just created is owned by one of my groups
+        # grrr
+        unless ingroup(File.stat(tmpfile).gid)
+            Puppet.info "Somehow created file in non-member group %s; fixing" %
+                File.stat(tmpfile).gid
+
+            require 'etc'
+            firstgr = @groups[0]
+            unless firstgr.is_a?(Integer)
+                str = Etc.getgrnam(firstgr)
+                firstgr = str.gid
+            end
+            File.chown(nil, firstgr, tmpfile)
+        end
+
+        @@tmpfiles.push tmpfile
+        hash[:name] = tmpfile
+        assert_nothing_raised() {
+            return Puppet::Type::PFile.create(hash)
+        }
+    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 => [:running]
+            )
+        }
+    end
+
+    def newexec(file)
+        assert_nothing_raised() {
+            return Puppet::Type::Exec.create(
+                :name => "touch %s" % file,
+                :path => "/bin:/usr/bin:/sbin:/usr/sbin",
+                :returns => 0
+            )
+        }
+    end
+
+    # modify a file and then roll the modifications back
+    def test_filerollback
+        transaction = nil
+        file = newfile()
+
+        states = {}
+        check = [:group,:mode]
+        file[:check] = check
+
+        assert_nothing_raised() {
+            file.retrieve
+        }
+
+        assert_nothing_raised() {
+            check.each { |state|
+                assert(file[state])
+                states[state] = file[state]
+            }
+        }
+
+
+        component = newcomp("file",file)
+        require 'etc'
+        groupname = Etc.getgrgid(File.stat(file.name).gid).name
+        assert_nothing_raised() {
+            # Find a group that it's not set to
+            group = @groups.find { |group| group != groupname }
+            unless group
+                raise "Could not find suitable group"
+            end
+            file[:group] = group
+
+            file[:mode] = "755"
+        }
+        trans = assert_events(component, [:inode_changed, :inode_changed], "file")
+
+        assert_rollback_events(trans, [:inode_changed, :inode_changed], "file")
+
+        assert_nothing_raised() {
+            file.retrieve
+        }
+        states.each { |state,value|
+            assert_equal(
+                value,file.is(state), "File %s remained %s" % [state, file.is(state)]
+            )
+        }
+    end
+
+    # start a service, and then roll the modification back
+    def test_servicetrans
+        transaction = nil
+        service = newservice()
+
+        component = newcomp("service",service)
+
+        assert_nothing_raised() {
+            service[:running] = 1
+        }
+        trans = assert_events(component, [:service_started], "file")
+
+        assert_rollback_events(trans, [:service_stopped], "file")
+    end
+
+    # test that services are correctly restarted and that work is done
+    # in the right order
+    def test_refreshing
+        transaction = nil
+        file = newfile()
+        execfile = File.join(tmpdir(), "exectestingness")
+        exec = newexec(execfile)
+        states = {}
+        check = [:group,:mode]
+        file[:check] = check
+
+        @@tmpfiles << execfile
+
+        component = newcomp("both",file,exec)
+
+        # 'subscribe' expects an array of arrays
+        exec[:subscribe] = [[file.class.name,file.name]]
+        exec[:refreshonly] = true
+
+        assert_nothing_raised() {
+            file.retrieve
+            exec.retrieve
+        }
+
+        check.each { |state|
+            states[state] = file[state]
+        }
+        assert_nothing_raised() {
+            file[:mode] = "755"
+        }
+
+        trans = assert_events(component,
+            [:inode_changed], "testboth")
+
+        assert(FileTest.exists?(execfile), "Execfile does not exist")
+        File.unlink(execfile)
+        assert_nothing_raised() {
+            file[:group] = @groups[1]
+        }
+
+        trans = assert_events(component,
+            [:inode_changed], "testboth")
+        assert(FileTest.exists?(execfile), "Execfile does not exist")
+    end
+
+    def test_zrefreshAcrossTwoComponents
+        transaction = nil
+        file = newfile()
+        execfile = File.join(tmpdir(), "exectestingness2")
+        @@tmpfiles << execfile
+        exec = newexec(execfile)
+        states = {}
+        check = [:group,:mode]
+        file[:check] = check
+
+        fcomp = newcomp("file",file)
+        ecomp = newcomp("exec",exec)
+
+        component = newcomp("both",fcomp,ecomp)
+
+        # 'subscribe' expects an array of arrays
+        #component[:require] = [[file.class.name,file.name]]
+        ecomp[:subscribe] = [[fcomp.class.name,fcomp.name]]
+        exec[:refreshonly] = true
+
+        trans = assert_events(component, [], "subscribe1")
+
+        assert_nothing_raised() {
+            file[:group] = @groups[1]
+            file[:mode] = "755"
+        }
+
+        trans = assert_events(component, [:inode_changed, :inode_changed],
+            "subscribe2")
+
+    end
+
+end

data/test/parser/lexer.rb

@@ -0,0 +1,120 @@
+if __FILE__ == $0
+    $:.unshift '../../lib'
+    $:.unshift '..'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/parser/lexer'
+require 'test/unit'
+require 'puppettest.rb'
+
+#%q{service("telnet") = \{
+#    port => "23",
+#    protocol => "tcp",
+#    name => "telnet",
+#\}
+#} => [[:NAME, "service"], [:LPAREN, "("], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:RPAREN, ")"], [:EQUALS, "="], [:lbrace, "{"], [:NAME, "port"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "23"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "protocol"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "tcp"], [:DQUOTE, "\""], [:COMMA, ","], [:NAME, "name"], [:FARROW, "=>"], [:DQUOTE, "\""], [:NAME, "telnet"], [:DQUOTE, "\""], [:COMMA, ","], [:RBRACE, "}"]]
+
+class TestLexer < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @lexer = Puppet::Parser::Lexer.new()
+    end
+
+    def test_simple_lex
+        strings = {
+%q{\\} => [[:BACKSLASH,"\\"],[false,false]],
+%q{simplest scanner test} => [[:NAME,"simplest"],[:NAME,"scanner"],[:NAME,"test"],[false,false]],
+%q{returned scanner test
+} => [[:NAME,"returned"],[:NAME,"scanner"],[:NAME,"test"],[false,false]]
+        }
+        strings.each { |str,ary|
+            @lexer.string = str
+            assert_equal(
+                ary,
+                @lexer.fullscan()
+            )
+        }
+    end
+
+    def test_quoted_strings
+        strings = {
+%q{a simple "scanner" test
+} => [[:NAME,"a"],[:NAME,"simple"],[:QTEXT,"scanner"],[:NAME,"test"],[false,false]],
+%q{a harder "scanner test"
+} => [[:NAME,"a"],[:NAME,"harder"],[:QTEXT,"scanner test"],[false,false]],
+%q{a hardest "scanner \"test\""
+} => [[:NAME,"a"],[:NAME,"hardest"],[:QTEXT,'scanner "test"'],[false,false]],
+%q{function("call")} => [[:NAME,"function"],[:LPAREN,"("],[:QTEXT,'call'],[:RPAREN,")"],[false,false]]
+}
+        strings.each { |str,array|
+            @lexer.string = str
+            assert_equal(
+                array,
+                @lexer.fullscan()
+            )
+        }
+    end
+
+    def test_errors
+        strings = %w{
+            ^
+            @
+        }
+        strings.each { |str|
+            @lexer.string = str
+            assert_raise(RuntimeError) {
+                @lexer.fullscan()
+            }
+        }
+    end
+
+    def test_more_error
+        assert_raise(TypeError) {
+            @lexer.fullscan()
+        }
+    end
+
+    def test_files
+        textfiles() { |file|
+            @lexer.file = file
+            assert_nothing_raised() {
+                @lexer.fullscan()
+            }
+            Puppet::Type.allclear
+        }
+    end
+
+    def test_strings
+        names = %w{this is a bunch of names}
+        types = %w{Many Different Words A Word}
+        words = %w{differently Cased words A a}
+
+        names.each { |t|
+            @lexer.string = t
+            assert_equal(
+                [[:NAME,t],[false,false]],
+                @lexer.fullscan
+            )
+        }
+        types.each { |t|
+            @lexer.string = t
+            assert_equal(
+                [[:TYPE,t],[false,false]],
+                @lexer.fullscan
+            )
+        }
+    end
+
+    def test_emptystring
+        bit = '$var = ""'
+
+        assert_nothing_raised {
+            @lexer.string = bit
+        }
+    end
+end
+
+# $Id: lexer.rb 724 2005-10-22 22:27:20Z luke $