puppet 0.18.4 → 0.22.4

data/test/ral/providers/cron/crontab.rb

@@ -0,0 +1,346 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'mocha'
+require 'puppettest/fileparsing'
+require 'puppet/type/cron'
+require 'puppet/provider/cron/crontab'
+
+class TestCronParsedProvider < Test::Unit::TestCase
+	include PuppetTest
+	include PuppetTest::FileParsing
+
+    def setup
+        super
+        @type = Puppet::Type.type(:cron)
+        @provider = @type.provider(:crontab)
+        @provider.initvars
+
+        @oldfiletype = @provider.filetype
+    end
+
+    def teardown
+        Puppet::Util::FileType.filetype(:ram).clear
+        @provider.filetype = @oldfiletype
+        @provider.clear
+        super
+    end
+
+    def test_parse_record
+        fields = [:month, :weekday, :monthday, :hour, :command, :minute]
+        {
+            "* * * * * /bin/echo" => {:command => "/bin/echo"},
+            "10 * * * * /bin/echo test" => {:minute => ["10"],
+                :command => "/bin/echo test"}
+        }.each do |line, should|
+            result = nil
+            assert_nothing_raised("Could not parse %s" % line.inspect) do
+                result = @provider.parse_line(line)
+            end
+            should[:record_type] = :crontab
+            fields.each do |field|
+                if should[field]
+                    assert_equal(should[field], result[field],
+                        "Did not parse %s in %s correctly" % [field, line.inspect])
+                else
+                    assert_equal(:absent, result[field],
+                        "Did not set %s absent in %s" % [field, line.inspect])
+                end
+            end
+        end
+    end
+
+    def test_parse_and_generate
+        @provider.filetype = :ram
+        crondir = datadir(File.join(%w{providers cron}))
+        files = Dir.glob("%s/crontab.*" % crondir)
+
+        setme
+        target = @provider.target_object(@me)
+        files.each do |file|
+            str = args = nil
+            assert_nothing_raised("could not load %s" % file) do
+                str, args = YAML.load(File.read(file))
+            end
+            
+            # Stupid old yaml
+            args.each do |hash|
+                hash.each do |param, value|
+                    if param.is_a?(String) and param =~ /^:/
+                        hash.delete(param)
+                        param = param.sub(/^:/,'').intern
+                        hash[param] = value
+                    end
+
+                    if value.is_a?(String) and value =~ /^:/
+                        value = value.sub(/^:/,'').intern
+                        hash[param] = value
+                    end
+                end
+            end
+            target.write(str)
+            assert_nothing_raised("could not parse %s" % file) do
+                @provider.prefetch_target(@me)
+            end
+            records = @provider.send(:instance_variable_get, "@records")
+
+            args.zip(records) do |should, sis|
+                # Make the values a bit more equal.
+                should[:target] = @me
+                should[:ensure] = :present
+                should[:on_disk] = true
+                is = sis.dup
+                sis.dup.each do |p,v|
+                    is.delete(p) if v == :absent
+                end
+                assert_equal(should, is,
+                    "Did not parse %s correctly" % file)
+            end
+
+            assert_nothing_raised("could not generate %s" % file) do
+                @provider.flush_target(@me)
+            end
+
+            assert_equal(str, target.read, "%s changed" % file)
+            @provider.clear
+        end
+    end
+
+    # A simple test to see if we can load the cron from disk.
+    def test_load
+        setme()
+        records = nil
+        assert_nothing_raised {
+            records = @provider.retrieve(@me)
+        }
+        assert_instance_of(Array, records, "did not get correct response")
+    end
+
+    # Test that a cron job turns out as expected, by creating one and generating
+    # it directly
+    def test_simple_to_cron
+        # make the cron
+        setme()
+
+        name = "yaytest"
+        args = {:name => name,
+            :command => "date > /dev/null",
+            :minute => "30",
+            :user => @me,
+            :record_type => :crontab
+        }
+        # generate the text
+        str = nil
+        assert_nothing_raised {
+            str = @provider.to_line(args)
+        }
+
+        assert_equal("# Puppet Name: #{name}\n30 * * * * date > /dev/null", str,
+            "Cron did not generate correctly")
+    end
+    
+    # Test that comments are correctly retained
+    def test_retain_comments
+        str = "# this is a comment\n#and another comment\n"
+        user = "fakeuser"
+        records = nil
+        target = @provider.filetype = :ram
+        target = @provider.target_object(user)
+        target.write(str)
+        assert_nothing_raised {
+            @provider.prefetch_target(user)
+        }
+
+        assert_nothing_raised {
+            newstr = @provider.flush_target(user)
+            assert(target.read.include?(str), "Comments were lost")
+        }
+    end
+
+    def test_simpleparsing
+        @provider.filetype = :ram
+        text = "5 1,2 * 1 0 /bin/echo funtest"
+
+        records = nil
+        assert_nothing_raised {
+            records = @provider.parse(text)
+        }
+
+        should = {
+            :minute => %w{5},
+            :hour => %w{1 2},
+            :monthday => :absent,
+            :month => %w{1},
+            :weekday => %w{0},
+            :command => "/bin/echo funtest"
+        }
+
+        is = records.shift
+        assert(is, "Did not get record")
+
+        should.each do |p, v|
+            assert_equal(v, is[p], "did not parse %s correctly" % p)
+        end
+    end
+
+    # Make sure we can create a cron in an empty tab
+    def test_mkcron_if_empty
+        setme
+        @provider.filetype = @oldfiletype
+
+        records = @provider.retrieve(@me)
+
+        target = @provider.target_object(@me)
+
+        cleanup do
+            if records.length == 0
+                target.remove
+            else
+                target.write(@provider.to_file(records))
+            end
+        end
+
+        # Now get rid of it
+        assert_nothing_raised("Could not remove cron tab") do
+            target.remove
+        end
+
+        @provider.flush :target => @me, :command => "/do/something",
+            :record_type => :crontab
+        created = @provider.retrieve(@me)
+        assert(created.detect { |r| r[:command] == "/do/something" },
+            "Did not create cron tab")
+    end
+
+    # Make sure we correctly bidirectionally parse things.
+    def test_records_and_strings
+        @provider.filetype = :ram
+        setme
+
+        target = @provider.target_object(@me)
+        
+        [
+            "* * * * * /some/command",
+            "0,30 * * * * /some/command",
+            "0-30 * * * * /some/command",
+            "# Puppet Name: name\n0-30 * * * * /some/command",
+            "# Puppet Name: name\nVAR=VALUE\n0-30 * * * * /some/command",
+            "# Puppet Name: name\nVAR=VALUE\nC=D\n0-30 * * * * /some/command",
+            "0 * * * * /some/command"
+        ].each do |str|
+            @provider.initvars
+            str += "\n"
+            target.write(str)
+            assert_equal(str, target.read,
+                "Did not write correctly")
+            assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
+                @provider.prefetch_target(@me)
+            end
+            assert_nothing_raised("Could not flush with %s" % str.inspect) do
+                @provider.flush_target(@me)
+            end
+
+            assert_equal(str, target.read,
+                "Changed in read/write")
+
+            @provider.clear
+        end
+    end
+
+    # Test that a specified cron job will be matched against an existing job
+    # with no name, as long as all fields match
+    def test_matchcron
+        str = "0,30 * * * * date\n"
+        setme
+        @provider.filetype = :ram
+
+        cron = nil
+        assert_nothing_raised {
+            cron = @type.create(
+                :name => "yaycron",
+                :minute => [0, 30],
+                :command => "date",
+                :user => @me
+            )
+        }
+
+        hash = @provider.parse_line(str)
+        hash[:user] = @me
+
+        instance = @provider.match(hash)
+        assert(instance, "did not match cron")
+        assert_equal(cron, instance,
+            "Did not match cron job")
+    end
+
+    def test_data
+        setme
+        @provider.filetype = :ram
+        target = @provider.target_object(@me)
+        fakedata("data/providers/cron/examples").each do |file|
+            text = File.read(file)
+            target.write(text)
+
+            assert_nothing_raised("Could not parse %s" % file) do
+                @provider.prefetch_target(@me)
+            end
+            # mark the provider modified
+            @provider.modified(@me)
+
+            # and zero the text
+            target.write("")
+
+            result = nil
+            assert_nothing_raised("Could not generate %s" % file) do
+                @provider.flush_target(@me)
+            end
+
+            # Ignore whitespace differences, since those don't affect function.
+            modtext = text.gsub(/[ \t]+/, " ")
+            modtarget = target.read.gsub(/[ \t]+/, " ")
+            assert_equal(modtext, modtarget,
+                "File was not rewritten the same")
+
+            @provider.clear
+        end
+    end
+
+    # Match freebsd's annoying @daily stuff.
+    def test_match_freebsd_special
+        @provider.filetype = :ram
+        setme
+
+        target = @provider.target_object(@me)
+        
+        [
+            "@daily /some/command",
+            "@daily /some/command more"
+        ].each do |str|
+            @provider.initvars
+            str += "\n"
+            target.write(str)
+            assert_equal(str, target.read,
+                "Did not write correctly")
+            assert_nothing_raised("Could not prefetch with %s" % str.inspect) do
+                @provider.prefetch_target(@me)
+            end
+            records = @provider.send(:instance_variable_get, "@records")
+            records.each do |r|
+                assert_equal(:freebsd_special, r[:record_type],
+                    "Did not create lines as freebsd lines")
+            end
+            assert_nothing_raised("Could not flush with %s" % str.inspect) do
+                @provider.flush_target(@me)
+            end
+
+            assert_equal(str, target.read,
+                "Changed in read/write")
+
+            @provider.clear
+        end
+    end
+end
+
+# $Id: crontab.rb 2334 2007-03-19 23:04:32Z luke $

data/test/ral/providers/group.rb

@@ -0,0 +1,252 @@
+#!/usr/bin/env ruby
+
+$:.unshift("../../lib") if __FILE__ =~ /\.rb$/
+
+require 'puppettest'
+require 'etc'
+
+class TestGroupProvider < Test::Unit::TestCase
+	include PuppetTest
+    def setup
+        super
+        @@tmpgroups = []
+        @provider = nil
+        assert_nothing_raised {
+            @provider = Puppet::Type.type(:group).defaultprovider
+        }
+
+        assert(@provider, "Could not find default group provider")
+        assert(@provider.name != :fake, "Got a fake provider")
+    end
+
+    def teardown
+        super
+        Puppet.type(:group).clear
+        @@tmpgroups.each { |group|
+            unless missing?(group)
+                remove(group)
+            end
+        }
+    end
+
+    def mkgroup(name, hash = {})
+        fakemodel = fakemodel(:group, name)
+        group = nil
+        assert_nothing_raised {
+            group = @provider.new(fakemodel)
+        }
+        hash.each do |name, val|
+            fakemodel[name] = val
+        end
+        assert(group, "Could not create provider group")
+
+        return group
+    end
+
+    case Facter["operatingsystem"].value
+    when "Darwin":
+        def missing?(group)
+            output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
+
+            if output == ""
+                return true
+            else
+                return false
+            end
+
+            assert_equal("", output, "Group %s is present:\n%s" % [group, output])
+        end
+
+        def gid(name)
+            %x{nireport / /groups name gid}.split("\n").each { |line|
+                group, id = line.chomp.split(/\s+/)
+                assert(id =~ /^-?\d+$/, "Group id %s for %s is not a number" %
+                    [id.inspect, group])
+                if group == name
+                    return Integer(id)
+                end
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("niutil -destroy / /groups/%s" % group)
+        end
+    else
+        def missing?(group)
+            begin
+                obj = Etc.getgrnam(group)
+                return false
+            rescue ArgumentError
+                return true
+            end
+        end
+
+        def gid(name)
+            assert_nothing_raised {
+                obj = Etc.getgrnam(name)
+                return obj.gid
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("groupdel %s" % group)
+        end
+    end
+
+    def groupnames
+        %x{groups}.chomp.split(/ /)
+    end
+
+    def groupids
+        Process.groups
+    end
+
+    def attrtest_ensure(group)
+        old = group.ensure
+        assert_nothing_raised {
+            group.ensure = :absent
+        }
+
+        assert(!group.exists?, "Group was not deleted")
+
+        assert_nothing_raised {
+            group.ensure = :present
+        }
+        assert(group.exists?, "Group was not created")
+
+        unless old == :present
+            assert_nothing_raised {
+                group.ensure = old
+            }
+        end
+    end
+
+    def attrtest_gid(group)
+        old = gid(group.name)
+
+        newgid = old
+        while true
+            newgid += 1
+
+            if newgid - old > 1000
+                $stderr.puts "Could not find extra test UID"
+                return
+            end
+            begin
+                Etc.getgrgid(newgid)
+            rescue ArgumentError => detail
+                break
+            end
+        end
+
+        assert_nothing_raised("Failed to change group id") {
+            group.gid = newgid
+        }
+
+        curgid = nil
+        assert_nothing_raised {
+            curgid = gid(group.name)
+        }
+
+        assert_equal(newgid, curgid, "GID was not changed")
+        # Refresh
+        group.getinfo(true)
+        assert_equal(newgid, group.gid, "Object got wrong gid")
+
+        assert_nothing_raised("Failed to change group id") {
+            group.gid = old
+        }
+    end
+
+    # Iterate over each of our groups and try to grab the gid.
+    def test_ownprovidergroups
+        groupnames().each { |group|
+            gobj = nil
+            comp = nil
+            fakemodel = fakemodel(:group, group)
+            assert_nothing_raised {
+                gobj = @provider.new(fakemodel)
+            }
+
+            assert(gobj.gid, "Failed to retrieve gid")
+        }
+    end
+
+    if Puppet::Util::SUIDManager.uid == 0
+        def test_mkgroup
+            gobj = nil
+            comp = nil
+            name = "pptestgr"
+            assert(missing?(name), "Group %s is still present" % name)
+            group = mkgroup(name)
+
+            @@tmpgroups << name
+
+            assert(group.respond_to?(:addcmd), "no respondo?")
+            assert_nothing_raised {
+                group.create
+            }
+            assert(!missing?(name), "Group %s is missing" % name)
+
+            tests = Puppet.type(:group).validproperties
+
+            tests.each { |test|
+                if self.respond_to?("attrtest_%s" % test)
+                    self.send("attrtest_%s" % test, group)
+                else
+                    $stderr.puts "Not testing attr %s of group" % test
+                end
+            }
+
+            assert_nothing_raised {
+                group.delete
+            }
+        end
+
+        # groupadd -o is broken in FreeBSD.
+        unless Facter["operatingsystem"].value == "FreeBSD"
+        def test_duplicateIDs
+            group1 = mkgroup("group1", :gid => 125)
+            group2 = mkgroup("group2", :gid => 125)
+
+            @@tmpgroups << "group1"
+            @@tmpgroups << "group2"
+            # Create the first group
+            assert_nothing_raised {
+                group1.create
+            }
+
+            # Not all OSes fail here, so we can't test that it doesn't work with
+            # it off, only that it does work with it on.
+            assert_nothing_raised {
+                group2.model[:allowdupe] = :true
+            }
+
+            # Now create the second group
+            assert_nothing_raised {
+                group2.create
+            }
+            assert_equal(:present, group2.ensure,
+                         "Group did not get created")
+        end
+        end
+    else
+        $stderr.puts "Not running as root; skipping group creation tests."
+    end
+    
+    def test_autogen
+        provider = nil
+        group = Puppet::Type.type(:group).create(:name => nonrootgroup.name)
+        provider = group.provider
+        assert(provider, "did not get provider")
+
+        # Everyone should be able to autogenerate a uid
+        assert_instance_of(Fixnum, provider.autogen(:gid))
+    end
+end
+
+# $Id: group.rb 2178 2007-02-07 23:56:59Z luke $