puppet 0.18.4 → 0.22.4

data/test/ral/types/group.rb

@@ -0,0 +1,169 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'etc'
+
+class TestGroup < Test::Unit::TestCase
+	include PuppetTest
+
+    p = Puppet::Type.type(:group).provide :fake, :parent => PuppetTest::FakeProvider do
+        @name = :fake
+        apimethods :ensure, :gid
+
+        def create
+            @ensure = :present
+        end
+
+        def delete
+            @ensure = :absent
+        end
+
+        def exists?
+            if defined? @ensure and @ensure == :present
+                true
+            else
+                false
+            end
+        end
+    end
+
+    FakeGroupProvider = p
+
+    @@fakeproviders[:group] = p
+
+    def setup
+        super
+        Puppet::Type.type(:group).defaultprovider = FakeGroupProvider
+    end
+
+    def teardown
+        Puppet.type(:group).clear
+        Puppet::Type.type(:group).defaultprovider = nil
+        super
+    end
+
+    def mkgroup(name, hash = {})
+        group = nil
+        hash[:name] = name
+        assert_nothing_raised {
+            group = Puppet.type(:group).create(hash)
+        }
+
+        return group
+    end
+
+    def groupnames
+        %x{groups}.chomp.split(/ /)
+    end
+
+    def groupids
+        Process.groups
+    end
+
+    def attrtest_ensure(group)
+        group[:ensure] = :absent
+
+        comp = newcomp("ensuretest", group)
+        assert_apply(comp)
+        assert_equal(:absent, group.provider.ensure,  "Group is still present")
+        group[:ensure] = :present
+        assert_events([:group_created], comp)
+        assert_equal(:present, group.provider.ensure,  "Group is absent")
+        group[:ensure] = :absent
+        trans = assert_events([:group_removed], comp)
+        assert_equal(:absent, group.provider.ensure,  "Group is present")
+
+        assert_rollback_events(trans, [:group_created], "group")
+        assert_equal(:present, group.provider.ensure,  "Group is absent")
+    end
+
+    # This is a bit odd, since we're not actually doing anything on the machine.
+    # Just make sure we can set the gid and that it will work correctly.
+    def attrtest_gid(group)
+
+        # Check the validation.
+        assert_nothing_raised {
+            group[:gid] = "15"
+        }
+
+        assert_equal(15, group.should(:gid),
+                     "Did not convert gid to number")
+
+        comp = newcomp(group)
+        trans = assert_events([:group_modified], comp, "group")
+        assert_equal(15, group.provider.gid, "GID was not changed")
+
+        assert_nothing_raised {
+            group[:gid] = 16
+        }
+
+        assert_equal(16, group.should(:gid),
+                     "Did not keep gid as number")
+
+        # Now switch to 16
+        trans = assert_events([:group_modified], comp, "group")
+        assert_equal(16, group.provider.gid, "GID was not changed")
+
+        # And then rollback
+        assert_rollback_events(trans, [:group_modified], "group")
+        assert_equal(15, group.provider.gid, "GID was not changed")
+    end
+
+    def test_owngroups
+        groupnames().each { |group|
+            gobj = nil
+            comp = nil
+            assert_nothing_raised {
+                gobj = Puppet.type(:group).create(
+                    :name => group,
+                    :check => [:gid]
+                )
+            }
+
+            # Set a fake gid
+            gobj.provider.gid = rand(100)
+
+            assert_nothing_raised {
+                gobj.retrieve
+            }
+
+            assert(gobj.is(:gid), "Failed to retrieve gid")
+        }
+    end
+
+    def test_mkgroup
+        gobj = nil
+        name = "pptestgr"
+
+        assert_nothing_raised {
+            gobj = Puppet.type(:group).create(
+                :name => name,
+                :gid => 123
+            )
+        }
+        gobj.finish
+
+        trans = assert_events([:group_created], gobj, "group")
+
+        assert(gobj.provider.exists?,
+                "Did not create group")
+
+        tests = Puppet.type(:group).validproperties
+
+        gobj.retrieve
+        tests.each { |test|
+            if self.respond_to?("attrtest_%s" % test)
+                self.send("attrtest_%s" % test, gobj)
+            else
+                #$stderr.puts "Not testing attr %s of group" % test
+            end
+        }
+
+        assert_rollback_events(trans, [:group_removed], "group")
+
+        assert(! gobj.provider.exists?,
+                "Did not delete group")
+    end
+end

data/test/ral/types/host.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'test/unit'
+require 'facter'
+
+class TestHost < Test::Unit::TestCase
+	include PuppetTest
+
+    def setup
+        super
+        @hosttype = Puppet::Type.type(:host)
+
+        @provider = @hosttype.defaultprovider
+
+        # Make sure they aren't using something funky like netinfo
+        unless @provider.name == :parsed
+            @hosttype.defaultprovider = @hosttype.provider(:parsed)
+        end
+
+        cleanup do @hosttype.defaultprovider = nil end
+
+        if @provider.respond_to?(:default_target=)
+            @default_file = @provider.default_target
+            cleanup do
+                @provider.default_target = @default_file
+            end
+            @target = tempfile()
+            @provider.default_target = @target
+        end
+    end
+
+    def mkhost
+        if defined? @hcount
+            @hcount += 1
+        else
+            @hcount = 1
+        end
+        host = nil
+        assert_nothing_raised {
+            host = Puppet.type(:host).create(
+                :name => "fakehost%s" % @hcount,
+                :ip => "192.168.27.%s" % @hcount,
+                :alias => "alias%s" % @hcount
+            )
+        }
+
+        return host
+    end
+
+    def test_list
+        assert_nothing_raised do
+            @hosttype.defaultprovider.prefetch
+        end
+
+        count = 0
+        @hosttype.each do |h|
+            count += 1
+        end
+
+        assert_equal(0, count, "Found hosts in empty file somehow")
+    end
+
+    # Darwin will actually write to netinfo here.
+    if Facter.value(:operatingsystem) != "Darwin" or Process.uid == 0
+    def test_simplehost
+        host = nil
+        # We want to actually use the netinfo provider on darwin
+        if Facter.value(:operatingsystem) == "Darwin"
+            Puppet::Type.type(:host).defaultprovider = nil
+        end
+
+        assert_nothing_raised {
+            host = Puppet.type(:host).create(
+                :name => "culain",
+                :ip => "192.168.0.3"
+            )
+        }
+
+        host.retrieve
+        assert_events([:host_created], host)
+
+        assert_nothing_raised { host.retrieve }
+
+        assert_equal(:present, host.is(:ensure))
+
+        host[:ensure] = :absent
+
+        assert_events([:host_removed], host)
+
+        assert_nothing_raised { host.retrieve }
+
+        assert_equal(:absent, host.is(:ensure))
+    end
+
+    def test_moddinghost
+        # We want to actually use the netinfo provider on darwin
+        if Facter.value(:operatingsystem) == "Darwin"
+            Puppet::Type.type(:host).defaultprovider = nil
+        end
+        host = mkhost()
+        if Facter.value(:operatingsystem) == "Darwin"
+            assert_equal(:netinfo, host[:provider], "Got incorrect provider")
+        end
+        cleanup do
+            host[:ensure] = :absent
+            assert_apply(host)
+        end
+
+        assert_events([:host_created], host)
+
+        host.retrieve
+
+        # This was a hard bug to track down.
+        assert_instance_of(String, host.is(:ip))
+
+        host[:alias] = %w{madstop kirby yayness}
+
+        assert_events([:host_changed], host)
+
+        host.retrieve
+
+        assert_equal(%w{madstop kirby yayness}, host.is(:alias))
+        
+        host[:ensure] = :absent
+        assert_events([:host_removed], host)
+    end
+    end
+
+    def test_aliasisproperty
+        assert_equal(:property, @hosttype.attrtype(:alias))
+    end
+
+    def test_multivalues
+        host = mkhost
+        assert_raise(Puppet::Error) {
+            host[:alias] = "puppetmasterd yayness"
+        }
+    end
+
+    def test_puppetalias
+        host = mkhost()
+
+        assert_nothing_raised {
+            host[:alias] = "testing"
+        }
+
+        same = host.class["testing"]
+        assert(same, "Could not retrieve by alias")
+    end
+end
+
+# $Id: host.rb 2170 2007-02-07 17:21:52Z luke $

data/test/ral/types/mount.rb

@@ -0,0 +1,312 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+
+unless Facter.value(:operatingsystem) == "Darwin"
+class TestMounts < Test::Unit::TestCase
+	include PuppetTest
+
+    p = Puppet::Type.type(:mount).provide :fake, :parent => PuppetTest::FakeParsedProvider do
+        @name = :fake
+        apimethods :ensure
+
+        attr_accessor :mounted
+
+        def self.default_target
+            :yayness
+        end
+
+        def create
+            @ensure = :present
+            @model.class.validproperties.each do |property|
+                if value = @model.should(property)
+                    self.send(property.to_s + "=", value)
+                end
+            end
+        end
+
+        def destroy
+            @ensure = :absent
+        end
+
+        def exists?
+            if defined? @ensure and @ensure == :present
+                true
+            else
+                false
+            end
+        end
+
+        def mounted?
+            @ensure == :mounted
+        end
+
+        def mount
+            @ensure = :mounted
+        end
+
+        def remount
+        end
+
+        def unmount
+            @ensure = :present
+        end
+    end
+
+    FakeMountProvider = p
+
+    @@fakeproviders[:mount] = p
+
+    def setup
+        super
+        @mount = Puppet::Type.type(:mount)
+        @realprovider = @mount.defaultprovider
+        @mount.defaultprovider = FakeMountProvider
+    end
+
+    def teardown
+        Puppet.type(:mount).clear
+        if @realprovider.respond_to?(:clear)
+            @realprovider.clear
+        end
+        Puppet::Type.type(:mount).defaultprovider = nil
+        super
+    end
+
+    def mkmount
+        mount = nil
+
+        assert_nothing_raised {
+            mount = Puppet.type(:mount).create(mkmount_args)
+        }
+
+        return mount
+    end
+
+    def mkmount_args
+        if defined? @pcount
+            @pcount += 1
+        else
+            @pcount = 1
+        end
+        args = {
+            :name => "/fspuppet%s" % @pcount,
+            :device => "/dev/dsk%s" % @pcount,
+        }
+
+        [@mount.validproperties, @mount.parameters].flatten.each do |field|
+            next if [:path, :provider, :target, :ensure, :remounts].include?(field)
+            unless args.include? field
+                args[field] = "fake%s" % @pcount
+            end
+        end
+
+        return args
+    end
+
+    def test_simplemount
+        mount = mkmount
+        mount[:ensure] = :mounted
+
+        assert_apply(mount)
+        mount.send(:properties).each do |property|
+            assert_equal(property.should, mount.provider.send(property.name),
+                "%s was not set to %s" % [property.name, property.should])
+        end
+        assert_events([], mount)
+
+        assert_nothing_raised { mount.retrieve }
+
+        # Now modify a field
+        mount[:dump] = 2
+        mount[:options] = "defaults,ro"
+
+        assert_events([:mount_changed,:mount_changed, :triggered], mount)
+        assert_equal(2, mount.provider.dump, "Changes did not get flushed")
+        assert_equal("defaults,ro", mount.provider.options, "Changes did not get flushed")
+
+        # Now modify a field in addition to change :ensure.
+        mount[:ensure] = :present
+        mount[:options] = "defaults"
+
+        assert_apply(mount)
+        assert(! mount.provider.mounted?, "mount was still mounted")
+        assert_equal("defaults", mount.provider.options)
+
+        # Now remount it and make sure changes get flushed then, too.
+        mount[:ensure] = :mounted
+        mount[:options] = "aftermount"
+
+        assert_apply(mount)
+        assert(mount.provider.mounted?, "mount was not mounted")
+        assert_equal("aftermount", mount.provider.options)
+    end
+
+    # Make sure fs mounting behaves appropriately.  This is more a test of
+    # whether things get mounted and unmounted based on the value of 'ensure'.
+    def test_mountfs
+        obj = mkmount
+
+        assert_apply(obj)
+
+        # Verify we can remove the mount
+        assert_nothing_raised {
+            obj[:ensure] = :absent
+        }
+
+        assert_events([:mount_deleted], obj)
+        assert_events([], obj)
+
+        # And verify it's gone
+        assert(!obj.provider.mounted?, "Object is mounted after being removed")
+
+        assert_nothing_raised {
+            obj[:ensure] = :present
+        }
+
+        assert_events([:mount_created, :triggered], obj)
+        assert_events([], obj)
+
+        assert(! obj.provider.mounted?, "Object is mounted incorrectly")
+
+        assert_nothing_raised {
+            obj[:ensure] = :mounted
+        }
+
+        assert_events([:mount_mounted, :triggered], obj)
+        assert_events([], obj)
+
+        obj.retrieve
+        assert_equal(:mounted, obj.is(:ensure))
+
+        obj.retrieve
+        assert(obj.provider.mounted?, "Object is not mounted")
+    end
+    
+    # Darwin doesn't put its mount table into netinfo
+    unless Facter.value(:operatingsystem) == "Darwin"
+    def test_list
+        list = nil
+        assert(@mount.respond_to?(:list),
+            "No list method defined for mount")
+
+        assert_nothing_raised do
+            list = Puppet::Type.type(:mount).list
+        end
+        
+        assert(list.length > 0, "Did not return any mounts")
+
+        root = list.find { |o| o[:name] == "/" }
+        assert(root, "Could not find root root filesystem in list results")
+
+        assert(root.is(:device), "Device was not set")
+        assert(root.property(:device).value, "Device was not returned by value method")
+
+        assert_nothing_raised do
+            root.retrieve
+        end
+
+        assert(root.is(:device), "Device was not set")
+        assert(root.property(:device).value, "Device was not returned by value method")
+    end
+    end
+
+    # Make sure we actually remove the object from the file and such.
+    # Darwin will actually write to netinfo here.
+    if Facter.value(:operatingsystem) != "Darwin" or Process.uid == 0
+    def test_removal
+        # Reset the provider so that we're using the real thing
+        @mount.defaultprovider = nil
+
+        provider = @mount.defaultprovider
+        assert(provider, "Could not retrieve default provider")
+
+        if provider.respond_to?(:default_target)
+            file = provider.default_target
+            assert(FileTest.exists?(file),
+                "FSTab %s does not exist" % file)
+
+            # Now switch to ram, so we're just doing this there, not really on disk.
+            oldtype = provider.filetype
+            provider.filetype = :ram
+            cleanup { provider.filetype = oldtype }
+            #provider.target_object(file).write text
+        end
+
+        mount = mkmount
+
+        mount[:ensure] = :present
+
+        assert_events([:mount_created, :triggered], mount)
+        assert_events([], mount)
+
+        mount[:ensure] = :absent
+        assert_events([:mount_deleted], mount)
+        assert_events([], mount)
+
+        # Now try listing and making sure the object is actually gone.
+        list = mount.provider.class.list
+        assert(! list.find { |r| r[:name] == mount[:name] },
+            "Mount was not actually removed")
+    end
+    end
+
+    # Make sure that the name gets correctly set if they set the path,
+    # which used to be the namevar.
+    def test_name_and_path
+        mount = nil
+        args = mkmount_args
+        args[:name] = "mount_name"
+        args[:path] = "mount_path"
+
+        assert_nothing_raised do
+            mount = @mount.create(args)
+        end
+
+        assert_equal("mount_path", mount[:name], "Name did not get copied over")
+    end
+    
+    def test_refresh
+        mount = mkmount
+        mount[:ensure] = :mounted
+        
+        remounted = false
+        mount.provider.meta_def(:remount) do
+            remounted = true
+        end
+        
+        # First make sure we correctly call the provider
+        assert_nothing_raised do
+            mount.refresh
+        end
+        assert(remounted, "did not call remount on provider")
+        
+        # then make sure it gets called during transactions
+        remounted = false
+        mount[:device] = "/dev/yayness"
+        
+        assert_apply(mount)
+        
+        assert(remounted, "did not remount when mount changed")
+
+        # Now make sure it doesn't remount if the mount is just 'present'
+        mount[:ensure] = :present
+        mount[:device] = "/dev/funtest"
+        remounted = false
+        assert_apply(mount)
+
+        assert(! remounted, "remounted even though not supposed to be mounted")
+    end
+
+    def test_no_default_for_ensure
+        mount = mkmount
+        mount.finish
+
+        assert_nil(mount.should(:ensure), "Found default for ensure")
+    end
+end
+end
+
+# $Id: mount.rb 2377 2007-03-31 06:35:23Z luke $