puppet 0.25.5 → 2.6.0

data/test/ral/type/service.rb

@@ -6,33 +6,33 @@ require 'puppettest'
 require 'mocha'
 
 class TestServiceType < Test::Unit::TestCase
-    include PuppetTest
+  include PuppetTest
 
-    # #199
-    def test_no_refresh_when_starting
-        service = Puppet::Type.type(:service).new :name => "hopefully_this_isnt_in_the_process_table",
-            :ensure => :running, :provider => :base
+  # #199
+  def test_no_refresh_when_starting
+    service = Puppet::Type.type(:service).new :name => "hopefully_this_isnt_in_the_process_table",
+      :ensure => :running, :provider => :base
 
-        assert_equal :running, service.instance_eval('@parameters[:ensure]').should
-        assert_not_equal :running, service.instance_eval('@parameters[:ensure]').retrieve, "You have something called #{service.name} in your process table"
+    assert_equal :running, service.instance_eval('@parameters[:ensure]').should
+    assert_not_equal :running, service.instance_eval('@parameters[:ensure]').retrieve, "You have something called #{service.name} in your process table"
 
-        # First make sure it does not refresh
-        service.provider.expects(:restart).never
+    # First make sure it does not refresh
+    service.provider.expects(:restart).never
 
-        assert_nothing_raised do
-            service.refresh
-        end
+    assert_nothing_raised do
+      service.refresh
     end
+  end
 
-    def test_refresh_normally
-        service = Puppet::Type.type(:service).new :name => "testing",
-            :ensure => :running, :provider => :base, :status => "cat /dev/null"
+  def test_refresh_normally
+    service = Puppet::Type.type(:service).new :name => "testing",
+      :ensure => :running, :provider => :base, :status => "cat /dev/null"
 
-        service.provider.expects(:restart)
+    service.provider.expects(:restart)
 
-        assert_nothing_raised do
-            service.refresh
-        end
+    assert_nothing_raised do
+      service.refresh
     end
+  end
 end
 

data/test/ral/type/sshkey.rb

@@ -6,183 +6,143 @@ require 'puppettest'
 require 'facter'
 
 class TestSSHKey < Test::Unit::TestCase
-    include PuppetTest
-    def setup
-        super
-        # god i'm lazy
-        @sshkeytype = Puppet::Type.type(:sshkey)
-
-        @provider = @sshkeytype.defaultprovider
-
-        # Make sure they are using the parsed provider
-        unless @provider.name == :parsed
-            @sshkeytype.defaultprovider = @sshkeytype.provider(:parsed)
-        end
-
-        cleanup do @sshkeytype.defaultprovider = nil end
-
-        if @provider.respond_to?(:default_target)
-            oldpath = @provider.default_target
-            cleanup do
-                @provider.default_target = oldpath
-            end
-            @provider.default_target = tempfile()
-        end
-    end
-
-    def teardown
-        super
-        if @provider.respond_to?(:clear)
-            @provider.clear
-        end
-    end
-
-    def mkkey
-        key = nil
-
-        if defined? @kcount
-            @kcount += 1
-        else
-            @kcount = 1
-        end
-
-        @catalog ||= mk_catalog
+  include PuppetTest
+  def setup
+    super
+    # god i'm lazy
+    @sshkeytype = Puppet::Type.type(:sshkey)
 
-        key = @sshkeytype.new(
-            :name => "host%s.madstop.com" % @kcount,
-            :key => "%sAAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=" % @kcount,
-            :type => "ssh-dss",
-            :alias => ["192.168.0.%s" % @kcount],
-            :catalog => @catalog
-        )
+    @provider = @sshkeytype.defaultprovider
 
-        @catalog.add_resource(key)
-
-        return key
-    end
-
-    def test_instances
-        list = nil
-        assert_nothing_raised {
-            list = Puppet::Type.type(:sshkey).instances
-        }
-
-        count = 0
-        list.each do |h|
-            count += 1
-        end
-
-        assert_equal(0, count, "Found sshkeys in empty file somehow")
+    # Make sure they are using the parsed provider
+    unless @provider.name == :parsed
+      @sshkeytype.defaultprovider = @sshkeytype.provider(:parsed)
     end
 
-    def test_simplekey
-        key = mkkey
-        file = tempfile()
-        key[:target] = file
-        key[:provider] = :parsed
-
-        assert_apply(key)
-
-        assert_events([], key, "created events on in-sync key")
-
-        assert(key.provider.exists?, "Key did not get created")
-
-        # Now create a new key object
-        name = key.name
-        key = nil
-
-        key = @sshkeytype.new :name => name, :target => file, :provider => :parsed
-        key.retrieve
-
-        assert(key.provider.exists?, "key thinks it does not exist")
+    cleanup do @sshkeytype.defaultprovider = nil end
 
+    if @provider.respond_to?(:default_target)
+      oldpath = @provider.default_target
+      cleanup do
+        @provider.default_target = oldpath
+      end
+      @provider.default_target = tempfile
     end
+  end
 
-    def test_moddingkey
-        key = mkkey()
-
-        @catalog.apply
+  def teardown
+    super
+    @provider.clear if @provider.respond_to?(:clear)
+  end
 
-        key.retrieve
+  def mkkey
+    key = nil
 
-        aliases = %w{madstop kirby yayness}
-        key[:alias] = aliases
-
-        @catalog.apply
-
-        aliases.each do |name|
-            assert_equal(key.object_id, @catalog.resource(:sshkey, name).object_id, "alias %s was not set" % name)
-        end
+    if defined?(@kcount)
+      @kcount += 1
+    else
+      @kcount = 1
     end
 
-    def test_aliasisproperty
-        assert_equal(:property, @sshkeytype.attrtype(:host_aliases))
-    end
+    @catalog ||= mk_catalog
 
-    def test_multivalues
-        key = mkkey
-        assert_raise(Puppet::Error) {
-            key[:host_aliases] = "puppetmasterd yayness"
-        }
-    end
 
-    def test_puppetalias
-        key = mkkey()
+          key = @sshkeytype.new(
+                
+      :name => "host#{@kcount}.madstop.com",
+      :key => "#{@kcount}AAAAB3NzaC1kc3MAAACBAMnhSiku76y3EGkNCDsUlvpO8tRgS9wL4Eh54WZfQ2lkxqfd2uT/RTT9igJYDtm/+UHuBRdNGpJYW1Nw2i2JUQgQEEuitx4QKALJrBotejGOAWxxVk6xsh9xA0OW8Q3ZfuX2DDitfeC8ZTCl4xodUMD8feLtP+zEf8hxaNamLlt/AAAAFQDYJyf3vMCWRLjTWnlxLtOyj/bFpwAAAIEAmRxxXb4jjbbui9GYlZAHK00689DZuX0EabHNTl2yGO5KKxGC6Esm7AtjBd+onfu4Rduxut3jdI8GyQCIW8WypwpJofCIyDbTUY4ql0AQUr3JpyVytpnMijlEyr41FfIb4tnDqnRWEsh2H7N7peW+8DWZHDFnYopYZJ9Yu4/jHRYAAACAERG50e6aRRb43biDr7Ab9NUCgM9bC0SQscI/xdlFjac0B/kSWJYTGVARWBDWug705hTnlitY9cLC5Ey/t/OYOjylTavTEfd/bh/8FkAYO+pWdW3hx6p97TBffK0b6nrc6OORT2uKySbbKOn0681nNQh4a6ueR3JRppNkRPnTk5c=",
+      :type => "ssh-dss",
+      :alias => ["192.168.0.#{@kcount}"],
+        
+      :catalog => @catalog
+    )
 
-        assert_nothing_raised {
-            key[:alias] = "testing"
-        }
+    @catalog.add_resource(key)
 
-        key.finish
+    key
+  end
 
-        same = @catalog.resource(:sshkey, "testing")
-        assert(same, "Could not retrieve by alias")
-    end
+  def test_instances
+    list = nil
+    assert_nothing_raised {
+      list = Puppet::Type.type(:sshkey).instances
+    }
 
-    def test_removal
-        sshkey = mkkey()
-        assert_nothing_raised {
-            sshkey[:ensure] = :present
-        }
-        assert_events([:sshkey_created], sshkey)
-
-        assert(sshkey.provider.exists?, "key was not created")
-        assert_nothing_raised {
-            sshkey[:ensure] = :absent
-        }
-
-        assert_events([:sshkey_removed], sshkey)
-        assert(! sshkey.provider.exists?, "Key was not deleted")
-        assert_events([], sshkey)
+    count = 0
+    list.each do |h|
+      count += 1
     end
 
-    # Make sure changes actually modify the file.
-    def test_modifyingfile
-        keys = []
-        names = []
-        3.times {
-            k = mkkey()
-            #h[:ensure] = :present
-            #h.retrieve
-            keys << k
-            names << k.name
-        }
-        assert_apply(*keys)
-        keys.clear
-
-        @catalog.clear(true)
-        @catalog = nil
-
-        newkey = mkkey()
-        #newkey[:ensure] = :present
-        names << newkey.name
-        assert_apply(newkey)
-
-        # Verify we can retrieve that info
-        assert_nothing_raised("Could not retrieve after second write") {
-            newkey.provider.prefetch
-        }
-
-        assert(newkey.provider.exists?, "Did not see key in file")
-    end
+    assert_equal(0, count, "Found sshkeys in empty file somehow")
+  end
+
+  def test_simplekey
+    key = mkkey
+    file = tempfile
+    key[:target] = file
+    key[:provider] = :parsed
+
+    assert_apply(key)
+
+    assert_events([], key, "created events on in-sync key")
+
+    assert(key.provider.exists?, "Key did not get created")
+
+    # Now create a new key object
+    name = key.name
+    key = nil
+
+    key = @sshkeytype.new :name => name, :target => file, :provider => :parsed
+    key.retrieve
+
+    assert(key.provider.exists?, "key thinks it does not exist")
+
+  end
+
+  def test_removal
+    sshkey = mkkey
+    assert_nothing_raised {
+      sshkey[:ensure] = :present
+    }
+    assert_events([:sshkey_created], sshkey)
+
+    assert(sshkey.provider.exists?, "key was not created")
+    assert_nothing_raised {
+      sshkey[:ensure] = :absent
+    }
+
+    assert_events([:sshkey_removed], sshkey)
+    assert(! sshkey.provider.exists?, "Key was not deleted")
+    assert_events([], sshkey)
+  end
+
+  # Make sure changes actually modify the file.
+  def test_modifyingfile
+    keys = []
+    names = []
+    3.times {
+      k = mkkey
+      #h[:ensure] = :present
+      #h.retrieve
+      keys << k
+      names << k.name
+    }
+    assert_apply(*keys)
+    keys.clear
+
+    @catalog.clear(true)
+    @catalog = nil
+
+    newkey = mkkey
+    #newkey[:ensure] = :present
+    names << newkey.name
+    assert_apply(newkey)
+
+    # Verify we can retrieve that info
+    assert_nothing_raised("Could not retrieve after second write") {
+      newkey.provider.prefetch
+    }
+
+    assert(newkey.provider.exists?, "Did not see key in file")
+  end
 end

data/test/ral/type/user.rb

@@ -6,444 +6,162 @@ require 'puppettest'
 require 'etc'
 
 class TestUser < Test::Unit::TestCase
-    include PuppetTest
-
-    p = Puppet::Type.type(:user).provide :fake, :parent => PuppetTest::FakeProvider do
-        @name = :fake
-        apimethods
-        def create
-            @ensure = :present
-            @resource.send(:properties).each do |property|
-                next if property.name == :ensure
-                property.sync
-            end
-        end
-
-        def delete
-            @ensure = :absent
-            @resource.send(:properties).each do |property|
-                send(property.name.to_s + "=", :absent)
-            end
-        end
-
-        def exists?
-            if defined? @ensure and @ensure == :present
-                true
-            else
-                false
-            end
+  include PuppetTest
+
+  p = Puppet::Type.type(:user).provide :fake, :parent => PuppetTest::FakeProvider do
+    @name = :fake
+    apimethods
+    def create
+      @ensure = :present
+      @resource.send(:properties).each do |property|
+        next if property.name == :ensure
+        property.sync
+      end
+    end
+
+    def delete
+      @ensure = :absent
+      @resource.send(:properties).each do |property|
+        send(property.name.to_s + "=", :absent)
+      end
+    end
+
+    def exists?
+      if @ensure == :present
+        true
+      else
+        false
+      end
+    end
+  end
+
+  FakeUserProvider = p
+
+  @@fakeproviders[:group] = p
+
+  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
+    }
+  end
 
-    FakeUserProvider = p
+  def setup
+    super
+    Puppet::Type.type(:user).defaultprovider = FakeUserProvider
+  end
 
-    @@fakeproviders[:group] = p
+  def teardown
+    Puppet::Type.type(:user).defaultprovider = nil
+    super
+  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 mkuser(name)
+    user = nil
+    assert_nothing_raised {
 
-    def setup
-        super
-        Puppet::Type.type(:user).defaultprovider = FakeUserProvider
-    end
-
-    def teardown
-        Puppet::Type.type(:user).defaultprovider = nil
-        super
-    end
-
-    def mkuser(name)
-        user = nil
-        assert_nothing_raised {
             user = Puppet::Type.type(:user).new(
-                :name => name,
-                :comment => "Puppet Testing User",
-                :gid => Puppet::Util::SUIDManager.gid,
-                :shell => findshell(),
-                :home => "/home/%s" % name
-            )
-        }
-
-        assert(user, "Did not create user")
-
-        return user
-    end
-
-    def attrtest_ensure(user)
-        old = user.provider.ensure
-        user[:ensure] = :absent
-
-        comp = mk_catalog("ensuretest", user)
-        assert_apply(user)
-        assert(!user.provider.exists?, "User is still present")
-        user[:ensure] = :present
-        assert_events([:user_created], comp)
-        assert(user.provider.exists?, "User is absent")
-        user[:ensure] = :absent
-        trans = assert_events([:user_removed], comp)
-
-        assert_rollback_events(trans, [:user_created], "user")
-
-        user[:ensure] = old
-        assert_apply(user)
-    end
-
-    def attrtest_comment(user)
-        user.retrieve
-        old = user.provider.comment
-        user[:comment] = "A different comment"
-
-        comp = mk_catalog("commenttest", user)
-
-        trans = assert_events([:user_changed], comp, "user")
-
-        assert_equal("A different comment", user.provider.comment,
-            "Comment was not changed")
-
-        assert_rollback_events(trans, [:user_changed], "user")
-
-        assert_equal(old, user.provider.comment,
-            "Comment was not reverted")
-    end
-
-    def attrtest_home(user)
-        obj = nil
-        comp = mk_catalog("hometest", user)
-
-        old = user.provider.home
-        user[:home] = old
-
-        trans = assert_events([], comp, "user")
-
-        user[:home] = "/tmp"
-
-        trans = assert_events([:user_changed], comp, "user")
-
-        assert_equal("/tmp", user.provider.home, "Home was not changed")
-
-        assert_rollback_events(trans, [:user_changed], "user")
-
-        assert_equal(old, user.provider.home, "Home was not reverted")
-    end
-
-    def attrtest_shell(user)
-        old = user.provider.shell
-        comp = mk_catalog("shelltest", user)
-
-        user[:shell] = old
-
-        trans = assert_events([], comp, "user")
-
-        newshell = findshell(old)
-
-        unless newshell
-            $stderr.puts "Cannot find alternate shell; skipping shell test"
-            return
-        end
-
-        user[:shell] = newshell
-
-        trans = assert_events([:user_changed], comp, "user")
-
-        user.retrieve
-        assert_equal(newshell, user.provider.shell,
-            "Shell was not changed")
-
-        assert_rollback_events(trans, [:user_changed], "user")
-        user.retrieve
-
-        assert_equal(old, user.provider.shell, "Shell was not reverted")
-    end
-
-    def attrtest_uid(user)
-        obj = nil
-        comp = mk_catalog("uidtest", user)
-
-        user.provider.uid = 1
-
-        old = 1
-        newuid = 1
-        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([:user_changed], comp, "user")
-
-        assert_equal(newuid, user.provider.uid, "UID was not changed")
-
-        assert_rollback_events(trans, [:user_changed], "user")
-
-        assert_equal(old, user.provider.uid, "UID was not reverted")
-    end
+                
+        :name => name,
+        :comment => "Puppet Testing User",
+        :gid => Puppet::Util::SUIDManager.gid,
+        :shell => findshell,
+        
+        :home => "/home/#{name}"
+      )
+    }
+
+    assert(user, "Did not create user")
+
+    user
+  end
+
+  def test_autorequire
+    file = tempfile
+    comp = nil
+    user = nil
+    group =nil
+    home = nil
+    ogroup = nil
+    assert_nothing_raised {
 
-    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
-
-        groups = []
-        main = []
-        extra = []
-        5.times do |i|
-            i += 1
-            name = "pptstgr%s" % i
-            groups << name
-            if i < 3
-                main << name
-            else
-                extra << name
-            end
-        end
-
-        assert(user[:membership] == :minimum, "Membership did not default correctly")
-
-        assert_nothing_raised {
-            user.retrieve
-        }
-
-        # Now add some of them to our user
-        assert_nothing_raised {
-            user[:groups] = extra
-        }
-        assert_nothing_raised {
-            user.retrieve
-        }
-
-        assert_instance_of(String, user.property(:groups).should)
-
-        # Some tests to verify that groups work correctly startig from nothing
-        # Remove our user
-        user[:ensure] = :absent
-        assert_apply(user)
-
-        assert_nothing_raised do
-            user.retrieve
-        end
-
-        # And add it again
-        user[:ensure] = :present
-        assert_apply(user)
-
-        # Make sure that the groups are a string, not an array
-        assert(user.provider.groups.is_a?(String),
-            "Incorrectly passed an array to groups")
-
-        currentvalue = user.retrieve
-
-        assert(currentvalue[user.property(:groups)], "Did not retrieve group list")
-
-        list = currentvalue[user.property(:groups)]
-        assert_equal(extra.sort, list.sort, "Group list is not equal")
-
-        # Now set to our main list of groups
-        assert_nothing_raised {
-            user[:groups] = main
-        }
-
-        assert_equal((main + extra).sort, user.property(:groups).should.split(",").sort)
-
-        currentvalue = nil
-        assert_nothing_raised {
-            currentvalue = user.retrieve
-        }
-
-        assert(!user.insync?(currentvalue), "User is incorrectly in sync")
-
-        assert_apply(user)
-
-        assert_nothing_raised {
-            currentvalue = user.retrieve
-        }
-
-        # We're not managing inclusively, so it should keep the old group
-        # memberships and add the new ones
-        list = currentvalue[user.property(:groups)]
-        assert_equal((main + extra).sort, list.sort, "Group list is not equal")
-
-        assert_nothing_raised {
-            user[:membership] = :inclusive
-        }
-        assert_nothing_raised {
-            currentvalue = user.retrieve
-        }
-
-        assert(!user.insync?(currentvalue), "User is incorrectly in sync")
-
-        assert_events([:user_changed], user)
-        assert_nothing_raised {
-            currentvalue = user.retrieve
-        }
-
-        list = currentvalue[user.property(:groups)]
-        assert_equal(main.sort, list.sort, "Group list is not equal")
-
-        # Set the values a bit differently.
-        user.property(:groups).should = list.sort { |a,b| b <=> a }
-
-        assert(user.property(:groups).insync?(list.sort), "Groups property did not sort groups")
-
-        user.delete(:groups)
-    end
-
-    def test_groups_list_must_not_contain_commas
-        assert_raise(Puppet::Error) do
-            Puppet::Type.type(:user).new :name => "luke", :groups => "root,adm"
-        end
-    end
-
-    def test_autorequire
-        file = tempfile()
-        comp = nil
-        user = nil
-        group =nil
-        home = nil
-        ogroup = nil
-        assert_nothing_raised {
             user = Puppet::Type.type(:user).new(
-                :name => "pptestu",
-                :home => file,
-                :gid => "pptestg",
-                :groups => "yayness"
-            )
-            home = Puppet::Type.type(:file).new(
-                :path => file,
-                :owner => "pptestu",
-                :ensure => "directory"
-            )
-            group = Puppet::Type.type(:group).new(
-                :name => "pptestg"
-            )
-            ogroup = Puppet::Type.type(:group).new(
-                :name => "yayness"
-            )
-            comp = mk_catalog(user, group, home, ogroup)
-        }
+                
+        :name => "pptestu",
+        :home => file,
+        :gid => "pptestg",
+        
+        :groups => "yayness"
+      )
 
-        rels = nil
-        assert_nothing_raised() { rels = user.autorequire }
-
-        assert(rels.detect { |r| r.source == group }, "User did not require group")
-        assert(rels.detect { |r| r.source == ogroup }, "User did not require other groups")
-        assert_nothing_raised() { rels = home.autorequire }
-        assert(rels.detect { |r| r.source == user }, "Homedir did not require user")
-    end
-
-    def test_simpleuser
-        name = "pptest"
-
-        user = mkuser(name)
-
-        comp = mk_catalog("usercomp", user)
+            home = Puppet::Type.type(:file).new(
+                
+        :path => file,
+        :owner => "pptestu",
+        
+        :ensure => "directory"
+      )
+      group = Puppet::Type.type(:group).new(
+        :name => "pptestg"
+      )
+      ogroup = Puppet::Type.type(:group).new(
+        :name => "yayness"
+      )
+      comp = mk_catalog(user, group, home, ogroup)
+    }
 
-        trans = assert_events([:user_created], comp, "user")
+    rels = nil
+    assert_nothing_raised { rels = user.autorequire }
 
-        assert_equal(user.should(:comment), user.provider.comment,
-            "Comment was not set correctly")
+    assert(rels.detect { |r| r.source == group }, "User did not require group")
+    assert(rels.detect { |r| r.source == ogroup }, "User did not require other groups")
+    assert_nothing_raised { rels = home.autorequire }
+    assert(rels.detect { |r| r.source == user }, "Homedir did not require user")
+  end
 
-        assert_rollback_events(trans, [:user_removed], "user")
+  # Testing #455
+  def test_autorequire_with_no_group_should
+    user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
+    catalog = mk_catalog(user)
 
-        assert(! user.provider.exists?, "User did not get deleted")
+    assert_nothing_raised do
+      user.autorequire
     end
 
-    def test_allusermodelproperties
-        user = nil
-        name = "pptest"
-
-        user = mkuser(name)
-
-        assert(! user.provider.exists?, "User %s is present" % name)
-
-        comp = mk_catalog("usercomp", user)
+    user[:ensure] = :absent
 
-        trans = assert_events([:user_created], comp, "user")
+    assert(user.property(:groups).insync?(nil),
+      "Groups state considered out of sync with no :should value")
+  end
 
-        user.retrieve
-        assert_equal("Puppet Testing User", user.provider.comment,
-            "Comment was not set")
+  # Make sure the 'managehome' param can only be set when the provider
+  # has that feature.  Uses a patch from #432.
+  def test_managehome
+    user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
 
-        tests = Puppet::Type.type(:user).validproperties
+    prov = user.provider
 
-        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
-        }
+    home = false
+    prov.class.meta_def(:manages_homedir?) { home }
 
-        user[:ensure] = :absent
-        assert_apply(user)
+    assert_nothing_raised("failed on false managehome") do
+      user[:managehome] = false
     end
 
-    # Testing #455
-    def test_autorequire_with_no_group_should
-        user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
-        catalog = mk_catalog(user)
-
-        assert_nothing_raised do
-            user.autorequire
-        end
-
-        user[:ensure] = :absent
-
-        assert_nothing_raised do
-            user.evaluate
-        end
-
-        assert(user.send(:property, :groups).insync?(nil),
-            "Groups state considered out of sync with no :should value")
+    assert_raise(Puppet::Error, "did not fail when managehome? is false") do
+      user[:managehome] = true
     end
 
-    # Make sure the 'managehome' param can only be set when the provider
-    # has that feature.  Uses a patch from #432.
-    def test_managehome
-        user = Puppet::Type.type(:user).new(:name => "yaytest", :check => :all)
-
-        prov = user.provider
-
-        home = false
-        prov.class.meta_def(:manages_homedir?) { home }
-
-        assert_nothing_raised("failed on false managehome") do
-            user[:managehome] = false
-        end
-
-        assert_raise(Puppet::Error, "did not fail when managehome? is false") do
-            user[:managehome] = true
-        end
-
-        home = true
-        assert(prov.class.manages_homedir?, "provider did not enable homedir")
-        assert_nothing_raised("failed when managehome is true") do
-            user[:managehome] = true
-        end
+    home = true
+    assert(prov.class.manages_homedir?, "provider did not enable homedir")
+    assert_nothing_raised("failed when managehome is true") do
+      user[:managehome] = true
     end
+  end
 end