finishing up user and group support for now

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@633 980ebf18-57e1-0310-9a29-db15c13687c0

3 files changed, 329 insertions, 75 deletions

diff --git a/test/puppettest.rb b/test/puppettest.rb
index 642c8275f..1543434e9 100644
--- a/test/puppettest.rb
+++ b/test/puppettest.rb
@@ -27,6 +27,40 @@ class TestPuppet < Test::Unit::TestCase
         Puppet::Type.allclear
     end
 
+    def assert_rollback_events(trans, events, msg)
+        run_events(:rollback, trans, events, msg)
+    end
+
+    def assert_events(comp, events, msg)
+        trans = nil
+        assert_nothing_raised("Component %s failed" % [msg]) {
+            trans = comp.evaluate
+        }
+
+        run_events(:evaluate, trans, events, msg)
+    end
+
+    def run_events(type, trans, events, msg)
+        case type
+        when :evaluate, :rollback: # things are hunky-dory
+        else
+            raise Puppet::DevError, "Incorrect run_events type"
+        end
+
+        method = type
+
+        newevents = nil
+        assert_nothing_raised("Transaction %s %s failed" % [type, msg]) {
+            newevents = trans.send(method).reject { |e| e.nil? }.collect { |e|
+                e.event
+            }
+        }
+
+        assert_equal(events, newevents, "Incorrect %s %s events" % [type, msg])
+
+        return trans
+    end
+
     def test_nothing
     end
 end
diff --git a/test/types/tc_group.rb b/test/types/tc_group.rb
index 7f3c1d01f..2a23535d4 100755
--- a/test/types/tc_group.rb
+++ b/test/types/tc_group.rb
@@ -14,6 +14,19 @@ require 'test/unit'
 class TestGroup < TestPuppet
     def setup
         Puppet[:loglevel] = :debug if __FILE__ == $0
+        @@tmpgroups = []
+        super
+    end
+
+    def teardown
+        @@tmpgroups.each { |group|
+            begin
+                obj = Etc.getgrnam(group)
+                system("groupdel %s" % group)
+            rescue ArgumentError => detail
+                # no such group, so we're fine
+            end
+        }
         super
     end
 
@@ -67,6 +80,10 @@ class TestGroup < TestPuppet
             gobj = nil
             comp = nil
             name = "pptestgr"
+
+            assert_raise(ArgumentError) {
+                obj = Etc.getgrnam(name)
+            }
             assert_nothing_raised {
                 gobj = Puppet::Type::Group.new(
                     :name => name
@@ -75,23 +92,19 @@ class TestGroup < TestPuppet
                 comp = newcomp("groupmaker %s" % name, gobj)
             }
 
-            trans = nil
-            assert_nothing_raised {
-                trans = comp.evaluate
-            }
+            trans = assert_events(comp, [:group_created], "group")
+            @@tmpgroups << name
 
-            events = nil
+            obj = nil
             assert_nothing_raised {
-                events = trans.evaluate.reject { |e| e.nil? }.collect { |e| e.event }
+                obj = Etc.getgrnam(name)
             }
 
-            assert_equal([:group_created], events, "Incorrect group events")
+            assert_rollback_events(trans, [:group_deleted], "group")
 
-            assert_nothing_raised {
-                events = trans.rollback.reject { |e| e.nil? }.collect { |e| e.event }
+            assert_raise(ArgumentError) {
+                obj = Etc.getgrnam(name)
             }
-
-            assert_equal([:group_deleted], events, "Incorrect deletion group events")
         end
     else
         $stderr.puts "Not running as root; skipping group creation tests."
diff --git a/test/types/tc_user.rb b/test/types/tc_user.rb
index 3522539d5..a70e55ce6 100755
--- a/test/types/tc_user.rb
+++ b/test/types/tc_user.rb
@@ -6,93 +6,300 @@ end
 
 # $Id$
 
+require 'etc'
 require 'puppet/type'
+require 'puppettest'
 require 'test/unit'
 
-class TestType < Test::Unit::TestCase
-    def test_typemethods
-        assert_nothing_raised() {
-            Puppet::Type.buildstatehash
+class TestUser < TestPuppet
+    def setup
+        @@tmpusers = []
+        Puppet[:loglevel] = :debug if __FILE__ == $0
+        super
+    end
+
+    def teardown
+        @@tmpusers.each { |user|
+            begin
+                obj = Etc.getpwnam(user)
+                system("userdel %s" % user)
+            rescue ArgumentError => detail
+                # no such user, so we're fine
+            end
         }
+        super
+    end
 
-        Puppet::Type.eachtype { |type|
-            name = nil
-            assert_nothing_raised() {
-                name = type.name
-            }
+    def attrtest_comment(user)
+        old = user.is(:comment)
+        user[:comment] = "A different comment"
 
-            assert(
-                name
-            )
+        comp = newcomp("commenttest", user)
 
-            assert_equal(
-                type,
-                Puppet::Type.type(name)
-            )
+        trans = assert_events(comp, [:user_modified], "user")
 
-            assert(
-                type.namevar
-            )
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
 
-            assert_not_nil(
-                type.states
-            )
+        assert_equal("A different comment", obj.gecos, "Comment was not changed")
 
-            assert_not_nil(
-                type.validstates
-            )
+        assert_rollback_events(trans, [:user_modified], "user")
 
-            assert(
-                type.validparameter?(type.namevar)
-            )
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
+
+        assert_equal(old, obj.gecos, "Comment was not reverted")
     end
 
-    def test_stringvssymbols
-        file = nil
-        path = "/tmp/testfile"
-        assert_nothing_raised() {
-            system("rm -f %s" % path)
-            file = Puppet::Type::PFile.new(
-                :path => path,
-                :create => true,
-                :recurse => true,
-                :checksum => "md5"
-            )
+    def attrtest_home(user)
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
-        assert_nothing_raised() {
-            file.retrieve
+        old = obj.dir
+        comp = newcomp("hometest", user)
+
+        user[:home] = old
+
+        trans = assert_events(comp, [], "user")
+
+        user[:home] = "/tmp"
+
+        trans = assert_events(comp, [:user_modified], "user")
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
-        assert_nothing_raised() {
-            file.sync
+
+        assert_equal("/tmp", obj.dir, "Home was not changed")
+
+        assert_rollback_events(trans, [:user_modified], "user")
+
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
-        Puppet::Type::PFile.clear
-        assert_nothing_raised() {
-            system("rm -f %s" % path)
-            file = Puppet::Type::PFile.new(
-                "path" => path,
-                "create" => true,
-                "recurse" => true,
-                "checksum" => "md5"
-            )
+
+        assert_equal(old, obj.dir, "Home was not reverted")
+    end
+
+    def attrtest_shell(user)
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
-        assert_nothing_raised() {
-            file.retrieve
+        old = obj.shell
+        comp = newcomp("shelltest", user)
+
+        user[:shell] = old
+
+        trans = assert_events(comp, [], "user")
+
+        newshell = %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|
+                FileTest.exists?(shell) and shell != old
         }
-        assert_nothing_raised() {
-            file[:path]
+
+        unless newshell
+            $stderr.puts "Cannot find alternate shell; skipping shell test"
+            return
+        end
+
+        user[:shell] = newshell
+
+        trans = assert_events(comp, [:user_modified], "user")
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+
+        assert_equal(newshell, obj.shell, "Shell was not changed")
+
+        assert_rollback_events(trans, [:user_modified], "user")
+
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
-        assert_nothing_raised() {
-            file["path"]
+
+        assert_equal(old, obj.shell, "Shell was not reverted")
+    end
+
+    def attrtest_gid(user)
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+        old = obj.gid
+        comp = newcomp("gidtest", user)
+
+        user[:gid] = old
+
+        trans = assert_events(comp, [], "user")
+
+        newgid = %w{nogroup nobody staff users daemon}.find { |gid|
+                begin
+                    group = Etc.getgrnam(gid)
+                rescue ArgumentError => detail
+                    false
+                end
+                old != group.gid
         }
-        assert_nothing_raised() {
-            file[:recurse]
+
+        unless newgid
+            $stderr.puts "Cannot find alternate group; skipping gid test"
+            return
+        end
+
+        # first test by name
+        assert_nothing_raised("Failed to specify group by name") {
+            user[:gid] = newgid
         }
-        assert_nothing_raised() {
-            file["recurse"]
+
+        trans = assert_events(comp, [:user_modified], "user")
+
+        # then by id
+        newgid = Etc.getgrnam(newgid).gid
+
+        assert_nothing_raised("Failed to specify group by id") {
+            user[:gid] = newgid
         }
-        assert_nothing_raised() {
-            file.sync
+
+        assert_events(comp, [], "user")
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
         }
+
+        assert_equal(newgid, obj.gid, "GID was not changed")
+
+        assert_rollback_events(trans, [:user_modified], "user")
+
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+
+        assert_equal(old, obj.gid, "GID was not reverted")
+    end
+
+    def attrtest_uid(user)
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+        old = obj.uid
+        comp = newcomp("uidtest", user)
+
+        user[:uid] = old
+
+        trans = assert_events(comp, [], "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
+        }
+
+        trans = assert_events(comp, [:user_modified], "user")
+
+        obj = nil
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+
+        assert_equal(newuid, obj.uid, "UID was not changed")
+
+        assert_rollback_events(trans, [:user_modified], "user")
+
+        assert_nothing_raised {
+            obj = Etc.getpwnam(user[:name])
+        }
+
+        assert_equal(old, obj.uid, "UID was not reverted")
+    end
+
+    def test_eachmethod
+        obj = Etc.getpwuid(Process.uid)
+
+        assert(obj, "Could not retrieve test group object")
+
+        Puppet::Type::User.validstates.each { |name, state|
+            assert_nothing_raised {
+                method = state.infomethod
+                assert(method, "State %s has no infomethod" % name)
+                assert(obj.respond_to?(method), "State %s has an invalid method %s" %
+                    [name, method])
+            }
+        }
+    end
+
+    if Process.uid == 0
+        def test_simpleuser
+            user = nil
+            name = "pptest"
+
+            assert_raise(ArgumentError) {
+                Etc.getpwnam(name)
+            }
+
+            assert_nothing_raised {
+                user = Puppet::Type::User.new(
+                    :name => name,
+                    :comment => "Puppet Testing User"
+                )
+            }
+
+            comp = newcomp("usercomp", user)
+
+            trans = assert_events(comp, [:user_created], "user")
+
+            @@tmpusers << name
+
+            obj = nil
+            assert_nothing_raised {
+                obj = Etc.getpwnam(name)
+            }
+
+            assert_equal("Puppet Testing User", obj.gecos, "Comment was not set")
+
+            tests = Puppet::Type::User.validstates.collect { |name, state|
+                state.name
+            }
+
+            user.retrieve
+            tests.each { |test|
+                if self.respond_to?("attrtest_%s" % test)
+                    self.send("attrtest_%s" % test, user)
+                else
+                    $stderr.puts "Not testing attr %s of user" % test
+                end
+            }
+
+            assert_rollback_events(trans, [:user_deleted], "user")
+
+            assert_raise(ArgumentError) {
+                Etc.getpwnam(user[:name])
+            }
+        end
+    else
+        $stderr.puts "Not root; skipping user creation/modification tests"
     end
 end