puppet 0.25.5 → 2.6.0

data/test/ral/providers/service/base.rb

@@ -8,67 +8,73 @@ require File.dirname(__FILE__) + '/../../../lib/puppettest'
 require 'puppettest'
 
 class TestBaseServiceProvider < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    def test_base
-        running = tempfile()
+  def test_base
+    running = tempfile
 
-        commands = {}
-        %w{touch rm test}.each do |c|
-            path = %x{which #{c}}.chomp
-            if path == ""
-                $stderr.puts "Cannot find '#{c}'; cannot test base service provider"
-                return
-            end
-            commands[c.to_sym] = path
-        end
-        service = Puppet::Type.type(:service).new(
-            :name => "yaytest", :provider => :base,
-            :start => "%s %s" % [commands[:touch], running],
-            :status => "%s -f %s" % [commands[:test], running],
-            :stop => "%s %s" % [commands[:rm], running]
-        )
+    commands = {}
+    %w{touch rm test}.each do |c|
+      path = %x{which #{c}}.chomp
+      if path == ""
+        $stderr.puts "Cannot find '#{c}'; cannot test base service provider"
+        return
+      end
+      commands[c.to_sym] = path
+    end
+
+          service = Puppet::Type.type(:service).new(
+                
+      :name => "yaytest", :provider => :base,
+      :start => "#{commands[:touch]} #{running}",
+      :status => "#{commands[:test]} -f #{running}",
+        
+      :stop => "#{commands[:rm]} #{running}"
+    )
 
-        provider = service.provider
-        assert(provider, "did not get base provider")
+    provider = service.provider
+    assert(provider, "did not get base provider")
 
-        assert_nothing_raised do
-            provider.start
-        end
-        assert(FileTest.exists?(running), "start was not called correctly")
-        assert_nothing_raised do
-            assert_equal(:running, provider.status, "status was not returned correctly")
-        end
-        assert_nothing_raised do
-            provider.stop
-        end
-        assert(! FileTest.exists?(running), "stop was not called correctly")
-        assert_nothing_raised do
-            assert_equal(:stopped, provider.status, "status was not returned correctly")
-        end
+    assert_nothing_raised do
+      provider.start
+    end
+    assert(FileTest.exists?(running), "start was not called correctly")
+    assert_nothing_raised do
+      assert_equal(:running, provider.status, "status was not returned correctly")
     end
+    assert_nothing_raised do
+      provider.stop
+    end
+    assert(! FileTest.exists?(running), "stop was not called correctly")
+    assert_nothing_raised do
+      assert_equal(:stopped, provider.status, "status was not returned correctly")
+    end
+  end
+
+  # Testing #454
+  def test_that_failures_propagate
+    nope = "/no/such/command"
 
-    # Testing #454
-    def test_that_failures_propagate
-        nope = "/no/such/command"
-        service = Puppet::Type.type(:service).new(
-            :name => "yaytest", :provider => :base,
-            :start => nope,
-            :status => nope,
-            :stop => nope,
-            :restart => nope
-        )
+          service = Puppet::Type.type(:service).new(
+                
+      :name => "yaytest", :provider => :base,
+      :start => nope,
+      :status => nope,
+      :stop => nope,
+        
+      :restart => nope
+    )
 
-        provider = service.provider
-        assert(provider, "did not get base provider")
+    provider = service.provider
+    assert(provider, "did not get base provider")
 
-        # We can't fail well when status is messed up, because we depend on the return code
-        # of the command for data.
-        %w{start stop restart}.each do |command|
-            assert_raise(Puppet::Error, "did not throw error when %s failed" % command) do
-                provider.send(command)
-            end
-        end
+    # We can't fail well when status is messed up, because we depend on the return code
+    # of the command for data.
+    %w{start stop restart}.each do |command|
+      assert_raise(Puppet::Error, "did not throw error when #{command} failed") do
+        provider.send(command)
+      end
     end
+  end
 end
 

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

@@ -6,104 +6,107 @@ require 'puppettest'
 require 'puppettest/fileparsing'
 
 class TestParsedSSHKey < Test::Unit::TestCase
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-    def setup
-        super
-        @provider = Puppet::Type.type(:sshkey).provider(:parsed)
-
-        @oldfiletype = @provider.filetype
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+  def setup
+    super
+    @provider = Puppet::Type.type(:sshkey).provider(:parsed)
+
+    @oldfiletype = @provider.filetype
+  end
+
+  def teardown
+    Puppet::Util::FileType.filetype(:ram).clear
+    @provider.filetype = @oldfiletype
+    @provider.clear
+    super
+  end
+
+  def mkkey(name = "host.domain.com")
+    if defined?(@pcount)
+      @pcount += 1
+    else
+      @pcount = 1
     end
-
-    def teardown
-        Puppet::Util::FileType.filetype(:ram).clear
-        @provider.filetype = @oldfiletype
-        @provider.clear
-        super
-    end
-
-    def mkkey(name = "host.domain.com")
-        if defined? @pcount
-            @pcount += 1
-        else
-            @pcount = 1
-        end
-        args = {
-            :name => name || "/fspuppet%s" % @pcount,
-            :key => "thisismykey%s" % @pcount,
-            :host_aliases => ["host1.domain.com","192.168.0.1"],
-            :type => "dss",
-            :ensure => :present
-        }
-
-        fakeresource = fakeresource(:sshkey, args[:name])
-
-        key = @provider.new(fakeresource)
-        args.each do |p,v|
-            key.send(p.to_s + "=", v)
-        end
-
-        return key
+    args = {
+      :name => name || "/fspuppet#{@pcount}",
+      :key => "thisismykey#{@pcount}",
+      :host_aliases => ["host1.domain.com","192.168.0.1"],
+      :type => "dss",
+      :ensure => :present
+    }
+
+    fakeresource = fakeresource(:sshkey, args[:name])
+
+    key = @provider.new(fakeresource)
+    args.each do |p,v|
+      key.send(p.to_s + "=", v)
     end
 
-    def test_keysparse
-        fakedata("data/types/sshkey").each { |file|
-            fakedataparse(file)
-        }
-    end
+    key
+  end
 
-    def test_simplekey
-        @provider.filetype = :ram
-        file = @provider.default_target
+  def test_keysparse
+    fakedata("data/types/sshkey").each { |file|
+      fakedataparse(file)
+    }
+  end
 
-        key = nil
-        assert_nothing_raised do
-            key = mkkey
-        end
+  def test_simplekey
+    @provider.filetype = :ram
+    file = @provider.default_target
 
-        assert(key, "did not create key")
+    key = nil
+    assert_nothing_raised do
+      key = mkkey
+    end
 
-        assert_nothing_raised do
-            key.flush
-        end
+    assert(key, "did not create key")
 
-        assert(key.host_aliases, "No host_aliases set for key")
+    assert_nothing_raised do
+      key.flush
+    end
 
-        hash = key.property_hash.dup
-        text = @provider.target_object(file).read
-        names = [key.name, key.host_aliases].flatten.join(",")
+    assert(key.host_aliases, "No host_aliases set for key")
 
-        assert_equal("#{names} #{key.type} #{key.key}\n", text)
+    hash = key.property_hash.dup
+    text = @provider.target_object(file).read
+    names = [key.name, key.host_aliases].flatten.join(",")
 
-        assert_nothing_raised do
-            @provider.prefetch
-        end
+    assert_equal("#{names} #{key.type} #{key.key}\n", text)
 
-        hash.each do |p, v|
-            next unless key.respond_to?(p)
-            assert_equal(v, key.send(p), "%s did not match" % p)
-        end
+    assert_nothing_raised do
+      @provider.prefetch
+    end
 
-        assert(key.name !~ /,/, "Aliases were not split out during parsing")
+    hash.each do |p, v|
+      next unless key.respond_to?(p)
+      assert_equal(v, key.send(p), "#{p} did not match")
     end
 
-    def test_hooks
-        result = nil
-        assert_nothing_raised("Could not call post hook") do
-            result = @provider.parse_line("one,two type key")
-        end
-        assert_equal("one", result[:name], "Did not call post hook")
-        assert_equal(%w{two}, result[:host_aliases], "Did not call post hook")
-
-        assert_equal("one,two type key",
-            @provider.to_line(:record_type => :parsed,
-            :name => "one",
-            :host_aliases => %w{two},
-            :type => "type",
-            :key => "key"),
-            "Did not use pre-hook when generating line"
-        )
+    assert(key.name !~ /,/, "Aliases were not split out during parsing")
+  end
+
+  def test_hooks
+    result = nil
+    assert_nothing_raised("Could not call post hook") do
+      result = @provider.parse_line("one,two type key")
     end
+    assert_equal("one", result[:name], "Did not call post hook")
+    assert_equal(%w{two}, result[:host_aliases], "Did not call post hook")
+
+
+          assert_equal(
+        "one,two type key",
+      @provider.to_line(:record_type => :parsed,
+      :name => "one",
+      :host_aliases => %w{two},
+      :type => "type",
+        
+      :key => "key"),
+      "Did not use pre-hook when generating line"
+    )
+  end
 end
 

data/test/ral/providers/user.rb

@@ -6,561 +6,581 @@ require 'puppettest'
 require 'puppettest/support/utils'
 
 class TestUserProvider < Test::Unit::TestCase
-    include PuppetTest::Support::Utils
-    include PuppetTest::FileTesting
+  include PuppetTest::Support::Utils
+  include PuppetTest::FileTesting
 
-    def setup
-        super
-        setme()
-        @@tmpusers = []
-        @provider = nil
-        assert_nothing_raised {
-            @provider = Puppet::Type.type(:user).defaultprovider
-        }
+  def setup
+    super
+    setme
+    @@tmpusers = []
+    @provider = nil
+    assert_nothing_raised {
+      @provider = Puppet::Type.type(:user).defaultprovider
+    }
 
-        assert(@provider, "Could not find default user provider")
+    assert(@provider, "Could not find default user provider")
 
-    end
+  end
 
-    def teardown
-        @@tmpusers.each { |user|
-            unless missing?(user)
-                remove(user)
-            end
-        }
-        super
-    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
+  case Facter["operatingsystem"].value
+  when "Darwin"
+    def missing?(user)
+      output = %x{nidump -r /users/#{user} / 2>/dev/null}.chomp
 
-            if output == ""
-                return true
-            else
-                return false
-            end
+      return output == ""
 
-            assert_equal("", output, "User %s is present:\n%s" % [user, output])
-        end
+      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
-            }
-
-            return nil
+    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
+      }
 
-        def remove(user)
-            system("niutil -destroy / /users/%s" % user)
-        end
-    else
-        def missing?(user)
-            begin
-                obj = Etc.getpwnam(user)
-                return false
-            rescue ArgumentError
-                return true
-            end
-        end
+      nil
+    end
 
-        def current?(param, user)
-            property = Puppet::Type.type(:user).properties.find { |st|
-                st.name == param
-            }
+    def remove(user)
+      system("niutil -destroy / /users/#{user}")
+    end
+  else
+    def missing?(user)
+        obj = Etc.getpwnam(user)
+        return false
+    rescue ArgumentError
+        return true
+    end
 
-            assert_nothing_raised {
-                obj = Etc.getpwnam(user.name)
-                return obj.send(user.posixmethod(param))
-            }
+    def current?(param, user)
+      property = Puppet::Type.type(:user).properties.find { |st|
+        st.name == param
+      }
 
-            return nil
-        end
+      assert_nothing_raised {
+        obj = Etc.getpwnam(user.name)
+        return obj.send(user.posixmethod(param))
+      }
 
-        def remove(user)
-            system("userdel %s" % user)
-        end
+      nil
     end
 
-
-    def eachproperty
-        Puppet::Type.type(:user).validproperties.each do |property|
-            yield property
-        end
+    def remove(user)
+      system("userdel #{user}")
     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 %s" % name # use a single quote a la #375
-        when :gid; nonrootgroup.gid
-        when :shell; findshell()
-        when :home; "/home/%s" % name
+  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
-            return nil
+          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
-
-    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 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 mkuser(name)
-        fakeresource = fakeresource(:user, name)
-        user = nil
-        assert_nothing_raised {
-            user = @provider.new(fakeresource)
-        }
-        assert(user, "Could not create provider user")
+  def test_infocollection
+    fakeresource = fakeresource(:user, @me)
 
-        return user
-    end
+    user = nil
+    assert_nothing_raised {
+      user = @provider.new(fakeresource)
+    }
+    assert(user, "Could not create user provider")
 
-    def test_list
-        names = nil
-        assert_nothing_raised {
-            names = @provider.listbyname
-        }
+    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(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")
+        assert(
+          val != :absent,
 
-        names.each do |obj|
-            assert_instance_of(@provider, obj)
-        end
+          "Property #{property} is missing")
+
+      assert(val, "Did not get value for #{property}")
     end
+  end
 
-    def test_infocollection
-        fakeresource = fakeresource(:user, @me)
+  def test_exists
+    user = mkuser("nosuchuserok")
 
-        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(
+        ! user.exists?,
 
-            assert(val != :absent,
-                   "Property %s is missing" % property)
+        "Fake user exists?")
 
-            assert(val, "Did not get value for %s" % property)
-        end
-    end
+    user = mkuser(@me)
 
-    def test_exists
-        user = mkuser("nosuchuserok")
+      assert(
+        user.exists?,
 
-        assert(! user.exists?,
-               "Fake user exists?")
+        "I don't exist?")
+  end
 
-        user = mkuser(@me)
-        assert(user.exists?,
-               "I don't exist?")
-    end
+  def attrtest_ensure(user)
+    old = user.ensure
+    assert_nothing_raised {
+      user.delete
+    }
 
-    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
+    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
+  def attrtest_comment(user)
+    old = user.comment
 
-        newname = "Billy O'Neal" # use a single quote, a la #372
-        assert_nothing_raised {
-            user.comment = newname
-        }
+    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(
+        newname, current?(:comment, user),
 
-        assert_equal(old, current?(:comment, user),
-            "Comment was not reverted")
-    end
+      "Comment was not changed")
 
-    def attrtest_home(user)
-        old = current?(:home, user)
+    assert_nothing_raised {
+      user.comment = old
+    }
 
-        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?(:comment, user),
 
-        assert_equal(old, current?(:home, user), "Home was not reverted")
-    end
+      "Comment was not reverted")
+  end
 
-    def attrtest_shell(user)
-        old = current?(:shell, user)
+  def attrtest_home(user)
+    old = current?(:home, user)
 
-        newshell = findshell(old)
+    assert_nothing_raised {
+      user.home = "/tmp"
+    }
 
-        unless newshell
-            $stderr.puts "Cannot find alternate shell; skipping shell test"
-            return
-        end
+    assert_equal("/tmp", current?(:home, user), "Home was not changed")
+    assert_nothing_raised {
+      user.home = old
+    }
 
-        assert_nothing_raised {
-            user.shell = newshell
-        }
+    assert_equal(old, current?(:home, user), "Home was not reverted")
+  end
 
-        assert_equal(newshell, current?(:shell, user),
-            "Shell was not changed")
+  def attrtest_shell(user)
+    old = current?(:shell, user)
 
-        assert_nothing_raised {
-            user.shell = old
-        }
+    newshell = findshell(old)
 
-        assert_equal(old, current?(:shell, user), "Shell was not reverted")
+    unless newshell
+      $stderr.puts "Cannot find alternate shell; skipping shell test"
+      return
     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
+    assert_nothing_raised {
+      user.shell = newshell
+    }
 
-        # 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(
+        newshell, current?(:shell, user),
 
-        assert_equal(group.gid, current?(:gid,user), "GID was not changed")
+      "Shell was not changed")
 
-        assert_nothing_raised("Failed to change back to old gid") {
-            user.gid = old
-        }
-    end
+    assert_nothing_raised {
+      user.shell = old
+    }
 
-    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
+    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)
 
-        assert_nothing_raised("Failed to change user id") {
-            user.uid = newuid
-        }
+    unless newgroup
+      $stderr.puts "Cannot find alternate group; skipping gid test"
+      return
+    end
 
-        assert_equal(newuid, current?(:uid, user), "UID was not changed")
+    # 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 change user id") {
-            user.uid = old
-        }
-        assert_equal(old, current?(:uid, user), "UID was not changed back")
+    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
 
-    def attrtest_groups(user)
-        Etc.setgrent
-        max = 0
-        while group = Etc.getgrent
-            if group.gid > max and group.gid < 5000
-                max = group.gid
-            end
-        end
+    assert_nothing_raised("Failed to change user id") {
+      user.uid = newuid
+    }
 
-        groups = []
-        main = []
-        extra = []
-        5.times do |i|
-            i += 1
-            name = "pptstgr%s" % 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
+    assert_equal(newuid, current?(:uid, user), "UID was not changed")
 
-        # Create our test groups
-        assert_apply(*groups)
+    assert_nothing_raised("Failed to change user id") {
+      user.uid = old
+    }
+    assert_equal(old, current?(:uid, user), "UID was not changed back")
+  end
 
-        # Now add some of them to our user
-        assert_nothing_raised {
-            user.resource[:groups] = extra.join(",")
-        }
+  def attrtest_groups(user)
+    Etc.setgrent
+    max = 0
+    while group = Etc.getgrent
+      max = group.gid if group.gid > max and group.gid < 5000
+    end
 
-        # Some tests to verify that groups work correctly startig from nothing
-        # Remove our user
-        user.delete
+    groups = []
+    main = []
+    extra = []
+    5.times do |i|
+      i += 1
+      name = "pptstgr#{i}"
 
-        # And add it again
-        user.create
+        tmpgroup = Puppet::Type.type(:group).new(
+
+          :name => name,
 
-        # 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")
+          :gid => max + i
+      )
 
-        list = user.groups.split(",")
-        assert_equal(extra.sort, list.sort, "Group list was not set at creation time")
+      groups << tmpgroup
 
-        # Now set to our main list of groups
-        assert_nothing_raised {
-            user.groups = main.join(",")
-        }
+      cleanup do
+        tmpgroup.provider.delete if tmpgroup.provider.exists?
+      end
 
-        list = user.groups.split(",")
-        assert_equal(main.sort, list.sort, "Group list is not equal")
+      if i < 3
+        main << name
+      else
+        extra << name
+      end
     end
 
-    if Puppet::Util::SUIDManager.uid == 0
-        def test_simpleuser
-            name = "pptest"
+    # Create our test groups
+    assert_apply(*groups)
+
+    # Now add some of them to our user
+    assert_nothing_raised {
+      user.resource[:groups] = extra.join(",")
+    }
 
-            assert(missing?(name), "User %s is present" % name)
+    # Some tests to verify that groups work correctly startig from nothing
+    # Remove our user
+    user.delete
 
-            user = mkuser(name)
+    # And add it again
+    user.create
 
-            eachproperty do |property|
-                if val = fakedata(user.name, property)
-                    user.resource[property] = val
-                end
-            end
+    # 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")
 
-            @@tmpusers << name
+    list = user.groups.split(",")
+    assert_equal(extra.sort, list.sort, "Group list was not set at creation time")
 
-            assert_nothing_raised {
-                user.create
-            }
+    # Now set to our main list of groups
+    assert_nothing_raised {
+      user.groups = main.join(",")
+    }
 
-            assert_equal("Puppet's Testing User pptest",
-                 user.comment,
-                "Comment was not set")
+    list = user.groups.split(",")
+    assert_equal(main.sort, list.sort, "Group list is not equal")
+  end
 
-            assert_nothing_raised {
-                user.delete
-            }
+  if Puppet.features.root?
+    def test_simpleuser
+      name = "pptest"
 
-            assert(missing?(user.name), "User was not deleted")
+      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
 
-        def test_alluserproperties
-            user = nil
-            name = "pptest"
+      @@tmpusers << name
 
-            assert(missing?(name), "User %s is present" % name)
+      assert_nothing_raised {
+        user.create
+      }
 
-            user = mkuser(name)
+      assert_equal("Puppet's Testing User pptest",
+        user.comment,
+        "Comment was not set")
 
-            eachproperty do |property|
-                if val = fakedata(user.name, property)
-                    user.resource[property] = val
-                end
-            end
+      assert_nothing_raised {
+        user.delete
+      }
 
-            @@tmpusers << name
+      assert(missing?(user.name), "User was not deleted")
+    end
 
-            assert_nothing_raised {
-                user.create
-            }
-            assert_equal("Puppet's Testing User pptest", user.comment,
-                "Comment was not set")
+    def test_alluserproperties
+      user = nil
+      name = "pptest"
 
-            tests = Puppet::Type.type(:user).validproperties
+      assert(missing?(name), "User #{name} is present")
 
-            just = nil
-            tests.each { |test|
-                if self.respond_to?("attrtest_%s" % test)
-                    self.send("attrtest_%s" % test, user)
-                else
-                    Puppet.err "Not testing attr %s of user" % test
-                end
-            }
+      user = mkuser(name)
 
-            assert_nothing_raised {
-                user.delete
-            }
+      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")
 
-        # 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")
+      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
-    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")
+      assert_nothing_raised {
+        user.delete
+      }
     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 %s for darwin correctly" % param)
-            else
-                assert_nil(provider.autogen(param), "autogenned %s for non-darwin os" % param)
-            end
-        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