path: root/test/ral/providers/user.rb

#!/usr/bin/env ruby

require File.dirname(__FILE__) + '/../../lib/puppettest'

require 'puppettest'
require 'puppettest/support/utils'

class TestUserProvider < Test::Unit::TestCase
    include PuppetTest::Support::Utils
    include PuppetTest::FileTesting

    def setup
        super
        setme()
        @@tmpusers = []
        @provider = nil
        assert_nothing_raised {
            @provider = Puppet::Type.type(:user).defaultprovider
        }

        assert(@provider, "Could not find default user provider")

    end

    def teardown
        @@tmpusers.each { |user|
            remove(user) unless missing?(user)
        }
        super
    end

    case Facter["operatingsystem"].value
    when "Darwin"
        def missing?(user)
            output = %x{nidump -r /users/#{user} / 2>/dev/null}.chomp

            return output == ""

            assert_equal("", output, "User #{user} is present:\n#{output}")
        end

        def current?(param, user)
            property = Puppet::Type.type(:user).properties.find { |st|
                st.name == param
            }

            prov = Puppet::Type.type(:user).defaultprovider
            output = prov.report(param)
            output.each { |hash|
                if hash[:name] == user.name
                    val = hash[param]
                    if val =~ /^[-0-9]+$/
                        return Integer(val)
                    else
                        return val
                    end
                end
            }

            nil
        end

        def remove(user)
            system("niutil -destroy / /users/#{user}")
        end
    else
        def missing?(user)
                obj = Etc.getpwnam(user)
                return false
        rescue ArgumentError
                return true
        end

        def current?(param, user)
            property = Puppet::Type.type(:user).properties.find { |st|
                st.name == param
            }

            assert_nothing_raised {
                obj = Etc.getpwnam(user.name)
                return obj.send(user.posixmethod(param))
            }

            nil
        end

        def remove(user)
            system("userdel #{user}")
        end
    end


    def eachproperty
        Puppet::Type.type(:user).validproperties.each do |property|
            yield property
        end
    end

    def findshell(old = nil)
        %w{/bin/sh /bin/bash /sbin/sh /bin/ksh /bin/zsh /bin/csh /bin/tcsh
            /usr/bin/sh /usr/bin/bash /usr/bin/ksh /usr/bin/zsh /usr/bin/csh
            /usr/bin/tcsh}.find { |shell|
                if old
                    FileTest.exists?(shell) and shell != old
                else
                    FileTest.exists?(shell)
                end
        }
    end

    def fakedata(name, param)
        case param
        when :name; name
        when :ensure; :present
        when :comment; "Puppet's Testing User #{name}" # use a single quote a la #375
        when :gid; nonrootgroup.gid
        when :shell; findshell()
        when :home; "/home/#{name}"
        else
            return nil
        end
    end

    def fakeresource(*args)
        resource = super

        # Set boolean methods as necessary.
        class << resource
            def allowdupe?
                self[:allowdupe]
            end
            def managehome?
                self[:managehome]
            end
        end
        resource
    end

    def mkuser(name)
        fakeresource = fakeresource(:user, name)
        user = nil
        assert_nothing_raised {
            user = @provider.new(fakeresource)
        }
        assert(user, "Could not create provider user")

        user
    end

    def test_list
        names = nil
        assert_nothing_raised {
            names = @provider.listbyname
        }

        assert(names.length > 0, "Listed no users")

        # Now try it by object
        assert_nothing_raised {
            names = @provider.instances
        }
        assert(names.length > 0, "Listed no users as objects")

        names.each do |obj|
            assert_instance_of(@provider, obj)
        end
    end

    def test_infocollection
        fakeresource = fakeresource(:user, @me)

        user = nil
        assert_nothing_raised {
            user = @provider.new(fakeresource)
        }
        assert(user, "Could not create user provider")

        Puppet::Type.type(:user).validproperties.each do |property|
            next if property == :ensure
            # This is mostly in place for the 'password' stuff.
            next unless user.class.supports_parameter?(property) and Puppet.features.root?
            val = nil
            assert_nothing_raised {
                val = user.send(property)
            }


                assert(
                    val != :absent,

                    "Property #{property} is missing")

            assert(val, "Did not get value for #{property}")
        end
    end

    def test_exists
        user = mkuser("nosuchuserok")


            assert(
                ! user.exists?,

                "Fake user exists?")

        user = mkuser(@me)

            assert(
                user.exists?,

                "I don't exist?")
    end

    def attrtest_ensure(user)
        old = user.ensure
        assert_nothing_raised {
            user.delete
        }

        assert(missing?(user.name), "User is still present")
        assert_nothing_raised {
            user.create
        }
        assert(!missing?(user.name), "User is absent")
        assert_nothing_raised {
            user.delete
        }

        unless old == :absent
            user.create
        end
    end

    def attrtest_comment(user)
        old = user.comment

        newname = "Billy O'Neal" # use a single quote, a la #372
        assert_nothing_raised {
            user.comment = newname
        }


            assert_equal(
                newname, current?(:comment, user),

            "Comment was not changed")

        assert_nothing_raised {
            user.comment = old
        }


            assert_equal(
                old, current?(:comment, user),

            "Comment was not reverted")
    end

    def attrtest_home(user)
        old = current?(:home, user)

        assert_nothing_raised {
            user.home = "/tmp"
        }

        assert_equal("/tmp", current?(:home, user), "Home was not changed")
        assert_nothing_raised {
            user.home = old
        }

        assert_equal(old, current?(:home, user), "Home was not reverted")
    end

    def attrtest_shell(user)
        old = current?(:shell, user)

        newshell = findshell(old)

        unless newshell
            $stderr.puts "Cannot find alternate shell; skipping shell test"
            return
        end

        assert_nothing_raised {
            user.shell = newshell
        }


            assert_equal(
                newshell, current?(:shell, user),

            "Shell was not changed")

        assert_nothing_raised {
            user.shell = old
        }

        assert_equal(old, current?(:shell, user), "Shell was not reverted")
    end

    def attrtest_gid(user)
        old = current?(:gid, user)

        newgroup = %w{nogroup nobody staff users daemon}.find { |gid|
            begin
                group = Etc.getgrnam(gid)
                rescue ArgumentError => detail
                    next
                end
                old != group.gid
        }
        group = Etc.getgrnam(newgroup)

        unless newgroup
            $stderr.puts "Cannot find alternate group; skipping gid test"
            return
        end

        # Stupid DirectoryServices
        if Facter.value(:operatingsystem) == "Darwin"
            assert_raise(ArgumentError, "gid allowed a non-integer value") do
                user.gid = group.name
            end
        end

        assert_nothing_raised("Failed to specify group by id") {
            user.gid = group.gid
        }

        assert_equal(group.gid, current?(:gid,user), "GID was not changed")

        assert_nothing_raised("Failed to change back to old gid") {
            user.gid = old
        }
    end

    def attrtest_uid(user)
        old = current?(:uid, user)

        newuid = old
        while true
            newuid += 1

            if newuid - old > 1000
                $stderr.puts "Could not find extra test UID"
                return
            end
            begin
                newuser = Etc.getpwuid(newuid)
            rescue ArgumentError => detail
                break
            end
        end

        assert_nothing_raised("Failed to change user id") {
            user.uid = newuid
        }

        assert_equal(newuid, current?(:uid, user), "UID was not changed")

        assert_nothing_raised("Failed to change user id") {
            user.uid = old
        }
        assert_equal(old, current?(:uid, user), "UID was not changed back")
    end

    def attrtest_groups(user)
        Etc.setgrent
        max = 0
        while group = Etc.getgrent
            max = group.gid if group.gid > max and group.gid < 5000
        end

        groups = []
        main = []
        extra = []
        5.times do |i|
            i += 1
            name = "pptstgr#{i}"

                tmpgroup = Puppet::Type.type(:group).new(

                    :name => name,

                    :gid => max + i
            )

            groups << tmpgroup

            cleanup do
                tmpgroup.provider.delete if tmpgroup.provider.exists?
            end

            if i < 3
                main << name
            else
                extra << name
            end
        end

        # Create our test groups
        assert_apply(*groups)

        # Now add some of them to our user
        assert_nothing_raised {
            user.resource[:groups] = extra.join(",")
        }

        # Some tests to verify that groups work correctly startig from nothing
        # Remove our user
        user.delete

        # And add it again
        user.create

        # Make sure that the group list is added at creation time.
        # This is necessary because we don't have default fakedata for groups.
        assert(user.groups, "Did not retrieve group list")

        list = user.groups.split(",")
        assert_equal(extra.sort, list.sort, "Group list was not set at creation time")

        # Now set to our main list of groups
        assert_nothing_raised {
            user.groups = main.join(",")
        }

        list = user.groups.split(",")
        assert_equal(main.sort, list.sort, "Group list is not equal")
    end

    if Puppet.features.root?
        def test_simpleuser
            name = "pptest"

            assert(missing?(name), "User #{name} is present")

            user = mkuser(name)

            eachproperty do |property|
                if val = fakedata(user.name, property)
                    user.resource[property] = val
                end
            end

            @@tmpusers << name

            assert_nothing_raised {
                user.create
            }

            assert_equal("Puppet's Testing User pptest",
                user.comment,
                "Comment was not set")

            assert_nothing_raised {
                user.delete
            }

            assert(missing?(user.name), "User was not deleted")
        end

        def test_alluserproperties
            user = nil
            name = "pptest"

            assert(missing?(name), "User #{name} is present")

            user = mkuser(name)

            eachproperty do |property|
                if val = fakedata(user.name, property)
                    user.resource[property] = val
                end
            end

            @@tmpusers << name

            assert_nothing_raised {
                user.create
            }
            assert_equal("Puppet's Testing User pptest", user.comment,
                "Comment was not set")

            tests = Puppet::Type.type(:user).validproperties

            just = nil
            tests.each { |test|
                if self.respond_to?("attrtest_#{test}")
                    self.send("attrtest_#{test}", user)
                else
                    Puppet.err "Not testing attr #{test} of user"
                end
            }

            assert_nothing_raised {
                user.delete
            }
        end

        # This is a weird method that shows how annoying the interface between
        # types and providers is.  Grr.
        def test_duplicateIDs
            user1 = mkuser("user1")
            user1.create
            user1.uid = 125
            user2 = mkuser("user2")
            user2.resource[:uid] = 125

            cleanup do
                user1.delete
                user2.delete
            end

            # 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 {
                user2.resource[:allowdupe] = :true
            }
            assert_nothing_raised { user2.create }

                assert_equal(
                    :present, user2.ensure,

                        "User did not get created")
        end
    else
        $stderr.puts "Not root; skipping user creation/modification tests"
    end

    # Here is where we test individual providers
    def test_useradd_flags
        useradd = nil
        assert_nothing_raised {
            useradd = Puppet::Type.type(:user).provider(:useradd)
        }
        assert(useradd, "Did not retrieve useradd provider")

        user = nil
        assert_nothing_raised {
            fakeresource = fakeresource(:user, @me)
            user = useradd.new(fakeresource)
        }


            assert_equal(
                "-d", user.send(:flag, :home),

                    "Incorrect home flag")


                    assert_equal(
                        "-s", user.send(:flag, :shell),

                    "Incorrect shell flag")
    end

    def test_autogen
        provider = nil
        user = Puppet::Type.type(:user).new(:name => nonrootuser.name)
        provider = user.provider
        assert(provider, "did not get provider")

        # Everyone should be able to autogenerate a uid
        assert_instance_of(Fixnum, provider.autogen(:uid))

        # If we're Darwin, then we should get results, but everyone else should
        # get nil
        darwin = (Facter.value(:operatingsystem) == "Darwin")

        should = {
            :comment => user[:name].capitalize,
            :home => "/var/empty",
            :shell => "/usr/bin/false"
        }

        should.each do |param, value|
            if darwin
                assert_equal(value, provider.autogen(param), "did not autogen #{param} for darwin correctly")
            else
                assert_nil(provider.autogen(param), "autogenned #{param} for non-darwin os")
            end
        end
    end
end