puppet 0.23.2 → 0.24.0

data/test/ral/providers/mount/parsed.rb

@@ -1,251 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
-
-require 'mocha'
-require 'puppettest'
-require 'puppettest/fileparsing'
-require 'facter'
-
-module MountTesting
-	include PuppetTest
-	include PuppetTest::FileParsing
-
-    def setup
-        super
-        @mount = Puppet.type(:mount)
-        @provider = @mount.provider(:parsed)
-
-        @oldfiletype = @provider.filetype
-    end
-
-    def teardown
-        Puppet::Util::FileType.filetype(:ram).clear
-        @provider.filetype = @oldfiletype
-        @provider.clear
-        super
-    end
-
-    def fake_fstab
-        os = Facter['operatingsystem']
-        if os == "Solaris"
-            name = "solaris.fstab"
-        elsif os == "FreeBSD"
-            name = "freebsd.fstab"
-        else
-            # Catchall for other fstabs
-            name = "linux.fstab"
-        end
-        oldpath = @provider.default_target
-        return fakefile(File::join("data/types/mount", name))
-    end
-
-    def mkmountargs
-        mount = nil
-
-        if defined? @pcount
-            @pcount += 1
-        else
-            @pcount = 1
-        end
-        args = {
-            :name => "/fspuppet%s" % @pcount,
-            :device => "/dev/dsk%s" % @pcount,
-        }
-
-        @provider.fields(:parsed).each do |field|
-            unless args.include? field
-                args[field] = "fake%s%s" % [field, @pcount]
-            end
-        end
-
-        return args
-    end
-
-    def mkmount
-        hash = mkmountargs()
-        #hash[:provider] = @provider.name
-
-        fakeresource = fakeresource(:mount, hash[:name])
-
-        mount = @provider.new(fakeresource)
-        assert(mount, "Could not create provider mount")
-        hash[:record_type] = :parsed
-        hash[:ensure] = :present
-        mount.property_hash = hash
-
-        return mount
-    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
-        @provider.filetype = Puppet::Util::FileType.filetype(:ram)
-    end
-end
-
-class TestParsedMounts < Test::Unit::TestCase
-    include MountTesting
-
-    def test_default_target
-        should = case Facter.value(:operatingsystem)
-        when "Solaris": "/etc/vfstab"
-        else
-            "/etc/fstab"
-        end
-        assert_equal(should, @provider.default_target)
-    end
-
-    def test_simplemount
-        mkfaketype
-        target = @provider.default_target
-
-        # Make sure we start with an empty file
-        assert_equal("", @provider.target_object(target).read,
-            "Got a non-empty starting file")
-
-        # Now create a provider
-        mount = nil
-        assert_nothing_raised {
-            mount = mkmount
-        }
-
-        # Make sure we're still empty
-        assert_equal("", @provider.target_object(target).read,
-            "Got a non-empty starting file")
-
-        # Try flushing it to disk
-        assert_nothing_raised do
-            mount.flush
-        end
-
-        # Make sure it's now in the file.  The file format is validated in
-        # the isomorphic methods.
-        assert(@provider.target_object(target).read.include?("\t%s\t" %
-            mount.property_hash[:name]), "Mount was not written to disk")
-
-        # now make a change
-        assert_nothing_raised { mount.dump = 5 }
-        assert_nothing_raised { mount.flush }
-
-        @provider.prefetch
-        assert_equal(5, mount.dump, "did not flush change to disk")
-    end
-
-    # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
-    def test_flush_when_mounting_absent_fs
-        @provider.filetype = :ram
-        mount = mkmount
-
-        mount.expects(:flush)
-        mount.expects(:mountcmd) # just so we don't actually try to mount anything
-        mount.mount
-    end
-end
-
-class TestParsedMountsNonDarwin < PuppetTest::TestCase
-    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
-    include MountTesting
-
-    def test_mountsparse
-        tab = fake_fstab
-        fakedataparse(tab) do
-            # Now just make we've got some mounts we know will be there
-            hashes = @provider.target_records(tab).find_all { |i| i.is_a? Hash }
-            assert(hashes.length > 0, "Did not create any hashes")
-            root = hashes.find { |i| i[:name] == "/" }
-            assert(root, "Could not retrieve root mount")
-
-            assert_nothing_raised("Could not rewrite file") do
-                @provider.to_file(hashes)
-            end
-        end
-    end
-
-    def test_rootfs
-        fs = nil
-        type = @mount.create :name => "/"
-
-        provider = type.provider
-
-        assert(FileTest.exists?(@provider.default_target),
-            "FSTab %s does not exist" % @provider.default_target)
-
-        assert_nothing_raised do
-            @provider.prefetch("/" => type)
-        end
-
-        assert_equal(:present, type.provider.property_hash[:ensure],
-            "Could not find root fs with provider %s" % provider.class.name)
-
-        assert_nothing_raised {
-            assert(provider.mounted?, "Root is considered not mounted")
-        }
-    end
-end
-
-class TestParsedMountsNonDarwinAsRoot < PuppetTest::TestCase
-    confine "Mount type not tested on Darwin" => Facter["operatingsystem"].value != "Darwin"
-    confine "Not running as root" => Puppet.features.root?
-
-    include MountTesting
-
-    def test_mountfs
-        fs = nil
-        case Facter.value(:hostname)
-        when "culain": fs = "/ubuntu"
-        when "atalanta": fs = "/mnt"
-        else
-            $stderr.puts "No mount for mount testing; skipping"
-            return
-        end
-
-        oldtext = @provider.target_object(@provider.default_target).read
-
-        ftype = @provider.filetype
-
-        mount = @mount.create :name => fs
-        obj = mount.provider
-
-        current = nil
-        assert_nothing_raised {
-            current = obj.mounted?
-        }
-
-        if current
-            # Make sure the original gets remounted.
-            cleanup do
-                unless obj.mounted?
-                    obj.mount
-                end
-            end
-        end
-
-        unless current
-            assert_nothing_raised {
-                obj.mount
-            }
-        end
-
-        assert(obj.mounted?, "filesystem is not mounted")
-
-        assert_nothing_raised {
-            obj.unmount
-        }
-        assert(! obj.mounted?, "FS still mounted")
-        # Check the actual output of mountcmd
-        assert(! obj.mountcmd().include?(fs), "%s is still listed in mountcmd" % fs)
-        assert_nothing_raised {
-            obj.mount
-        }
-        assert(obj.mounted?, "FS not mounted")
-        assert(obj.mountcmd().include?(fs), "%s is not listed in mountcmd" % fs)
-
-        # Now try remounting
-        assert_nothing_raised("Could not remount filesystem") do
-            obj.remount
-        end
-    end
-end
-
-# $Id: parsed.rb 2745 2007-08-05 17:49:23Z luke $

data/test/ral/providers/service.rb

@@ -1,235 +0,0 @@
-#!/usr/bin/env ruby
-
-$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
-
-require 'puppettest'
-
-$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 TestLocalService < Test::Unit::TestCase
-	include PuppetTest
-
-    def teardown
-        Puppet.type(:service).clear
-        super
-    end
-
-    def mktestsvcs
-        list = tstsvcs.collect { |svc,svcargs|
-            args = svcargs.dup
-            args[:name] = svc
-            Puppet.type(:service).create(args)
-        }
-    end
-
-    def tstsvcs
-        case Facter["operatingsystem"].value.downcase
-        when "solaris":
-            case Facter["operatingsystemrelease"].value
-            when "5.10":
-                return {"smtp" => {}, "xfs" => {}}
-            end
-        when "debian":
-            return {"hddtemp" => {:hasrestart => true}}
-        when "centos":
-            return {"cups" => {:hasstatus => true}}
-        when "redhat":
-            return {"saslauthd" => {:hasstatus => true}}
-        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[:ensure] = :running
-
-        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)
-        props = nil
-        assert_nothing_raised() {
-            props = service.retrieve
-        }
-        props.each do |prop, value|
-            if prop.name == :ensure
-                assert_equal(:running, value, "Service %s is not running" % service.name)
-            end
-        end
-
-        # test refreshing it
-        assert_nothing_raised() {
-            service.refresh
-        }
-
-        # now stop it
-        assert_nothing_raised() {
-            service[:ensure] = :stopped
-        }
-        props.each do |prop, value|
-            if prop.name == :ensure
-                assert_equal(:running, value, "Service %s is not running" % service.name)
-            end
-        end
-        Puppet.info "stopping %s" % service.name
-        assert_events([:service_stopped], comp)
-        sleep(1.5)
-        assert_nothing_raised() {
-            props = service.retrieve
-        }
-        props.each do |prop, value|
-            if prop.name == :ensure
-                assert_equal(:stopped, value, "Service %s is not running" % service.name)
-            end
-        end
-    end
-
-    def cycleenable(service)
-        assert_nothing_raised() {
-            service.retrieve
-        }
-
-        comp = newcomp("servicetst", service)
-        service[:enable] = true
-
-        Puppet.info "Enabling %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)
-        props = nil
-        assert_nothing_raised() {
-            props = service.retrieve
-        }
-        props.each do |prop, value|
-            if prop.name == :enable
-                assert_equal(value, :true, "Service %s is not enabled" % service.name)
-            end
-        end
-
-        # now disable it
-        assert_nothing_raised() {
-            service[:enable] = false
-        }
-        assert_nothing_raised() {
-            props = service.retrieve
-        }
-        props.each do |prop, value|
-            assert_equal(value, :true, "Service %s is already disabled" % service.name)
-        end
-        Puppet.info "disabling %s" % service.name
-        assert_events([:service_disabled], comp)
-        sleep(1.5)
-        assert_nothing_raised() {
-            props = service.retrieve
-        }
-        props.each do |prop, value|
-            assert_equal(value, :false, "Service %s is still enabled" % service.name)
-        end
-    end
-
-    def test_status
-        mktestsvcs.each { |svc|
-            val = nil
-            assert_nothing_raised("Could not get status") {
-                val = svc.provider.status
-            }
-            assert_instance_of(Symbol, val)
-        }
-    end
-
-    unless Puppet::Util::SUIDManager.uid == 0
-        puts "run as root to test service start/stop"
-    else
-        def test_servicestartstop
-            mktestsvcs.each { |svc|
-                startproperty = nil
-                assert_nothing_raised("Could not get status") {
-                    startproperty = svc.provider.status
-                }
-                cycleservice(svc)
-
-                svc[:ensure] = startproperty
-                assert_apply(svc)
-                Puppet.type(:component).clear
-            }
-        end
-
-        def test_serviceenabledisable
-            mktestsvcs.each { |svc|
-                assert(svc[:name], "Service has no name")
-                startproperty = nil
-                svc[:check] = :enable
-                assert_nothing_raised("Could not get status") {
-                    startproperty = svc.provider.enabled?
-                }
-                cycleenable(svc)
-
-                svc[:enable] = startproperty
-                assert_apply(svc)
-                Puppet.type(:component).clear
-            }
-        end
-
-        def test_serviceenableandrun
-            mktestsvcs.each do |svc|
-                startenable = nil
-                startensure = nil
-                svc[:check] = [:ensure, :enable]
-                properties = nil
-                assert_nothing_raised("Could not get status") {
-                    properties = svc.retrieve
-                }
-                initial = properties.dup
-
-                svc[:enable] = false
-                svc[:ensure] = :stopped
-                assert_apply(svc)
-
-                sleep 1
-                assert_nothing_raised("Could not get status") {
-                    properties = svc.retrieve
-                }
-                properties.each do |prop, value|
-                    assert(prop.insync?(value), "Service did not sync %s property" % prop.name)
-                end
-
-                svc[:enable] = true
-                svc[:ensure] = :running
-                assert_apply(svc)
-
-                sleep 1
-                assert_nothing_raised("Could not get status") {
-                    properties = svc.retrieve
-                }
-                assert(svc.insync?(properties), "Service did not sync both properties")
-
-                initial.each do |prop, value|
-                    svc[prop.name] = value
-                end
-                assert_apply(svc)
-                Puppet.type(:component).clear
-            end
-        end
-    end
-end
-end
-
-# $Id: service.rb 2555 2007-06-08 17:20:00Z luke $