puppet 0.9.2 → 0.13.0

data/test/types/service.rb

@@ -8,15 +8,23 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-class TestService < Test::Unit::TestCase
+$skipsvcs = false
+case Facter["operatingsystem"].value
+when "Darwin", "OpenBSD": $skipsvcs = true
+end
+
+if $skipsvcs
+    puts "Skipping service testing on %s" % Facter["operatingsystem"].value
+else
+#class TestInitService < Test::Unit::TestCase
+class TestInitService
 	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")
+        @init = File.join($puppetbase,"examples/root/etc/init.d")
         @status = script + " status"
     end
 
@@ -25,13 +33,21 @@ class TestService < Test::Unit::TestCase
         stopservices
     end
 
+    def tstsvcs
+        case Facter["operatingsystem"].value
+        when "Solaris":
+            return ["smtp", "xf"]
+        end
+    end
+
     def mksleeper(hash = {})
         hash[:name] = "sleeper"
         hash[:path] = File.join($puppetbase,"examples/root/etc/init.d")
         hash[:running] = true
-        hash[:type] = "init"
+        hash[:hasstatus] = true
+        #hash[:type] = "init"
         assert_nothing_raised() {
-            return Puppet::Type::Service.create(hash)
+            return Puppet.type(:service).create(hash)
         }
     end
 
@@ -40,9 +56,10 @@ class TestService < Test::Unit::TestCase
             sleeper.retrieve
         }
         assert(!sleeper.insync?())
-        assert_nothing_raised() {
-            sleeper.sync
-        }
+
+        comp = newcomp(sleeper)
+
+        assert_events([:service_started], comp)
         assert_nothing_raised() {
             sleeper.retrieve
         }
@@ -63,9 +80,7 @@ class TestService < Test::Unit::TestCase
             sleeper.retrieve
         }
         assert(!sleeper.insync?())
-        assert_nothing_raised() {
-            sleeper.sync
-        }
+        assert_events([:service_stopped], comp)
         assert_nothing_raised() {
             sleeper.retrieve
         }
@@ -83,18 +98,119 @@ class TestService < Test::Unit::TestCase
         cyclesleeper(sleeper)
     end
 
+    def test_invalidpathsremoved
+        sleeper = mksleeper()
+        fakedir = [@init, "/thisdirnoexist"]
+        sleeper[:path] = fakedir
+
+        assert(! sleeper[:path].include?(fakedir))
+    end
+end
+
+class TestLocalService < Test::Unit::TestCase
+	include TestPuppet
+
+    def teardown
+        Puppet.type(:service).clear
+        super
+    end
+
+    def mktestsvcs
+        tstsvcs.collect { |svc|
+            Puppet.type(:service).create(
+                :name => svc,
+                :check => [:running]
+            )
+        }
+    end
+
+    def tstsvcs
+        case Facter["operatingsystem"].value
+        when "Solaris":
+            case Facter["operatingsystemrelease"].value
+            when "5.10":
+                return ["smtp", "xfs"]
+            end
+        end
+
+        Puppet.notice "No test services for %s-%s" %
+            [Facter["operatingsystem"].value,
+                Facter["operatingsystemrelease"].value]
+        return []
+    end
+
+    def cycleservice(service)
+        assert_nothing_raised() {
+            service.retrieve
+        }
+
+        comp = newcomp("servicetst", service)
+        service[:running] = true
+
+        Puppet.info "Starting %s" % service.name
+        assert_apply(service)
+
+        # Some package systems background the work, so we need to give them
+        # time to do their work.
+        sleep(1.5)
+        assert_nothing_raised() {
+            service.retrieve
+        }
+        assert(service.insync?, "Service %s is not running" % service.name)
+
+        # test refreshing it
+        assert_nothing_raised() {
+            service.refresh
+        }
+
+        assert(service.respond_to?(:refresh))
+
+        # now stop it
+        assert_nothing_raised() {
+            service[:running] = 0
+        }
+        assert_nothing_raised() {
+            service.retrieve
+        }
+        assert(!service.insync?(), "Service %s is not running" % service.name)
+        Puppet.info "stopping %s" % service.name
+        assert_events([:service_stopped], comp)
+        sleep(1.5)
+        assert_nothing_raised() {
+            service.retrieve
+        }
+        assert(service.insync?, "Service %s has not stopped" % service.name)
+    end
+
+    def test_status
+        mktestsvcs.each { |svc|
+            val = nil
+            assert_nothing_raised("Could not get status") {
+                val = svc.status
+            }
+            assert_instance_of(Symbol, val)
+        }
+    end
+
     unless Process.uid == 0
-        puts "run as root to test service enable/disable"
+        puts "run as root to test service start/stop"
     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
+        def test_servicestartstop
+            mktestsvcs.each { |svc|
+                startstate = nil
+                assert_nothing_raised("Could not get status") {
+                    startstate = svc.status
+                }
+                cycleservice(svc)
+
+                svc[:running] = startstate
+                assert_apply(svc)
+                Puppet.type(:service).clear
+                Puppet.type(:component).clear
+            }
         end
     end
 end
+end
 
-# $Id: service.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: service.rb 809 2006-01-12 07:08:19Z luke $

data/test/types/sshkey.rb

@@ -0,0 +1,140 @@
+# Test key job creation, modification, and destruction
+
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'puppet/type/parsedtype/sshkey'
+require 'test/unit'
+require 'facter'
+
+class TestSSHKey < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        # god i'm lazy
+        @sshtype = Puppet.type(:sshkey)
+        @oldfiletype = @sshtype.filetype
+    end
+
+    def teardown
+        @sshtype.filetype = @oldfiletype
+        Puppet.type(:file).clear
+        super
+    end
+
+    # Here we just create a fake key type that answers to all of the methods
+    # but does not modify our actual system.
+    def mkfaketype
+        @sshtype.filetype = Puppet::FileType.filetype(:ram)
+    end
+
+    def mkkey
+        key = nil
+        assert_nothing_raised {
+            key = @sshtype.create(
+                :name => "culain.madstop.com",
+                :key => "AAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=",
+                :type => "ssh-dss",
+                :alias => ["192.168.0.3"]
+            )
+        }
+
+        return key
+    end
+
+    def test_simplekey
+        mkfaketype
+        assert_nothing_raised {
+            assert_nil(Puppet.type(:sshkey).retrieve)
+        }
+
+        key = mkkey
+
+        assert_apply(key)
+
+        assert_nothing_raised {
+            Puppet.type(:sshkey).store
+        }
+
+        assert_nothing_raised {
+            assert(
+                Puppet.type(:sshkey).to_file.include?(
+                    Puppet.type(:sshkey).fileobj.read
+                ),
+                "File does not include all of our objects"
+            )
+        }
+    end
+
+    def test_keysparse
+        fakedata("data/types/sshkey").each { |file|
+            @sshtype.path = file
+            assert_nothing_raised {
+                @sshtype.retrieve
+            }
+            @sshtype.clear
+        }
+    end
+
+    def test_moddingkey
+        mkfaketype
+        key = mkkey()
+
+        assert_events([:sshkey_created], key)
+
+        key.retrieve
+
+        key[:alias] = %w{madstop kirby yayness}
+
+        Puppet.err :mark
+        assert_events([:sshkey_changed], key)
+    end
+
+    def test_aliasisstate
+        assert_equal(:state, @sshtype.attrtype(:alias))
+    end
+
+    def test_multivalues
+        key = mkkey
+        assert_raise(Puppet::Error) {
+            key[:alias] = "puppetmasterd yayness"
+        }
+    end
+
+    def test_puppetalias
+        key = mkkey()
+
+        assert_nothing_raised {
+            key[:alias] = "testing"
+        }
+
+        same = key.class["testing"]
+        assert(same, "Could not retrieve by alias")
+    end
+
+    def test_removal
+        mkfaketype
+        sshkey = mkkey()
+        assert_nothing_raised {
+            sshkey[:ensure] = :present
+        }
+        assert_events([:sshkey_created], sshkey)
+
+        sshkey.retrieve
+        assert(sshkey.insync?)
+        assert_nothing_raised {
+            sshkey[:ensure] = :absent
+        }
+
+        assert_events([:sshkey_removed], sshkey)
+        sshkey.retrieve
+        assert_events([], sshkey)
+    end
+end
+
+# $Id: sshkey.rb 831 2006-01-16 20:01:20Z luke $

data/test/types/symlink.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: symlink.rb 724 2005-10-22 22:27:20Z luke $
+# $Id: symlink.rb 787 2006-01-08 00:02:23Z luke $
 
 class TestSymlink < Test::Unit::TestCase
 	include FileTesting
@@ -41,7 +41,7 @@ class TestSymlink < Test::Unit::TestCase
         unless hash.include?(:target)
             hash[:target] = mktmpfile()
         end
-        link = Puppet::Type::Symlink.create(hash)
+        link = Puppet.type(:symlink).create(hash)
         return link
     end
 
@@ -56,9 +56,7 @@ class TestSymlink < Test::Unit::TestCase
         }
         # we might already be in sync
         assert(!link.insync?())
-        assert_nothing_raised() {
-            link.sync
-        }
+        assert_apply(link)
         assert_nothing_raised() {
             link.retrieve
         }

data/test/types/tidy.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: tidy.rb 724 2005-10-22 22:27:20Z luke $
+# $Id: tidy.rb 831 2006-01-16 20:01:20Z luke $
 
 class TestTidy < Test::Unit::TestCase
 	include FileTesting
@@ -37,26 +37,17 @@ class TestTidy < Test::Unit::TestCase
             f.puts rand(100)
         }
 
-        tidy = Puppet::Type::Tidy.create(
+        tidy = Puppet.type(:tidy).create(
             :name => dir,
             :size => "1b",
             :recurse => true
         )
+        Puppet::Type.finalize
 
         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_events([:file_tidied], comp)
         assert(!FileTest.exists?(file), "Tidied file still exists")
     end
 
@@ -67,7 +58,7 @@ class TestTidy < Test::Unit::TestCase
             f.puts rand(100)
         }
 
-        tidy = Puppet::Type::Tidy.create(
+        tidy = Puppet.type(:tidy).create(
             :name => dir,
             :size => "1b",
             :age => "1s",

data/test/types/type.rb

@@ -30,6 +30,11 @@ class TestType < Test::Unit::TestCase
                 "Failed to retrieve %s by name" % name
             )
 
+            # Skip types with no parameters or valid states
+            #unless ! type.parameters.empty? or ! type.validstates.empty?
+            #    next
+            #end
+
             assert(
                 type.namevar,
                 "Failed to retrieve namevar for %s" % name
@@ -52,9 +57,9 @@ class TestType < Test::Unit::TestCase
         path = tempfile()
         assert_nothing_raised() {
             system("rm -f %s" % path)
-            file = Puppet::Type::PFile.create(
+            file = Puppet.type(:file).create(
                 :path => path,
-                :create => true,
+                :ensure => "file",
                 :recurse => true,
                 :checksum => "md5"
             )
@@ -63,14 +68,14 @@ class TestType < Test::Unit::TestCase
             file.retrieve
         }
         assert_nothing_raised() {
-            file.sync
+            file.evaluate
         }
-        Puppet::Type::PFile.clear
+        Puppet.type(:file).clear
         assert_nothing_raised() {
             system("rm -f %s" % path)
-            file = Puppet::Type::PFile.create(
+            file = Puppet.type(:file).create(
                 "path" => path,
-                "create" => true,
+                "ensure" => "file",
                 "recurse" => true,
                 "checksum" => "md5"
             )
@@ -91,7 +96,7 @@ class TestType < Test::Unit::TestCase
             file["recurse"]
         }
         assert_nothing_raised() {
-            file.sync
+            file.evaluate
         }
     end
 
@@ -102,7 +107,7 @@ class TestType < Test::Unit::TestCase
         # currently groups are the only objects with the namevar as a state
         group = nil
         assert_nothing_raised {
-            group = Puppet::Type::Group.create(
+            group = Puppet.type(:group).create(
                 :name => "testing"
             )
         }
@@ -116,7 +121,7 @@ class TestType < Test::Unit::TestCase
 
         # Create the first version
         assert_nothing_raised {
-            Puppet::Type::PFile.create(
+            Puppet.type(:file).create(
                 :path => file,
                 :owner => ["root", "bin"]
             )
@@ -124,12 +129,63 @@ class TestType < Test::Unit::TestCase
 
         # Make sure no other statements are allowed
         assert_raise(Puppet::Error) {
-            Puppet::Type::PFile.create(
+            Puppet.type(:file).create(
                 :path => file,
                 :group => "root"
             )
         }
     end
+
+    # Verify that aliasing works
+    def test_aliasing
+        file = tempfile()
+
+        baseobj = nil
+        assert_nothing_raised {
+            baseobj = Puppet.type(:file).create(
+                :name => file,
+                :ensure => "file",
+                :alias => ["funtest"]
+            )
+        }
+
+        # Verify we adding ourselves as an alias isn't an error.
+        assert_nothing_raised {
+            baseobj[:alias] = file
+        }
+
+        assert_instance_of(Puppet.type(:file), Puppet.type(:file)["funtest"],
+            "Could not retrieve alias")
+
+    end
+
+    # Verify that requirements don't depend on file order
+    def test_prereqorder
+        one = tempfile()
+        two = tempfile()
+
+        twoobj = nil
+        oneobj = nil
+        assert_nothing_raised("Could not create prereq that doesn't exist yet") {
+            twoobj = Puppet.type(:file).create(
+                :name => two,
+                :require => [:file, one]
+            )
+        }
+
+        assert_nothing_raised {
+            oneobj = Puppet.type(:file).create(
+                :name => one
+            )
+        }
+
+        assert_nothing_raised {
+            Puppet::Type.finalize
+        }
+
+
+        assert(twoobj.requires?(oneobj), "Requirement was not created")
+    end
 end
 
-# $Id: type.rb 737 2005-10-30 04:07:52Z luke $
+# $Id: type.rb 832 2006-01-17 07:11:50Z luke $