puppet 0.9.2 → 0.13.0

data/test/types/port.rb

@@ -0,0 +1,139 @@
+# Test host job creation, modification, and destruction
+
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'puppet/type/parsedtype/port'
+require 'test/unit'
+require 'facter'
+
+class TestPort < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @porttype = Puppet.type(:port)
+        @oldfiletype = @porttype.filetype
+    end
+
+    def teardown
+        @porttype.filetype = @oldfiletype
+        Puppet.type(:file).clear
+        super
+    end
+
+    # Here we just create a fake host type that answers to all of the methods
+    # but does not modify our actual system.
+    def mkfaketype
+        @faketype = Puppet::FileType.filetype(:ram)
+        @porttype.filetype = @faketype
+    end
+
+    def mkport
+        port = nil
+        assert_nothing_raised {
+            port = Puppet.type(:port).create(
+                :name => "puppet",
+                :number => "8139",
+                :protocols => "tcp",
+                :description => "The port that Puppet runs on",
+                :alias => "coolness"
+            )
+        }
+
+        return port
+    end
+
+    def test_simpleport
+        mkfaketype
+        host = nil
+        assert_nothing_raised {
+            assert_nil(Puppet.type(:port).retrieve)
+        }
+
+        port = mkport
+
+        assert_nothing_raised {
+            Puppet.type(:port).store
+        }
+
+        assert_nothing_raised {
+            assert(
+                Puppet.type(:port).to_file.include?(
+                    Puppet.type(:port).fileobj.read
+                ),
+                "File does not include all of our objects"
+            )
+        }
+    end
+
+    def test_portsparse
+        fakedata("data/types/ports").each { |file|
+            @porttype.path = file
+            Puppet.info "Parsing %s" % file
+            assert_nothing_raised {
+                @porttype.retrieve
+            }
+
+            # Now just make we've got some ports we know will be there
+            dns = @porttype["domain"]
+            assert(dns, "Could not retrieve DNS port")
+
+            assert_equal("53", dns.is(:number), "DNS number was wrong")
+            %w{udp tcp}.each { |v|
+                assert(dns.is(:protocols).include?(v), "DNS did not include proto %s" % v)
+            }
+
+            @porttype.clear
+        }
+    end
+
+    def test_moddingport
+        mkfaketype
+        port = nil
+        port = mkport
+
+        assert_events([:port_created], port)
+
+        port.retrieve
+
+        port[:protocols] = %w{tcp udp}
+
+        assert_events([:port_changed], port)
+    end
+
+    def test_multivalues
+        port = mkport
+        assert_raise(Puppet::Error) {
+            port[:protocols] = "udp tcp"
+        }
+        assert_raise(Puppet::Error) {
+            port[:alias] = "puppetmasterd yayness"
+        }
+    end
+
+    def test_removal
+        mkfaketype
+        port = mkport()
+        assert_nothing_raised {
+            port[:ensure] = :present
+        }
+        assert_events([:port_created], port)
+
+        port.retrieve
+        assert(port.insync?)
+        assert_nothing_raised {
+            port[:ensure] = :absent
+        }
+
+        assert_events([:port_removed], port)
+        port.retrieve
+        assert_events([], port)
+    end
+end
+
+# $Id: port.rb 831 2006-01-16 20:01:20Z luke $

data/test/types/query.rb

@@ -8,7 +8,7 @@ require 'puppet'
 require 'puppettest'
 require 'test/unit'
 
-# $Id: query.rb 742 2005-11-16 17:12:11Z luke $
+# $Id: query.rb 787 2006-01-08 00:02:23Z luke $
 
 class TestQuery < Test::Unit::TestCase
     include TestPuppet
@@ -18,21 +18,21 @@ class TestQuery < Test::Unit::TestCase
     def file
         assert_nothing_raised() {
             cfile = File.join($puppetbase,"examples/root/etc/configfile")
-            unless Puppet::Type::PFile.has_key?(cfile)
-                Puppet::Type::PFile.create(
+            unless Puppet.type(:file).has_key?(cfile)
+                Puppet.type(:file).create(
                     :path => cfile,
                     :check => [:mode, :owner, :checksum]
                 )
             end
-            @configfile = Puppet::Type::PFile[cfile]
+            @configfile = Puppet.type(:file)[cfile]
         }
         return @configfile
     end
 
     def service
         assert_nothing_raised() {
-            unless Puppet::Type::Service.has_key?("sleeper")
-                Puppet::Type::Service.create(
+            unless Puppet.type(:service).has_key?("sleeper")
+                Puppet.type(:service).create(
                     :name => "sleeper",
                     :type => "init",
                     :path => File.join($puppetbase,"examples/root/etc/init.d"),
@@ -40,7 +40,7 @@ class TestQuery < Test::Unit::TestCase
                     :check => [:running]
                 )
             end
-            @sleeper = Puppet::Type::Service["sleeper"]
+            @sleeper = Puppet.type(:service)["sleeper"]
         }
 
         return @sleeper
@@ -48,7 +48,7 @@ class TestQuery < Test::Unit::TestCase
 
     def component(name,*args)
         assert_nothing_raised() {
-            @component = Puppet::Type::Component.create(:name => name)
+            @component = Puppet.type(:component).create(:name => name)
         }
 
         args.each { |arg|

data/test/types/schedule.rb

@@ -0,0 +1,335 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'test/unit'
+require 'puppet/type/schedule'
+require 'puppettest'
+
+class TestSchedule < Test::Unit::TestCase
+    include TestPuppet
+
+    def setup
+        super
+        @stype = Puppet::Type::Schedule
+
+        # This will probably get overridden by different tests
+        @now = Time.now
+        Puppet[:ignoreschedules] = false
+    end
+
+    def mksched
+        s = nil
+        assert_nothing_raised {
+            s = @stype.create(
+                :name => "testsched"
+            )
+        }
+
+        s
+    end
+
+    def diff(unit, incr, method, count)
+        diff = @now.to_i.send(method, incr * count)
+        t = Time.at(diff)
+
+        #Puppet.notice "%s: %s %s %s = %s" %
+        #    [unit, @now.send(unit), method, count, t]
+        #t.strftime("%H:%M:%S")
+        t
+    end
+
+    def month(method, count)
+        diff(:hour, 3600 * 24 * 30, method, count)
+    end
+
+    def week(method, count)
+        diff(:hour, 3600 * 24 * 7, method, count)
+    end
+
+    def day(method, count)
+        diff(:hour, 3600 * 24, method, count)
+    end
+
+    def hour(method, count)
+        diff(:hour, 3600, method, count)
+    end
+
+    def min(method, count)
+        diff(:min, 60, method, count)
+    end
+
+    def sec(method, count)
+        diff(:sec, 1, method, count)
+    end
+
+    def settimes
+        unless defined? @@times
+            @@times = [Time.now]
+
+            # Make one with an edge year on each side
+            ary = Time.now.to_a
+            [1999, 2000, 2001].each { |y|
+                ary[5] = y; @@times << Time.local(*ary)
+            }
+
+            # And with edge hours
+            ary = Time.now.to_a
+            #[23, 0].each { |h| ary[2] = h; @@times << Time.local(*ary) }
+            # 23 hour
+            ary[2] = 23
+            @@times << Time.local(*ary)
+            # 0 hour, next day
+            ary[2] = 0
+            @@times << addday(Time.local(*ary))
+
+            # And with edge minutes
+            #[59, 0].each { |m| ary[1] = m; @@times << Time.local(*ary) }
+            ary = Time.now.to_a
+            ary[1] = 59; @@times << Time.local(*ary)
+            ary[1] = 0
+            #if ary[2] == 23
+                @@times << Time.local(*ary)
+            #else
+            #    @@times << addday(Time.local(*ary))
+            #end
+        end
+
+        Puppet.err @@times.inspect
+
+        @@times.each { |time|
+            @now = time
+            yield time
+        }
+
+        @now = Time.now
+    end
+
+    def test_range
+        s = mksched
+
+        ary = @now.to_a
+        ary[2] = 12
+        @now = Time.local(*ary)
+        data = {
+            true => [
+                # An hour previous, an hour after
+                [hour("-", 1), hour("+", 1)],
+
+                # an hour previous but a couple minutes later, and an hour plus
+                [min("-", 57), hour("+", 1)]
+            ],
+            false => [
+                # five minutes from now, an hour from now
+                [min("+", 5), hour("+", 1)],
+
+                # an hour ago, 20 minutes ago
+                [hour("-", 1), min("-", 20)]
+            ]
+        }
+
+        data.each { |result, values|
+            values = values.collect { |value|
+                "%s - %s" % [value[0].strftime("%H:%M:%S"),
+                    value[1].strftime("%H:%M:%S")]
+            }
+            values.each { |value|
+                assert_nothing_raised("Could not parse %s" % value) {
+                    s[:range] = value
+                }
+
+                assert_equal(result, s.match?(nil, @now),
+                    "%s matched %s incorrectly" % [value.inspect, @now])
+            }
+
+            assert_nothing_raised("Could not parse %s" % values) {
+                s[:range] = values
+            }
+
+            assert_equal(result, s.match?(nil, @now),
+                "%s matched %s incorrectly" % [values.inspect, @now])
+        }
+    end
+
+    def test_period_by_distance
+        previous = @now
+
+        s = mksched
+
+        assert_nothing_raised {
+            s[:period] = :daily
+        }
+
+        assert(s.match?(day("-", 1)), "did not match minus a day")
+        assert(s.match?(day("-", 2)), "did not match two days")
+        assert(! s.match?(@now), "matched today")
+        assert(! s.match?(hour("-", 11)), "matched minus 11 hours")
+
+        # Now test hourly
+        assert_nothing_raised {
+            s[:period] = :hourly
+        }
+
+        assert(s.match?(hour("-", 1)), "did not match minus an hour")
+        assert(s.match?(hour("-", 2)), "did not match two hours")
+        assert(! s.match?(@now), "matched now")
+        assert(! s.match?(min("-", 59)), "matched minus 11 hours")
+
+        # and weekly
+        assert_nothing_raised {
+            s[:period] = :weekly
+        }
+
+        assert(s.match?(week("-", 1)), "did not match minus a week")
+        assert(s.match?(day("-", 7)), "did not match minus 7 days")
+        assert(s.match?(day("-", 8)), "did not match minus 8 days")
+        assert(s.match?(week("-", 2)), "did not match two weeks")
+        assert(! s.match?(@now), "matched now")
+        assert(! s.match?(day("-", 6)), "matched minus 6 days")
+
+        # and monthly
+        assert_nothing_raised {
+            s[:period] = :monthly
+        }
+
+        assert(s.match?(month("-", 1)), "did not match minus a month")
+        assert(s.match?(week("-", 5)), "did not match minus 5 weeks")
+        assert(s.match?(week("-", 7)), "did not match minus 7 weeks")
+        assert(s.match?(day("-", 50)), "did not match minus 50 days")
+        assert(s.match?(month("-", 2)), "did not match two months")
+        assert(! s.match?(@now), "matched now")
+        assert(! s.match?(week("-", 3)), "matched minus 3 weeks")
+        assert(! s.match?(day("-", 20)), "matched minus 20 days")
+    end
+
+    # A shortened test...
+    def test_period_by_number
+        s = mksched
+        assert_nothing_raised {
+            s[:periodmatch] = :number
+        }
+
+        assert_nothing_raised {
+            s[:period] = :daily
+        }
+
+        assert(s.match?(day("+", 1)), "didn't match plus a day")
+        assert(s.match?(week("+", 1)), "didn't match plus a week")
+        assert(! s.match?(@now), "matched today")
+        assert(! s.match?(hour("-", 1)), "matched minus an hour")
+        assert(! s.match?(hour("-", 2)), "matched plus two hours")
+
+        # Now test hourly
+        assert_nothing_raised {
+            s[:period] = :hourly
+        }
+
+        assert(s.match?(hour("+", 1)), "did not match plus an hour")
+        assert(s.match?(hour("+", 2)), "did not match plus two hours")
+        assert(! s.match?(@now), "matched now")
+        assert(! s.match?(sec("+", 20)), "matched plus 20 seconds")
+    end
+
+    def test_periodmatch_default
+        s = mksched
+
+        match = s[:periodmatch]
+        assert(match, "Could not find periodmatch")
+
+        assert_equal(:distance, match, "Periodmatch was %s" % match)
+    end
+
+    def test_scheduled_objects
+        s = mksched
+        s[:period] = :hourly
+
+        f = nil
+        path = tempfile()
+        assert_nothing_raised {
+            f = Puppet.type(:file).create(
+                :name => path,
+                :schedule => s.name,
+                :ensure => "file"
+            )
+        }
+
+        assert(f.scheduled?, "File is not scheduled to run")
+
+        assert_apply(f)
+
+        assert(! f.scheduled?, "File is scheduled to run already")
+        File.unlink(path)
+
+        assert_apply(f)
+
+        assert(! FileTest.exists?(path), "File was created when not scheduled")
+    end
+
+    def test_latebinding_schedules
+        f = nil
+        path = tempfile()
+        assert_nothing_raised {
+            f = Puppet.type(:file).create(
+                :name => path,
+                :schedule => "testsched",
+                :ensure => "file"
+            )
+        }
+
+        s = mksched
+        s[:period] = :hourly
+
+        assert_nothing_raised {
+            f.schedule
+        }
+
+        assert(f.scheduled?, "File is not scheduled to run")
+    end
+
+    # Verify that each of our default schedules exist
+    def test_defaultschedules
+        Puppet.type(:schedule).mkdefaultschedules
+        %w{puppet hourly daily weekly monthly}.each { |period|
+            assert(Puppet.type(:schedule)[period], "Could not find %s schedule" %
+                period)
+        }
+    end
+
+    def test_period_with_repeat
+        previous = @now
+
+        s = mksched
+        s[:period] = :hourly
+
+        assert_nothing_raised("Was not able to set periodmatch") {
+            s[:periodmatch] = :number
+        }
+        assert_raise(Puppet::Error) {
+            s[:repeat] = 2
+        }
+        assert_nothing_raised("Was not able to reset periodmatch") {
+            s[:periodmatch] = :distance
+        }
+
+        assert(! s.match?(min("-", 40)), "matched minus 40 minutes")
+
+        assert_nothing_raised("Was not able to set period") {
+            s[:repeat] = 2
+        }
+
+        assert(! s.match?(min("-", 20)), "matched minus 20 minutes with half-hourly")
+        assert(s.match?(min("-", 40)), "Did not match minus 40 with half-hourly")
+
+        assert_nothing_raised("Was not able to set period") {
+            s[:repeat] = 3
+        }
+
+        assert(! s.match?(min("-", 15)), "matched minus 15 minutes with half-hourly")
+        assert(s.match?(min("-", 25)), "Did not match minus 25 with half-hourly")
+    end
+end
+
+# $Id: schedule.rb 858 2006-01-30 19:22:25Z luke $