puppet 0.23.2 → 0.24.0

data/test/ral/types/package.rb

@@ -1,154 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'facter'
-require 'mocha'
-
-$platform = Facter["operatingsystem"].value
-
-class TestPackages < Test::Unit::TestCase
-    include PuppetTest::FileTesting
-    def setup
-        super
-        Puppet.type(:package).clear
-        @type = Puppet::Type.type(:package)
-    end
-
-    # This is a bare-minimum test and *really* needs to do much more.
-    def test_package_actions
-        @type.provide :fake, :parent => PuppetTest::FakeProvider do
-            apimethods :ensure
-            def install
-                self.ensure = @resource.should(:ensure)
-            end
-
-            def uninstall
-                self.ensure = :absent
-            end
-
-            def query
-                case self.ensure
-                when :absent, nil: nil
-                else
-                    {:ensure => self.ensure}
-                end
-            end
-        end
-
-        pkg = nil
-        assert_nothing_raised do
-            pkg = @type.create :name => "testing", :provider => :fake
-        end
-        assert(pkg, "did not create package")
-
-        current_values = nil
-        assert_nothing_raised do
-            current_values = pkg.retrieve
-        end
-
-        assert_equal(:absent, current_values[pkg.property(:ensure)], 
-                     "package not considered missing")
-        assert_equal(:present, pkg.should(:ensure),
-            "package did not default to installed")
-
-        assert_events([:package_installed], pkg)
-
-        pkg[:ensure] = :absent
-        assert_events([:package_removed], pkg)
-    end
-
-    def test_packagedefaults
-        should = case Facter["operatingsystem"].value
-        when "Debian": :apt
-        when "Darwin": :apple
-        when "RedHat": :up2date
-        when "Fedora": :yum
-        when "FreeBSD": :ports
-        when "OpenBSD": :openbsd
-        when "Solaris": :sun
-        end
-
-        unless default = Puppet::Type.type(:package).defaultprovider
-            $stderr.puts "no default provider for %s" %
-                Facter["operatingsystem"].value
-            return
-        end
-
-
-        if should
-            assert_equal(should, default.name,
-                "Incorrect default package format")
-        end
-    end
-
-    # Make sure we can prefetch and retrieve packages
-    def test_package_instances
-        providers = []
-        instances = nil
-        assert_nothing_raised("Could not get package instances") do
-            instances = @type.instances
-        end
-        instances.each do |resource|
-            # Just do one of each type
-            next if providers.include?(resource.provider.class)
-            providers << resource.provider.class
-
-            # We should have data on the resource
-            assert(resource.exists?, "Listed resource thinks it's absent")
-
-            # Now flush the resource and make sure it clears the property_hash
-            assert_nothing_raised("Could not flush package") do
-                resource.flush
-            end
-
-            assert_equal(:absent, resource.provider.get(:ensure), "Flushing did not empty property hash")
-
-            # And query anew
-            props = nil
-            assert_nothing_raised("Could not retrieve package again") do
-                props = resource.retrieve
-            end
-            provider_props = resource.provider.send(:instance_variable_get, "@property_hash")
-            props.each do |prop, value|
-                assert_equal(value, provider_props[prop.name], "Query did not return same result as the property_hash for %s" % prop.name)
-            end
-        end
-    end
-
-    # Make sure we can prefetch package information, rather than getting it one package at a time.
-    def test_prefetch
-        @type.providers_by_source.each do |provider|
-            # First get a list of packages
-            list = provider.instances
-
-            packages = {}
-            list.each do |package|
-                packages[package.name] = @type.create(:name => package.name, :ensure => :installed)
-                break if packages.length > 4
-            end
-
-            # Now prefetch using that list of packages
-            assert_nothing_raised("Could not prefetch with %s" % provider.name) do
-                provider.prefetch(packages)
-            end
-
-            # And make sure each package is marked as existing, without calling query
-            packages.each do |name, package|
-                assert(package.exists?, "Package of type %s not marked present" % provider.name)
-                package.provider.expects(:query).never
-            end
-        end
-    end
-
-    # #716
-    def test_purge_is_not_installed
-        package = @type.create(:ensure => :installed, :name => "whatever")
-
-        property = package.property(:ensure)
-        assert(! property.insync?(:purged), "Package in state 'purged' was considered in sync")
-    end
-end
-
-# $Id: package.rb 2753 2007-08-07 02:38:45Z luke $

data/test/ral/types/schedule.rb

@@ -1,357 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-require 'puppet/type/schedule'
-
-class TestSchedule < Test::Unit::TestCase
-    include PuppetTest
-
-    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
-        assert_nothing_raised do
-            Puppet.type(:schedule).mkdefaultschedules
-        end
-        s = {}
-        %w{puppet hourly daily weekly monthly}.each { |period|
-            obj = Puppet.type(:schedule)[period]
-            assert(obj, "Could not find %s schedule" %
-                period)
-            s[period] = obj
-        }
-        assert_nothing_raised("Could not rerun mkdefaultschedules") do
-            Puppet.type(:schedule).mkdefaultschedules
-        end
-        s.each do |period, obj|
-            newobj = Puppet.type(:schedule)[period]
-            assert(newobj, "somehow lost schedule for %s" % period)
-            assert_equal(obj.object_id, newobj.object_id,
-                "created a new schedule instead of reusing existing one")
-        end
-    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
-
-    # #526
-    def test_never_period
-        schedule = nil
-        assert_nothing_raised do
-            schedule = Puppet::Type.type(:schedule).create(
-                :name => "test", :period => :never
-            )
-        end
-
-        assert(! schedule.match?, "schedule matched with period == never")
-    end
-end
-
-# $Id: schedule.rb 2487 2007-05-09 01:51:20Z ballman $