puppet 0.9.2

data/test/types/query.rb

@@ -0,0 +1,101 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: query.rb 742 2005-11-16 17:12:11Z luke $
+
+class TestQuery < Test::Unit::TestCase
+    include TestPuppet
+    # hmmm
+    # this is complicated, because we store references to the created
+    # objects in a central store
+    def file
+        assert_nothing_raised() {
+            cfile = File.join($puppetbase,"examples/root/etc/configfile")
+            unless Puppet::Type::PFile.has_key?(cfile)
+                Puppet::Type::PFile.create(
+                    :path => cfile,
+                    :check => [:mode, :owner, :checksum]
+                )
+            end
+            @configfile = Puppet::Type::PFile[cfile]
+        }
+        return @configfile
+    end
+
+    def service
+        assert_nothing_raised() {
+            unless Puppet::Type::Service.has_key?("sleeper")
+                Puppet::Type::Service.create(
+                    :name => "sleeper",
+                    :type => "init",
+                    :path => File.join($puppetbase,"examples/root/etc/init.d"),
+                    :hasstatus => true,
+                    :check => [:running]
+                )
+            end
+            @sleeper = Puppet::Type::Service["sleeper"]
+        }
+
+        return @sleeper
+    end
+
+    def component(name,*args)
+        assert_nothing_raised() {
+            @component = Puppet::Type::Component.create(:name => name)
+        }
+
+        args.each { |arg|
+            assert_nothing_raised() {
+                @component.push arg
+            }
+        }
+
+        return @component
+    end
+
+    def test_file
+        yayfile = file()
+        #p yayfile
+        yayfile.eachstate { |state|
+            assert_nil(state.is)
+        }
+
+        assert_nothing_raised() {
+            yayfile.retrieve
+        }
+
+        assert_nothing_raised() {
+            yayfile[:check] = :group
+        }
+
+        assert_nothing_raised() {
+            yayfile.retrieve
+        }
+    end
+
+    def test_service
+        service = service()
+        service.eachstate { |state|
+            assert_nil(state.is)
+        }
+
+        assert_nothing_raised() {
+            service.retrieve
+        }
+    end
+
+    def test_component
+        component = component("a",file(),service())
+
+        assert_nothing_raised() {
+            component.retrieve
+        }
+    end
+end

data/test/types/service.rb

@@ -0,0 +1,100 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+class TestService < Test::Unit::TestCase
+	include TestPuppet
+    # hmmm
+    # this is complicated, because we store references to the created
+    # objects in a central store
+    def setup
+        super
+        sleeper = nil
+        script = File.join($puppetbase,"examples/root/etc/init.d/sleeper")
+        @status = script + " status"
+    end
+
+    def teardown
+        super
+        stopservices
+    end
+
+    def mksleeper(hash = {})
+        hash[:name] = "sleeper"
+        hash[:path] = File.join($puppetbase,"examples/root/etc/init.d")
+        hash[:running] = true
+        hash[:type] = "init"
+        assert_nothing_raised() {
+            return Puppet::Type::Service.create(hash)
+        }
+    end
+
+    def cyclesleeper(sleeper)
+        assert_nothing_raised() {
+            sleeper.retrieve
+        }
+        assert(!sleeper.insync?())
+        assert_nothing_raised() {
+            sleeper.sync
+        }
+        assert_nothing_raised() {
+            sleeper.retrieve
+        }
+        assert(sleeper.insync?)
+
+        # test refreshing it
+        assert_nothing_raised() {
+            sleeper.refresh
+        }
+
+        assert(sleeper.respond_to?(:refresh))
+
+        # now stop it
+        assert_nothing_raised() {
+            sleeper[:running] = 0
+        }
+        assert_nothing_raised() {
+            sleeper.retrieve
+        }
+        assert(!sleeper.insync?())
+        assert_nothing_raised() {
+            sleeper.sync
+        }
+        assert_nothing_raised() {
+            sleeper.retrieve
+        }
+        assert(sleeper.insync?)
+    end
+
+    def test_processStartWithPattern
+        sleeper = mksleeper(:pattern => "bin/sleeper")
+
+        cyclesleeper(sleeper)
+    end
+
+    def test_processStartWithStatus
+        sleeper = mksleeper(:hasstatus => true)
+        cyclesleeper(sleeper)
+    end
+
+    unless Process.uid == 0
+        puts "run as root to test service enable/disable"
+    else
+        case Puppet::Type::Service.defaulttype
+        when Puppet::ServiceTypes::InitSvc
+        when Puppet::ServiceTypes::SMFSvc
+            # yay
+        else
+            Puppet.notice "Not testing service type %s" %
+                Puppet::Type::Service.defaulttype
+        end
+    end
+end
+
+# $Id: service.rb 742 2005-11-16 17:12:11Z luke $

data/test/types/symlink.rb

@@ -0,0 +1,93 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: symlink.rb 724 2005-10-22 22:27:20Z luke $
+
+class TestSymlink < Test::Unit::TestCase
+	include FileTesting
+    def mktmpfile
+        # because luke's home directory is on nfs, it can't be used for testing
+        # as root
+        tmpfile = tempfile()
+        File.open(tmpfile, "w") { |f| f.puts rand(100) }
+        @@tmpfiles.push tmpfile
+        return tmpfile
+    end
+
+    def mktmpdir
+        dir = File.join(tmpdir(), "puppetlinkdir")
+        unless FileTest.exists?(dir)
+            Dir.mkdir(dir)
+        end
+        @@tmpfiles.push dir
+        return dir
+    end
+
+    def tmplink
+        link = File.join(tmpdir(), "puppetlinktest")
+        @@tmpfiles.push link
+        return link
+    end
+
+    def newlink(hash = {})
+        hash[:name] = tmplink()
+        unless hash.include?(:target)
+            hash[:target] = mktmpfile()
+        end
+        link = Puppet::Type::Symlink.create(hash)
+        return link
+    end
+
+    def test_target
+        link = nil
+        file = mktmpfile()
+        assert_nothing_raised() {
+            link = newlink()
+        }
+        assert_nothing_raised() {
+            link.retrieve
+        }
+        # we might already be in sync
+        assert(!link.insync?())
+        assert_nothing_raised() {
+            link.sync
+        }
+        assert_nothing_raised() {
+            link.retrieve
+        }
+        assert(link.insync?())
+    end
+
+    def test_recursion
+        source = mktmpdir()
+        FileUtils.cd(source) {
+            mkranddirsandfiles()
+        }
+
+        link = nil
+        assert_nothing_raised {
+            link = newlink(:target => source, :recurse => true)
+        }
+        comp = newcomp("linktest",link)
+        cycle(comp)
+
+        path = link.name
+        list = file_list(path)
+        FileUtils.cd(path) {
+            list.each { |file|
+                unless FileTest.directory?(file)
+                    assert(FileTest.symlink?(file))
+                    target = File.readlink(file)
+                    assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
+                end
+            }
+        }
+    end
+end

data/test/types/tidy.rb

@@ -0,0 +1,124 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../../../../language/trunk"
+end
+
+require 'puppet'
+require 'puppettest'
+require 'test/unit'
+
+# $Id: tidy.rb 724 2005-10-22 22:27:20Z luke $
+
+class TestTidy < Test::Unit::TestCase
+	include FileTesting
+    def mktmpfile
+        # because luke's home directory is on nfs, it can't be used for testing
+        # as root
+        tmpfile = tempfile()
+        File.open(tmpfile, "w") { |f| f.puts rand(100) }
+        @@tmpfiles.push tmpfile
+        return tmpfile
+    end
+
+    def mktmpdir
+        dir = File.join(tmpdir(), "puppetlinkdir")
+        unless FileTest.exists?(dir)
+            Dir.mkdir(dir)
+        end
+        @@tmpfiles.push dir
+        return dir
+    end
+
+    def test_simpletidy
+        dir = mktmpdir
+        file = File.join(dir, "tidytesting")
+        File.open(file, "w") { |f|
+            f.puts rand(100)
+        }
+
+        tidy = Puppet::Type::Tidy.create(
+            :name => dir,
+            :size => "1b",
+            :recurse => true
+        )
+
+        comp = newcomp("tidytesting", tidy)
+
+        trans = nil
+        assert_nothing_raised {
+            trans = comp.evaluate
+        }
+        event = nil
+        assert_nothing_raised {
+            event = trans.evaluate.collect { |e| e.event }
+        }
+
+        assert_equal(1, event.length, "Got no events on tidy")
+        assert_equal([:file_tidied], event, "Got incorrect event on tidy")
+
+        assert(!FileTest.exists?(file), "Tidied file still exists")
+    end
+
+    def test_tidydirs
+        dir = mktmpdir
+        file = File.join(dir, "tidytesting")
+        File.open(file, "w") { |f|
+            f.puts rand(100)
+        }
+
+        tidy = Puppet::Type::Tidy.create(
+            :name => dir,
+            :size => "1b",
+            :age => "1s",
+            :rmdirs => true,
+            :recurse => true
+        )
+
+        comp = newcomp("tidytesting", tidy)
+
+        sleep(2)
+        trans = nil
+        assert_nothing_raised {
+            trans = comp.evaluate
+        }
+        event = nil
+        assert_nothing_raised {
+            event = trans.evaluate.collect { |e| e.event }
+        }
+
+        assert(!FileTest.exists?(file), "Tidied %s still exists" % file)
+        assert(!FileTest.exists?(dir), "Tidied %s still exists" % dir)
+
+        assert_equal(2, event.length, "Got %s events instead of %s on tidy" %
+            [event.length, 2])
+        assert_equal([:file_tidied, :file_tidied], event,
+            "Got incorrect events on tidy")
+    end
+
+    def disabled_test_recursion
+        source = mktmpdir()
+        FileUtils.cd(source) {
+            mkranddirsandfiles()
+        }
+
+        link = nil
+        assert_nothing_raised {
+            link = newlink(:target => source, :recurse => true)
+        }
+        comp = newcomp("linktest",link)
+        cycle(comp)
+
+        path = link.name
+        list = file_list(path)
+        FileUtils.cd(path) {
+            list.each { |file|
+                unless FileTest.directory?(file)
+                    assert(FileTest.symlink?(file))
+                    target = File.readlink(file)
+                    assert_equal(target,File.join(source,file.sub(/^\.\//,'')))
+                end
+            }
+        }
+    end
+end

data/test/types/type.rb

@@ -0,0 +1,135 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestType < Test::Unit::TestCase
+	include TestPuppet
+    def test_typemethods
+        assert_nothing_raised() {
+            Puppet::Type.buildstatehash
+        }
+
+        Puppet::Type.eachtype { |type|
+            name = nil
+            assert_nothing_raised("Searching for name for %s caused failure" %
+                type.to_s) {
+                    name = type.name
+            }
+
+            assert(name, "Could not find name for %s" % type.to_s)
+
+            assert_equal(
+                type,
+                Puppet::Type.type(name),
+                "Failed to retrieve %s by name" % name
+            )
+
+            assert(
+                type.namevar,
+                "Failed to retrieve namevar for %s" % name
+            )
+
+            assert_not_nil(
+                type.states,
+                "States for %s are nil" % name
+            )
+
+            assert_not_nil(
+                type.validstates,
+                "Valid states for %s are nil" % name
+            )
+        }
+    end
+
+    def test_stringvssymbols
+        file = nil
+        path = tempfile()
+        assert_nothing_raised() {
+            system("rm -f %s" % path)
+            file = Puppet::Type::PFile.create(
+                :path => path,
+                :create => true,
+                :recurse => true,
+                :checksum => "md5"
+            )
+        }
+        assert_nothing_raised() {
+            file.retrieve
+        }
+        assert_nothing_raised() {
+            file.sync
+        }
+        Puppet::Type::PFile.clear
+        assert_nothing_raised() {
+            system("rm -f %s" % path)
+            file = Puppet::Type::PFile.create(
+                "path" => path,
+                "create" => true,
+                "recurse" => true,
+                "checksum" => "md5"
+            )
+        }
+        assert_nothing_raised() {
+            file.retrieve
+        }
+        assert_nothing_raised() {
+            file[:path]
+        }
+        assert_nothing_raised() {
+            file["path"]
+        }
+        assert_nothing_raised() {
+            file[:recurse]
+        }
+        assert_nothing_raised() {
+            file["recurse"]
+        }
+        assert_nothing_raised() {
+            file.sync
+        }
+    end
+
+    # This was supposed to test objects whose name was a state, but that
+    # fundamentally doesn't make much sense, and we now don't have any such
+    # types.
+    def disabled_test_nameasstate
+        # currently groups are the only objects with the namevar as a state
+        group = nil
+        assert_nothing_raised {
+            group = Puppet::Type::Group.create(
+                :name => "testing"
+            )
+        }
+
+        assert_equal("testing", group.name, "Could not retrieve name")
+    end
+
+    # Verify that values get merged correctly
+    def test_mergestatevalues
+        file = tempfile()
+
+        # Create the first version
+        assert_nothing_raised {
+            Puppet::Type::PFile.create(
+                :path => file,
+                :owner => ["root", "bin"]
+            )
+        }
+
+        # Make sure no other statements are allowed
+        assert_raise(Puppet::Error) {
+            Puppet::Type::PFile.create(
+                :path => file,
+                :group => "root"
+            )
+        }
+    end
+end
+
+# $Id: type.rb 737 2005-10-30 04:07:52Z luke $