Merging r1468 from the implementations branch with r1438 from when the branch was first created.

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

18 files changed, 1686 insertions, 596 deletions

diff --git a/test/other/autoload.rb b/test/other/autoload.rb
new file mode 100644
index 000000000..95fafbda2
--- /dev/null
+++ b/test/other/autoload.rb
@@ -0,0 +1,111 @@
+#!/usr/bin/env ruby
+
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/autoload'
+require 'puppettest'
+require 'test/unit'
+
+class TestAutoload < Test::Unit::TestCase
+	include TestPuppet
+    @things = []
+    def self.newthing(name)
+        @things << name
+    end
+
+    def self.thing?(name)
+        @things.include? name
+    end
+
+    def self.clear
+        @things.clear
+    end
+
+    def mkfile(name, path)
+        # Now create a file to load
+        File.open(path, "w") do |f|
+            f.puts %{
+TestAutoload.newthing(:#{name.to_s})
+            }
+        end
+    end
+
+    def teardown
+        super
+        self.class.clear
+    end
+
+    def test_load
+        dir = tempfile()
+        $: << dir
+        cleanup do
+            $:.delete(dir)
+        end
+
+        Dir.mkdir(dir)
+
+        rbdir = File.join(dir, "yayness")
+
+        Dir.mkdir(rbdir)
+
+        # An object for specifying autoload
+        klass = self.class
+
+        loader = nil
+        assert_nothing_raised {
+            loader = Puppet::Autoload.new(klass, :yayness)
+        }
+
+        assert_equal(loader.object_id, Puppet::Autoload[klass].object_id,
+                    "Did not retrieve loader object by class")
+
+        # Make sure we don't fail on missing files
+        assert_nothing_raised {
+            assert_equal(false, loader.load(:mything),
+                        "got incorrect return on failed load")
+        }
+
+        # Now create a couple of files for testing
+        path = File.join(rbdir, "mything.rb")
+        mkfile(:mything, path)
+        opath = File.join(rbdir, "othing.rb")
+        mkfile(:othing, opath)
+
+        # Now try to actually load it.
+        assert_nothing_raised {
+            assert_equal(true, loader.load(:mything),
+                        "got incorrect return on failed load")
+        }
+
+        assert(loader.loaded?(:mything), "Not considered loaded")
+
+        assert(klass.thing?(:mything),
+                "Did not get loaded thing")
+
+        # Now clear everything, and test loadall
+        assert_nothing_raised {
+            loader.clear
+        }
+
+        self.class.clear
+
+        assert_nothing_raised {
+            loader.loadall
+        }
+
+        [:mything, :othing].each do |thing|
+            assert(loader.loaded?(thing), "#{thing.to_s} not considered loaded")
+
+            assert(klass.thing?(thing),
+                    "Did not get loaded #{thing.to_s}")
+        end
+    end
+
+    def test_loadall
+    end
+end
diff --git a/test/other/provider.rb b/test/other/provider.rb
new file mode 100644
index 000000000..fc04b9926
--- /dev/null
+++ b/test/other/provider.rb
@@ -0,0 +1,165 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppet'
+require 'puppet/provider'
+require 'puppettest'
+require 'test/unit'
+
+class TestImpl < Test::Unit::TestCase
+    include TestPuppet
+
+    def setup
+        super
+        @type = newtype(@method_name.to_s + "type")
+
+        # But create a new provider for every method.
+        @provider = newprovider(@method_name.to_s + "provider")
+    end
+
+    def newtype(name)
+        # First create a fake type
+        return Puppet::Type.newtype(name) {
+            newparam(:name) { isnamevar }
+        }
+    end
+
+    def newprovider(name, type = nil)
+        type ||= @type
+        provider = nil
+        assert_nothing_raised("Could not create provider") do
+            provider = type.provide(name) {}
+        end
+        return provider
+    end
+
+    # Just a quick run-through to see if the basics work
+    def test_newprovider
+        assert_nothing_raised do
+            @provider.confine :operatingsystem => Facter["operatingsystem"].value
+            @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
+        end
+
+        assert(@provider.suitable?, "Implementation was not considered suitable")
+        assert(@provider.default?, "Implementation was not considered a default")
+
+        assert_equal(@provider, @type.defaultprovider,
+                     "Did not correctly find default provider")
+
+    end
+
+    def test_provider_false_confine
+        assert_nothing_raised do
+            @provider.confine :false => false
+        end
+
+        assert(@provider.suitable?, "False did not check correctly")
+    end
+
+    def test_provider_true_confine
+        assert_nothing_raised do
+            @provider.confine :true => true
+        end
+
+        assert(@provider.suitable?, "True did not check correctly")
+
+        # Now check whether we multiple true things work
+        assert_nothing_raised do
+            @provider.confine :true => false
+            @provider.confine :true => true
+        end
+        assert(! @provider.suitable?, "One truth overrode another")
+    end
+
+    def test_provider_exists_confine
+        file = tempfile()
+
+        assert_nothing_raised do
+            @provider.confine :exists => file
+        end
+
+        assert(! @provider.suitable?, "Exists did not check correctly")
+        File.open(file, "w") { |f| f.puts "" }
+        assert(@provider.suitable?, "Exists did not find file correctly")
+    end
+
+    def test_provider_facts_confine
+        # Now check for multiple platforms
+        assert_nothing_raised do
+            @provider.confine :operatingsystem => [Facter["operatingsystem"].value, :yayos]
+            @provider.confine :operatingsystem => [:fakeos, :otheros]
+        end
+
+        assert(@provider.suitable?, "Implementation not considered suitable")
+    end
+
+    def test_provider_default
+        nondef = nil
+        assert_nothing_raised {
+            nondef = newprovider(:nondefault)
+        }
+
+        assert_nothing_raised do
+            @provider.defaultfor :operatingsystem => Facter["operatingsystem"].value
+        end
+
+        assert_equal(@provider.name, @type.defaultprovider.name, "Did not get right provider")
+
+        @type.suitableprovider
+    end
+
+    def test_subclassconfines
+        parent = newprovider("parentprovider")
+
+        # Now make a bad confine on the parent
+        parent.confine :exists => "/this/file/definitely/does/not/exist"
+
+        child = nil
+        assert_nothing_raised {
+            child = @type.provide("child", :parent => parent.name) {}
+        }
+
+        assert(child.suitable?, "Parent ruled out child")
+    end
+
+    def test_commands
+        parent = newprovider("parentprovider")
+
+        child = nil
+        assert_nothing_raised {
+            child = @type.provide("child", :parent => parent.name) {}
+        }
+
+        assert_nothing_raised {
+            child.commands :which => "which"
+        }
+
+        assert(child.command(:which), "Did not find 'which' command")
+
+        assert(child.command(:which) =~ /^\//,
+                "Command did not become fully qualified")
+        assert(FileTest.exists?(child.command(:which)),
+                                "Did not find actual 'which' binary")
+
+        assert_raise(Puppet::DevError) do
+            child.command(:nosuchcommand)
+        end
+
+        # Now create a parent command
+        assert_nothing_raised {
+            parent.commands :sh => Puppet::Util.binary('sh')
+        }
+
+        assert(parent.command(:sh), "Did not find 'sh' command")
+
+        assert(child.command(:sh), "Did not find parent's 'sh' command")
+
+        assert(FileTest.exists?(child.command(:sh)),
+                                "Somehow broke path to sh")
+    end
+end
+
+# $Id$
diff --git a/test/providers/group.rb b/test/providers/group.rb
new file mode 100755
index 000000000..364d1750d
--- /dev/null
+++ b/test/providers/group.rb
@@ -0,0 +1,246 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'etc'
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestGroupProvider < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @@tmpgroups = []
+        @provider = nil
+        assert_nothing_raised {
+            @provider = Puppet::Type.type(:group).defaultprovider
+        }
+
+        assert(@provider, "Could not find default group provider")
+        assert(@provider.name != :fake, "Got a fake provider")
+    end
+
+    def teardown
+        super
+        Puppet.type(:group).clear
+        @@tmpgroups.each { |group|
+            unless missing?(group)
+                remove(group)
+            end
+        }
+    end
+
+    def mkgroup(name, hash = {})
+        fakemodel = fakemodel(:group, name)
+        group = nil
+        assert_nothing_raised {
+            group = @provider.new(fakemodel)
+        }
+        hash.each do |name, val|
+            fakemodel[name] = val
+        end
+        assert(group, "Could not create provider group")
+
+        return group
+    end
+
+    case Facter["operatingsystem"].value
+    when "Darwin":
+        def missing?(group)
+            output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
+
+            if output == ""
+                return true
+            else
+                return false
+            end
+
+            assert_equal("", output, "Group %s is present:\n%s" % [group, output])
+        end
+
+        def gid(name)
+            %x{nireport / /groups name gid}.split("\n").each { |line|
+                group, id = line.chomp.split(/\s+/)
+                assert(id =~ /^-?\d+$/, "Group id %s for %s is not a number" %
+                    [id, group])
+                if group == name
+                    return Integer(id)
+                end
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("niutil -destroy / /groups/%s" % group)
+        end
+    else
+        def missing?(group)
+            begin
+                obj = Etc.getgrnam(group)
+                return false
+            rescue ArgumentError
+                return true
+            end
+        end
+
+        def gid(name)
+            assert_nothing_raised {
+                obj = Etc.getgrnam(name)
+                return obj.gid
+            }
+
+            return nil
+        end
+
+        def remove(group)
+            system("groupdel %s" % group)
+        end
+    end
+
+    def groupnames
+        %x{groups}.chomp.split(/ /)
+    end
+
+    def groupids
+        Process.groups
+    end
+
+    def attrtest_ensure(group)
+        old = group.ensure
+        assert_nothing_raised {
+            group.ensure = :absent
+        }
+
+        assert(!group.exists?, "Group was not deleted")
+
+        assert_nothing_raised {
+            group.ensure = :present
+        }
+        assert(group.exists?, "Group was not created")
+
+        unless old == :present
+            assert_nothing_raised {
+                group.ensure = old
+            }
+        end
+    end
+
+    def attrtest_gid(group)
+        old = gid(group.name)
+
+        newgid = old
+        while true
+            newgid += 1
+
+            if newgid - old > 1000
+                $stderr.puts "Could not find extra test UID"
+                return
+            end
+            begin
+                Etc.getgrgid(newgid)
+            rescue ArgumentError => detail
+                break
+            end
+        end
+
+        assert_nothing_raised("Failed to change group id") {
+            group.gid = newgid
+        }
+
+        curgid = nil
+        assert_nothing_raised {
+            curgid = gid(group.name)
+        }
+
+        assert_equal(newgid, curgid, "GID was not changed")
+        # Refresh
+        group.getinfo(true)
+        assert_equal(newgid, group.gid, "Object got wrong gid")
+
+        assert_nothing_raised("Failed to change group id") {
+            group.gid = old
+        }
+    end
+
+    # Iterate over each of our groups and try to grab the gid.
+    def test_ownprovidergroups
+        groupnames().each { |group|
+            gobj = nil
+            comp = nil
+            fakemodel = fakemodel(:group, group)
+            assert_nothing_raised {
+                gobj = @provider.new(fakemodel)
+            }
+
+            assert(gobj.gid, "Failed to retrieve gid")
+        }
+    end
+
+    if Process.uid == 0
+        def test_mkgroup
+            gobj = nil
+            comp = nil
+            name = "pptestgr"
+            assert(missing?(name), "Group %s is still present" % name)
+            group = mkgroup(name)
+
+            @@tmpgroups << name
+
+            assert(group.respond_to?(:addcmd), "no respondo?")
+            assert_nothing_raised {
+                group.create
+            }
+            assert(!missing?(name), "Group %s is missing" % name)
+
+            tests = Puppet.type(:group).validstates
+
+            tests.each { |test|
+                if self.respond_to?("attrtest_%s" % test)
+                    self.send("attrtest_%s" % test, group)
+                else
+                    $stderr.puts "Not testing attr %s of group" % test
+                end
+            }
+
+            assert_nothing_raised {
+                group.delete
+            }
+        end
+
+        # groupadd -o is broken in FreeBSD.
+        unless Facter["operatingsystem"].value == "FreeBSD"
+        def test_duplicateIDs
+            group1 = mkgroup("group1", :gid => 125)
+            group2 = mkgroup("group2", :gid => 125)
+
+            @@tmpgroups << "group1"
+            @@tmpgroups << "group2"
+            # Create the first group
+            assert_nothing_raised {
+                group1.create
+            }
+
+            # Not all OSes fail here, so we can't test that it doesn't work with
+            # it off, only that it does work with it on.
+            assert_nothing_raised {
+                group2.model[:allowdupe] = :true
+            }
+
+            # Now create the second group
+            assert_nothing_raised {
+                group2.create
+            }
+            assert_equal(:present, group2.ensure,
+                         "Group did not get created")
+        end
+        end
+    else
+        $stderr.puts "Not running as root; skipping group creation tests."
+    end
+end
+
+# $Id$
diff --git a/test/providers/nameservice.rb b/test/providers/nameservice.rb
new file mode 100644
index 000000000..0e0f8050f
--- /dev/null
+++ b/test/providers/nameservice.rb
@@ -0,0 +1,36 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'test/unit'
+require 'facter'
+
+class TestNameServiceProvider < Test::Unit::TestCase
+	include FileTesting
+
+    def test_option
+        klass = Class.new(Puppet::Type::Provider::NameService)
+        klass.model = Puppet::Type.type(:user)
+
+        val = nil
+        assert_nothing_raised {
+            val = klass.option(:home, :flag)
+        }
+
+        assert_nil(val, "Got an option")
+
+        assert_nothing_raised {
+            klass.options :home, :flag => "-d"
+        }
+        assert_nothing_raised {
+            val = klass.option(:home, :flag)
+        }
+        assert_equal("-d", val, "Got incorrect option")
+    end
+end
+
+# $Id$
diff --git a/test/providers/package.rb b/test/providers/package.rb
new file mode 100644
index 000000000..210fae5c1
--- /dev/null
+++ b/test/providers/package.rb
@@ -0,0 +1,86 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'etc'
+require 'puppet/type'
+require 'puppettest'
+require 'test/unit'
+
+class TestPackageProvider < Test::Unit::TestCase
+	include TestPuppet
+    def setup
+        super
+        @provider = nil
+        assert_nothing_raised {
+            @provider = Puppet::Type.type(:package).defaultprovider
+        }
+
+        assert(@provider, "Could not find default package provider")
+        assert(@provider.name != :fake, "Got a fake provider")
+    end
+
+    def test_nothing
+    end
+
+    if Facter["operatingsystem"].value == "Solaris" and Process.uid == 0
+    if Puppet.type(:package).provider(:blastwave).suitable?
+    # FIXME The packaging crap needs to be rewritten to support testing
+    # multiple package types on the same platform.
+    def test_list_blastwave
+        pkgs = nil
+        assert_nothing_raised {
+            pkgs = Puppet::Type.type(:package).provider(:blastwave).list
+        }
+
+        pkgs.each do |pkg|
+            if pkg[:name] =~ /^CSW/
+                assert_equal(:blastwave, pkg[:provider],
+                    "Type was not set correctly")
+            end
+        end
+    end
+
+    def test_install_blastwave
+        pkg = nil
+        name = "cabextract"
+        model = fakemodel(:package, name)
+        assert_nothing_raised {
+            pkg = Puppet::Type.type(:package).provider(:blastwave).new(model)
+        }
+
+        if hash = pkg.query and hash[:ensure] != :absent
+            p hash
+            $stderr.puts "Cannot test pkg installation; %s is already installed" %
+                name
+            return
+        end
+
+        assert_nothing_raised {
+            pkg.install
+        }
+
+        hash = nil
+        assert(hash = pkg.query,
+            "package did not install")
+        assert(hash[:ensure] != :absent,
+            "package did not install")
+
+        latest = nil
+        assert_nothing_raised {
+            latest = pkg.latest
+        }
+        assert(latest, "Could not find latest package version")
+        assert_nothing_raised {
+            pkg.uninstall
+        }
+    end
+    else
+        $stderr.puts "No pkg-get scripting; skipping blastwave tests"
+    end
+    end
+end
+
+# $Id$
diff --git a/test/providers/user.rb b/test/providers/user.rb
new file mode 100644
index 000000000..15b453780
--- /dev/null
+++ b/test/providers/user.rb
@@ -0,0 +1,528 @@
+if __FILE__ == $0
+    $:.unshift '..'
+    $:.unshift '../../lib'
+    $puppetbase = "../.."
+end
+
+require 'puppettest'
+require 'puppet'
+require 'test/unit'
+require 'facter'
+
+class TestUserProvider < Test::Unit::TestCase
+	include 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|
+            unless missing?(user)
+                remove(user)
+            end
+        }
+        super
+        #Puppet.type(:user).clear
+    end
+
+    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
+
+            assert_equal("", output, "User %s is present:\n%s" % [user, output])
+        end
+
+        def current?(param, user)
+            state = Puppet.type(:user).states.find { |st|
+                st.name == param
+            }
+
+            output = %x{nireport / /users name #{state.netinfokey}}
+            output.split("\n").each { |line|
+                if line =~ /^(\w+)\s+(.+)$/
+                    username = $1
+                    id = $2.sub(/\s+$/, '')
+                    if username == user.name
+                        if id =~ /^[-0-9]+$/
+                            return Integer(id)
+                        else
+                            return id
+                        end
+                    end
+                else
+                    raise "Could not match %s" % line
+                end
+            }
+
+            return nil
+        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
+
+        def current?(param, user)
+            state = Puppet.type(:user).states.find { |st|
+                st.name == param
+            }
+
+            assert_nothing_raised {
+                obj = Etc.getpwnam(user.name)
+                return obj.send(user.posixmethod(param))
+            }
+
+            return nil
+        end
+
+        def remove(user)
+            system("userdel %s" % user)
+        end
+    end
+
+
+    def eachstate
+        Puppet::Type.type(:user).validstates.each do |state|
+            next if state == :ensure
+            yield state
+        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 :comment: "Puppet Testing User %s" % name
+        when :gid: Process.gid()
+        when :shell: findshell()
+        when :home: "/home/%s" % name
+        else
+            return nil
+        end
+    end
+
+    def mkuser(name)
+        fakemodel = fakemodel(:user, name)
+        user = nil
+        assert_nothing_raised {
+            user = @provider.new(fakemodel)
+        }
+        assert(user, "Could not create provider user")
+
+        return 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.list
+        }
+        assert(names.length > 0, "Listed no users as objects")
+
+        names.each do |obj|
+            assert_instance_of(Puppet::Type.type(:user), obj)
+            assert(obj[:provider], "Provider was not set")
+        end
+    end
+
+    def test_infocollection
+        fakemodel = fakemodel(:user, @me)
+
+        user = nil
+        assert_nothing_raised {
+            user = @provider.new(fakemodel)
+        }
+        assert(user, "Could not create user provider")
+
+        Puppet::Type.type(:user).validstates.each do |state|
+            next if state == :ensure
+            val = nil
+            assert_nothing_raised {
+                val = user.send(state)
+            }
+
+            assert(val != :absent,
+                   "State %s is missing" % state)
+
+            assert(val, "Did not get value for %s" % state)
+        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.ensure = :absent
+        }
+
+        assert(missing?(user.name), "User is still present")
+        assert_nothing_raised {
+            user.ensure = :present
+        }
+        assert(!missing?(user.name), "User is absent")
+        assert_nothing_raised {
+            user.ensure = :absent
+        }
+
+        unless old == :absent
+            user.ensure = old
+        end
+    end
+
+    def attrtest_comment(user)
+        old = user.comment
+
+        assert_nothing_raised {
+            user.comment = "A different comment"
+        }
+
+        assert_equal("A different comment", 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
+
+        assert_raise(ArgumentError, "gid allowed a non-integer value") do
+            user.gid = group.name
+        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
+            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
+            tmpgroup = Puppet.type(:group).create(
+                :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.model[:groups] = extra.join(",")
+        }
+
+        # Some tests to verify that groups work correctly startig from nothing
+        # Remove our user
+        user.ensure = :absent
+
+        # And add it again
+        user.ensure = :present
+
+        # 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 Process.uid == 0
+        def test_simpleuser
+            name = "pptest"
+
+            assert(missing?(name), "User %s is present" % name)
+
+            user = mkuser(name)
+
+            eachstate do |state|
+                if val = fakedata(user.name, state)
+                    user.model[state] = val
+                end
+            end
+
+            @@tmpusers << name
+
+            assert_nothing_raised {
+                user.create
+            }
+
+            assert_equal("Puppet 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_alluserstates
+            user = nil
+            name = "pptest"
+
+            assert(missing?(name), "User %s is present" % name)
+
+            user = mkuser(name)
+
+            eachstate do |state|
+                if val = fakedata(user.name, state)
+                    user.model[state] = val
+                end
+            end
+
+            @@tmpusers << name
+
+            assert_nothing_raised {
+                user.create
+            }
+            assert_equal("Puppet Testing User pptest", user.comment,
+                "Comment was not set")
+
+            tests = Puppet::Type.type(:user).validstates
+
+            just = nil
+            tests.each { |test|
+                next unless test == :groups
+                if self.respond_to?("attrtest_%s" % test)
+                    self.send("attrtest_%s" % test, user)
+                else
+                    Puppet.err "Not testing attr %s of user" % test
+                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.model[:uid] = 125
+
+            cleanup do
+                user1.ensure = :absent
+                user2.ensure = :absent
+            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.model[: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 {
+            fakemodel = fakemodel(:user, @me)
+            user = useradd.new(fakemodel)
+        }
+
+        assert_equal("-d", user.send(:flag, :home),
+                    "Incorrect home flag")
+
+        assert_equal("-s", user.send(:flag, :shell),
+                    "Incorrect shell flag")
+    end
+end
+
+# $Id$
diff --git a/test/puppet/utiltest.rb b/test/puppet/utiltest.rb
index ebf61e0f0..c2dcdada5 100755
--- a/test/puppet/utiltest.rb
+++ b/test/puppet/utiltest.rb
@@ -294,6 +294,48 @@ class TestPuppetUtil < Test::Unit::TestCase
         assert(Process.euid == 0, "UID did not get reset")
     end
     end
+
+    def test_proxy
+        klass = Class.new do
+            attr_accessor :hash
+            class << self
+                attr_accessor :ohash
+            end
+        end
+        klass.send(:include, Puppet::Util)
+
+        klass.ohash = {}
+
+        inst = klass.new
+        inst.hash = {}
+        assert_nothing_raised do
+            Puppet::Util.proxy klass, :hash, "[]", "[]=", :clear, :delete
+        end
+
+        assert_nothing_raised do
+            Puppet::Util.classproxy klass, :ohash, "[]", "[]=", :clear, :delete
+        end
+
+        assert_nothing_raised do
+            inst[:yay] = "boo"
+            inst["cool"] = :yayness
+        end
+
+        [:yay, "cool"].each do |var|
+            assert_equal(inst.hash[var], inst[var],
+                        "Var %s did not take" % var)
+        end
+
+        assert_nothing_raised do
+            klass[:Yay] = "boo"
+            klass["Cool"] = :yayness
+        end
+
+        [:Yay, "Cool"].each do |var|
+            assert_equal(inst.hash[var], inst[var],
+                        "Var %s did not take" % var)
+        end
+    end
 end
 
 # $Id$
diff --git a/test/puppettest.rb b/test/puppettest.rb
index cc7ff2ccc..a49ceb175 100644
--- a/test/puppettest.rb
+++ b/test/puppettest.rb
@@ -9,6 +9,100 @@ require 'test/unit'
 module TestPuppet
     include ObjectSpace
 
+    # A baseclass for the faketypes.
+    class FakeModel < Hash
+        class << self
+            attr_accessor :name
+            @name = :fakemodel
+        end
+
+        def self.validstates
+            Puppet::Type.type(@name).validstates
+        end
+
+        def self.validstate?(name)
+            Puppet::Type.type(@name).validstate?(name)
+        end
+
+        def initialize(name)
+            self[:name] = name
+        end
+
+        def inspect
+            "%s(%s)" % [self.class.to_s.sub(/.+::/, ''), super()]
+        end
+
+        def name
+            self[:name]
+        end
+    end
+
+    class FakeProvider
+        attr_accessor :model
+        class << self
+            attr_accessor :name, :model, :methods
+        end
+
+        # A very low number, so these never show up as defaults via the standard
+        # algorithms.
+        def self.defaultnum
+            -50
+        end
+
+        # Set up methods to fake things
+        def self.apimethods(*ary)
+            @model.validstates.each do |state|
+                ary << state unless ary.include? state
+            end
+            attr_accessor *ary
+
+            @methods = ary
+        end
+
+        def self.initvars
+            @calls = Hash.new do |hash, key|
+                hash[key] = 0
+            end
+        end
+
+        def self.suitable?
+            true
+        end
+
+        def initialize(model)
+            @model = model
+        end
+    end
+
+    @@fakemodels = {}
+    @@fakeproviders = {}
+
+    def fakemodel(type, name, options = {})
+        type = type.intern if type.is_a? String
+        unless @@fakemodels.include? type
+            @@fakemodels[type] = Class.new(FakeModel)
+            @@fakemodels[type].name = type
+        end
+
+        obj = @@fakemodels[type].new(name)
+        obj[:name] = name
+        options.each do |name, val|
+            obj[name] = val
+        end
+        obj
+    end
+
+    def fakeprovider(type, model)
+        type = type.intern if type.is_a? String
+        unless @@fakeproviders.include? type
+            @@fakeproviders[type] = Class.new(FakeModel) do
+                @name = type
+            end
+        end
+
+        @@fakeproviders[type].new(model)
+    end
+
     def gcdebug(type)
         Puppet.warning "%s: %s" % [type, ObjectSpace.each_object(type) { |o| }]
     end
@@ -119,6 +213,19 @@ module TestPuppet
         @@cleaners << block
     end
 
+    def setme
+        # retrieve the user name
+        id = %x{id}.chomp
+        if id =~ /uid=\d+\(([^\)]+)\)/
+            @me = $1
+        else
+            puts id
+        end
+        unless defined? @me
+            raise "Could not retrieve user name; 'id' did not work"
+        end
+    end
+
     def teardown
         stopservices
 
diff --git a/test/server/pelement.rb b/test/server/pelement.rb
index 7bff1cb26..5d5b5ceb4 100644
--- a/test/server/pelement.rb
+++ b/test/server/pelement.rb
@@ -27,11 +27,8 @@ class TestPElementServer < Test::Unit::TestCase
                 obj.retrieve
             end
 
-            assert(obj.insync?, "Described %s[%s] is not in sync" %
-                [trans.type, name])
-
             if trans.type == :package
-                assert_equal(Puppet::Type.type(:package).default, obj[:type])
+                assert_equal(Puppet::Type.type(:package).defaultprovider.name, obj[:provider])
             end
         end
         type.clear
diff --git a/test/types/basic.rb b/test/types/basic.rb
index 1c41d37bc..f734cb5a0 100644
--- a/test/types/basic.rb
+++ b/test/types/basic.rb
@@ -38,7 +38,7 @@ class TestBasic < Test::Unit::TestCase
         assert_nothing_raised() {
             @sleeper = Puppet.type(:service).create(
                 :name => "sleeper",
-                :type => "init",
+                :provider => "init",
                 :path => File.join($puppetbase,"examples/root/etc/init.d"),
                 :hasstatus => true,
                 :ensure => :running
diff --git a/test/types/cron.rb b/test/types/cron.rb
index fee09b360..caada9f91 100755
--- a/test/types/cron.rb
+++ b/test/types/cron.rb
@@ -15,16 +15,8 @@ class TestCron < Test::Unit::TestCase
 	include TestPuppet
     def setup
         super
-        # retrieve the user name
-        id = %x{id}.chomp
-        if id =~ /uid=\d+\(([^\)]+)\)/
-            @me = $1
-        else
-            puts id
-        end
-        unless defined? @me
-            raise "Could not retrieve user name; 'id' did not work"
-        end
+
+        setme()
 
         # god i'm lazy
         @crontype = Puppet.type(:cron)
diff --git a/test/types/group.rb b/test/types/group.rb
index cb9b988ed..508b8436c 100755
--- a/test/types/group.rb
+++ b/test/types/group.rb
@@ -1,11 +1,9 @@
 if __FILE__ == $0
     $:.unshift '..'
     $:.unshift '../../lib'
-    $puppetbase = "../../../../language/trunk"
+    $puppetbase = "../.."
 end
 
-# $Id$
-
 require 'etc'
 require 'puppet/type'
 require 'puppettest'
@@ -13,18 +11,40 @@ require 'test/unit'
 
 class TestGroup < Test::Unit::TestCase
 	include TestPuppet
+
+    p = Puppet::Type.type(:group).provide :fake, :parent => TestPuppet::FakeProvider do
+        @name = :fake
+        apimethods :ensure, :gid
+
+        def create
+            @ensure = :present
+        end
+
+        def delete
+            @ensure = :absent
+        end
+
+        def exists?
+            if defined? @ensure and @ensure == :present
+                true
+            else
+                false
+            end
+        end
+    end
+
+    FakeGroupProvider = p
+
+    @@fakeproviders[:group] = p
+
     def setup
         super
-        @@tmpgroups = []
+        Puppet::Type.type(:group).defaultprovider = FakeGroupProvider
     end
 
     def teardown
         Puppet.type(:group).clear
-        @@tmpgroups.each { |group|
-            unless missing?(group)
-                remove(group)
-            end
-        }
+        Puppet::Type.type(:group).defaultprovider = nil
         super
     end
 
@@ -38,60 +58,6 @@ class TestGroup < Test::Unit::TestCase
         return group
     end
 
-    case Facter["operatingsystem"].value
-    when "Darwin":
-        def missing?(group)
-            output = %x{nidump -r /groups/#{group} / 2>/dev/null}.chomp
-
-            if output == ""
-                return true
-            else
-                return false
-            end
-
-            assert_equal("", output, "Group %s is present:\n%s" % [group, output])
-        end
-
-        def gid(name)
-            %x{nireport / /groups name gid}.split("\n").each { |line|
-                group, id = line.chomp.split(/\s+/)
-                assert(id =~ /^-?\d+$/, "Group id %s for %s is not a number" %
-                    [id, group])
-                if group == name
-                    return Integer(id)
-                end
-            }
-
-            return nil
-        end
-
-        def remove(group)
-            system("niutil -destroy / /groups/%s" % group)
-        end
-    else
-        def missing?(group)
-            begin
-                obj = Etc.getgrnam(group)
-                return false
-            rescue ArgumentError
-                return true
-            end
-        end
-
-        def gid(name)
-            assert_nothing_raised {
-                obj = Etc.getgrnam(name)
-                return obj.gid
-            }
-
-            return nil
-        end
-
-        def remove(group)
-            system("groupdel %s" % group)
-        end
-    end
-
     def groupnames
         %x{groups}.chomp.split(/ /)
     end
@@ -101,99 +67,52 @@ class TestGroup < Test::Unit::TestCase
     end
 
     def attrtest_ensure(group)
-        old = group.is(:ensure)
         group[:ensure] = :absent
 
         comp = newcomp("ensuretest", group)
-        assert_apply(group)
-        assert(missing?(group.name), "User is still present")
+        assert_apply(comp)
+        assert_equal(:absent, group.provider.ensure,  "Group is still present")
         group[:ensure] = :present
         assert_events([:group_created], comp)
-        assert(!missing?(group.name), "User is absent")
+        assert_equal(:present, group.provider.ensure,  "Group is absent")
         group[:ensure] = :absent
         trans = assert_events([:group_removed], comp)
+        assert_equal(:absent, group.provider.ensure,  "Group is present")
 
         assert_rollback_events(trans, [:group_created], "group")
-
-        group[:ensure] = old
-        assert_apply(group)
+        assert_equal(:present, group.provider.ensure,  "Group is absent")
     end
 
+    # This is a bit odd, since we're not actually doing anything on the machine.
+    # Just make sure we can set the gid and that it will work correctly.
     def attrtest_gid(group)
-        obj = nil
-        #assert_nothing_raised {
-        #    obj = Etc.getgrnam(group[:name])
-        #}
-        group.retrieve
-        old = gid(group[:name])
-        comp = newcomp("gidtest", group)
-
-        group[:gid] = old
-
-        trans = assert_events([], comp, "group")
-
-        newgid = old
-        while true
-            newgid += 1
-
-            if newgid - old > 1000
-                $stderr.puts "Could not find extra test UID"
-                return
-            end
-            begin
-                Etc.getgrgid(newgid)
-            rescue ArgumentError => detail
-                break
-            end
-        end
-
-        assert_nothing_raised("Failed to change group id") {
-            group[:gid] = newgid
-        }
-
-        trans = assert_events([:group_modified], comp, "group")
 
-        curgid = nil
+        # Check the validation.
         assert_nothing_raised {
-            curgid = gid(group[:name])
+            group[:gid] = "15"
         }
 
-        assert_equal(newgid, curgid, "GID was not changed")
+        assert_equal(15, group.should(:gid),
+                     "Did not convert gid to number")
 
-        assert_rollback_events(trans, [:group_modified], "group")
+        comp = newcomp(group)
+        trans = assert_events([:group_modified], comp, "group")
+        assert_equal(15, group.provider.gid, "GID was not changed")
 
         assert_nothing_raised {
-            curgid = gid(group[:name])
+            group[:gid] = 16
         }
 
-        assert_equal(old, curgid, "UID was not reverted")
-    end
-
-    # Disabled, because it was testing implementation, not function
-    def disabled_test_eachmethod
-        obj = Etc.getgrnam(groupnames()[0])
-
-        assert(obj, "Could not retrieve test group object")
+        assert_equal(16, group.should(:gid),
+                     "Did not keep gid as number")
 
-        Puppet.type(:group).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]
-                )
-            }
+        # Now switch to 16
+        trans = assert_events([:group_modified], comp, "group")
+        assert_equal(16, group.provider.gid, "GID was not changed")
 
-            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]
-                )
-            }
-        }
+        # And then rollback
+        assert_rollback_events(trans, [:group_modified], "group")
+        assert_equal(15, group.provider.gid, "GID was not changed")
     end
 
     def test_owngroups
@@ -205,119 +124,52 @@ class TestGroup < Test::Unit::TestCase
                     :name => group,
                     :check => [:gid]
                 )
-
-                comp = newcomp("grouptest %s" % group, gobj)
             }
 
-            #trans = nil
+            # Set a fake gid
+            gobj.provider.gid = rand(100)
+
             assert_nothing_raised {
                 gobj.retrieve
-                #trans = comp.evaluate
             }
 
             assert(gobj.is(:gid), "Failed to retrieve gid")
         }
     end
 
-    # Test that we can query things
-    # It'd be nice if we could automate this...
-    def test_checking
-        require 'etc'
+    def test_mkgroup
+        gobj = nil
+        comp = nil
+        name = "pptestgr"
 
-        name = nil
-        assert_nothing_raised {
-            name = Etc.getgrgid(Process.gid).name
-        }
-        user = nil
         assert_nothing_raised {
-            checks = Puppet.type(:group).validstates
-            user = Puppet.type(:group).create(
+            gobj = Puppet.type(:group).create(
                 :name => name,
-                :check => checks
+                :ensure => :present
             )
-        }
 
-        assert_nothing_raised {
-            user.retrieve
+            comp = newcomp("groupmaker %s" % name, gobj)
         }
 
-        assert_equal(Process.gid, user.is(:gid), "Retrieved UID does not match")
-    end
+        trans = assert_events([:group_created], comp, "group")
 
-    if Process.uid == 0
-        def test_mkgroup
-            gobj = nil
-            comp = nil
-            name = "pptestgr"
-
-            #os = Facter["operatingsystem"].value
-
-            #if os == "Darwin"
-            #    obj = nil
-            #    assert_nothing_raised {
-            #        obj = Etc.getgrnam(name)
-            #    }
-            #    assert_equal(-2, obj.gid, "Darwin GID is not -2")
-            #else
-                #assert_raise(ArgumentError) {
-                #    obj = Etc.getgrnam(name)
-                #}
-            #end
-            assert(missing?(name), "Group %s is still present" % name)
-            assert_nothing_raised {
-                gobj = Puppet.type(:group).create(
-                    :name => name,
-                    :ensure => :present
-                )
-
-                comp = newcomp("groupmaker %s" % name, gobj)
-            }
-
-            @@tmpgroups << name
-            trans = assert_events([:group_created], comp, "group")
-
-            obj = nil
-            assert_nothing_raised {
-                obj = Etc.getgrnam(name)
-            }
-            assert(!missing?(name), "Group %s is missing" % name)
+        assert(gobj.provider.exists?,
+                "Did not create group")
 
-            tests = Puppet.type(:group).validstates
+        tests = Puppet.type(:group).validstates
 
-            gobj.retrieve
-            tests.each { |test|
-                if self.respond_to?("attrtest_%s" % test)
-                    self.send("attrtest_%s" % test, gobj)
-                else
-                    #$stderr.puts "Not testing attr %s of group" % test
-                end
-            }
-
-            assert_rollback_events(trans, [:group_removed], "group")
-
-            assert(missing?(name), "Group %s is still present" % name)
-        end
-
-        # groupadd -o is broken in FreeBSD.
-        unless Facter["operatingsystem"].value == "FreeBSD"
-        def test_duplicateIDs
-            group1 = mkgroup("group1", :gid => 125)
-            group2 = mkgroup("group2", :gid => 125)
+        gobj.retrieve
+        tests.each { |test|
+            if self.respond_to?("attrtest_%s" % test)
+                self.send("attrtest_%s" % test, gobj)
+            else
+                #$stderr.puts "Not testing attr %s of group" % test
+            end
+        }
 
-            assert_apply(group1)
+        assert_rollback_events(trans, [:group_removed], "group")
 
-            # Not all OSes fail here, so we can't test that it doesn't work with
-            # it off, only that it does work with it on.
-            assert_nothing_raised {
-                group2[:allowdupe] = true
-            }
-            assert_apply(group2)
-            group2.retrieve
-            assert_equal(:present, group2.state(:ensure).is,
-                         "Group did not get created")
-        end
-        end
-    else
-        $stderr.puts "Not running as root; skipping group creation tests."
+        assert(! gobj.provider.exists?,
+                "Did not delete group")
     end
 end
diff --git a/test/types/package.rb b/test/types/package.rb
index d4ddc14c9..779c693fe 100644
--- a/test/types/package.rb
+++ b/test/types/package.rb
@@ -11,7 +11,7 @@ require 'facter'
 
 $platform = Facter["operatingsystem"].value
 
-unless Puppet.type(:package).default
+unless Puppet.type(:package).defaultprovider
     puts "No default package type for %s; skipping package tests" % $platform
 else
 
@@ -54,14 +54,15 @@ class TestPackages < Test::Unit::TestCase
         list.each { |pkg, source|
             hash = {:name => pkg}
             if useensure
-                hash[:ensure] = "latest"
+                hash[:ensure] = "installed"
             end
             if source
                 source = source[0] if source.is_a? Array
                 hash[:source] = source
             end
+            # Override the default package type for our test packages.
             if Facter["operatingsystem"].value == "Darwin"
-                hash[:type] = "darwinport"
+                hash[:provider] = "darwinport"
             end
             obj = Puppet.type(:package).create(hash)
             assert(pkg, "Could not create package")
@@ -103,6 +104,8 @@ class TestPackages < Test::Unit::TestCase
             retval = {"aop" => nil}
         when "FreeBSD":
             retval = {"yahtzee" => nil}
+        when "RedHat":
+            retval = {"puppet" => "/home/luke/rpm/RPMS/i386/puppet-0.16.1-1.i386.rpm"}
         else
             Puppet.notice "No test packages for %s" % $platform
         end
@@ -168,18 +171,6 @@ class TestPackages < Test::Unit::TestCase
         }
     end
 
-    def test_specifypkgtype
-        pkg = nil
-        assert_nothing_raised {
-            pkg = Puppet.type(:package).create(
-                :name => "mypkg",
-                :type => "yum"
-            )
-        }
-        assert(pkg, "Did not create package")
-        assert_equal(:yum, pkg[:type])
-    end
-
     def test_latestpkg
         mkpkgs { |pkg|
             next unless pkg.respond_to? :latest
@@ -194,11 +185,8 @@ class TestPackages < Test::Unit::TestCase
     def test_listing
         pkgtype = Puppet::Type.type(:package)
 
-        # Heh
-        defaulttype = pkgtype.pkgtype(pkgtype.default)
-
         assert_nothing_raised("Could not list packages") do
-            defaulttype.list
+            pkgtype.list
         end
     end
 
@@ -213,14 +201,14 @@ class TestPackages < Test::Unit::TestCase
                 pkg.retrieve
             }
 
-            if pkg.insync? or pkg.is(:ensure) != :absent
+            if pkg.provider.query
                 Puppet.notice "Test package %s is already installed; please choose a different package for testing" % pkg
                 next
             end
 
             comp = newcomp("package", pkg)
 
-            assert_events([:package_created], comp, "package")
+            assert_events([:package_installed], comp, "package")
 
             pkg.retrieve
 
@@ -243,7 +231,7 @@ class TestPackages < Test::Unit::TestCase
                     pkg[:ensure] = "latest"
                 }
 
-                assert_events([:package_created], comp, "package")
+                assert_events([:package_installed], comp, "package")
 
                 pkg.retrieve
                 assert(pkg.insync?, "After install, package is not insync")
@@ -306,9 +294,9 @@ class TestPackages < Test::Unit::TestCase
 
             modpkg(pkg)
 
-            assert(pkg.latest, "Could not retrieve latest value")
+            assert(pkg.provider.latest, "Could not retrieve latest value")
 
-            assert_events([:package_created], pkg)
+            assert_events([:package_installed], pkg)
 
             assert_nothing_raised {
                 pkg.retrieve
@@ -345,7 +333,8 @@ class TestPackages < Test::Unit::TestCase
                 pkg = Puppet::Type.type(:package).create(
                     :name => "pkgtesting",
                     :source => "/Users/luke/Documents/Puppet/pkgtesting.pkg",
-                    :ensure => :present
+                    :ensure => :present,
+                    :provider => :apple
                 )
             }
 
@@ -362,7 +351,7 @@ class TestPackages < Test::Unit::TestCase
             @@tmpfiles << "/tmp/file"
             @@tmpfiles << "/Library/Receipts/pkgtesting.pkg"
 
-            assert_events([:package_created], pkg, "package")
+            assert_events([:package_installed], pkg, "package")
 
             assert_nothing_raised {
                 pkg.retrieve
@@ -375,15 +364,15 @@ class TestPackages < Test::Unit::TestCase
     end
 
     # Yay, gems.  They're special because any OS can test them.
-    if %x{which gem 2>/dev/null}.chomp != ""
+    if Puppet::Type.type(:package).provider(:gem).suitable?
     def test_list_gems
         gems = nil
         assert_nothing_raised {
-            gems = Puppet::Type.type(:package).pkgtype(:gem).list
+            gems = Puppet::Type.type(:package).provider(:gem).list
         }
 
         gems.each do |gem|
-            assert_equal(:gem, gem[:type],
+            assert_equal(:gem, gem[:provider],
                 "Type was not set correctly")
         end
     end
@@ -396,7 +385,7 @@ class TestPackages < Test::Unit::TestCase
                 :name => name,
                 :version => "0.0.2",
                 :ensure => "installed",
-                :type => :gem
+                :provider => :gem
             )
         }
 
@@ -410,7 +399,7 @@ class TestPackages < Test::Unit::TestCase
             return
         end
 
-        assert_events([:package_created], gem)
+        assert_events([:package_installed], gem)
 
         assert_nothing_raised {
             gem.retrieve
@@ -421,7 +410,7 @@ class TestPackages < Test::Unit::TestCase
 
         latest = nil
         assert_nothing_raised {
-            latest = gem.latest
+            latest = gem.provider.latest
         }
 
         assert(latest != gem[:version], "Did not correctly find latest value")
@@ -440,12 +429,13 @@ class TestPackages < Test::Unit::TestCase
     end
 
     else
+    $stderr.puts "Install gems for gem tests"
     def test_nogems_nofailures
         obj = nil
         assert_nothing_raised do
             Puppet::Type.newpackage(
                 :name => "yayness",
-                :type => "gem",
+                :provider => "gem",
                 :ensure => "installed"
             )
         end
@@ -455,7 +445,7 @@ class TestPackages < Test::Unit::TestCase
     end
     end
     end
-    if ["Fedora", "RedHat", "CentOS"].include?(Facter["operatingsystem"].value) and
+    if Puppet.type(:package).provider(:rpm).suitable? and
         FileTest.exists?("/home/luke/rpm/RPMS/i386/puppet-server-0.16.1-1.i386.rpm")
 
     # We have a special test here, because we don't actually want to install the
@@ -464,73 +454,36 @@ class TestPackages < Test::Unit::TestCase
         pkg = nil
         assert_nothing_raised {
             pkg = Puppet::Type.type(:package).create(
-                :type => :rpm,
+                :provider => :rpm,
                 :name => "puppet-server",
                 :source => "/home/luke/rpm/RPMS/i386/puppet-server-0.16.1-1.i386.rpm"
             )
         }
 
-        assert_equal("0.16.1-1", pkg.latest, "RPM did not provide correct value for latest")
+        assert_equal("0.16.1-1", pkg.provider.latest, "RPM did not provide correct value for latest")
     end
     end
 
-    if Facter["operatingsystem"].value == "Solaris"
-    if pkgget = %x{which pkg-get 2>/dev/null}.chomp and pkgget != ""
-    # FIXME The packaging crap needs to be rewritten to support testing
-    # multiple package types on the same platform.
-    def test_list_blastwave
-        pkgs = nil
-        assert_nothing_raised {
-            pkgs = Puppet::Type.type(:package).pkgtype(:blastwave).list
-        }
-
-        pkgs.each do |pkg|
-            if pkg[:name] =~ /^CSW/
-                assert_equal(:blastwave, pkg[:type],
-                    "Type was not set correctly")
-            end
+    def test_packagedefaults
+        should = case Facter["operatingsystem"].value
+        when "Debian": :apt
+        when "Darwin": :apple
+        when "RedHat": :rpm
+        when "Fedora": :yum
+        when "FreeBSD": :ports
+        when "OpenBSD": :openbsd
+        when "Solaris": :sun
         end
-    end
 
-    def test_install_blastwave
-        pkg = nil
-        name = "cabextract"
-        assert_nothing_raised {
-            pkg = Puppet::Type.newpackage(
-                :name => name,
-                :ensure => "installed",
-                :type => :blastwave
-            )
-        }
+        default = Puppet.type(:package).defaultprovider
+        assert(default, "No default package provider for %s" %
+            Facter["operatingsystem"].value)
 
-        assert_nothing_raised {
-            pkg.retrieve
-        }
 
-        if pkg.is(:ensure) != :absent
-            p pkg.is(:ensure)
-            $stderr.puts "Cannot test pkg installation; %s is already installed" %
-                name
-            return
+        if should
+            assert_equal(should, default.name,
+                "Incorrect default package format")
         end
-
-        assert_events([:package_created], pkg)
-
-        assert_nothing_raised {
-            pkg.retrieve
-        }
-
-        latest = nil
-        assert_nothing_raised {
-            latest = pkg.latest
-        }
-        pkg[:ensure] = :absent
-
-        assert_events([:package_removed], pkg)
-    end
-    else
-        $stderr.puts "No pkg-get scripting; skipping blastwave tests"
-    end
     end
 end
 end
diff --git a/test/types/query.rb b/test/types/query.rb
index 451291cac..121670012 100644
--- a/test/types/query.rb
+++ b/test/types/query.rb
@@ -34,7 +34,7 @@ class TestQuery < Test::Unit::TestCase
             unless Puppet.type(:service).has_key?("sleeper")
                 Puppet.type(:service).create(
                     :name => "sleeper",
-                    :type => "init",
+                    :provider => "init",
                     :path => File.join($puppetbase,"examples/root/etc/init.d"),
                     :hasstatus => true,
                     :check => [:ensure]
@@ -82,6 +82,7 @@ class TestQuery < Test::Unit::TestCase
 
     def test_service
         service = service()
+        assert(service, "Did not get service object")
         service.eachstate { |state|
             assert_nil(state.is)
         }
diff --git a/test/types/service.rb b/test/types/service.rb
index 3a8ba089a..176f84818 100644
--- a/test/types/service.rb
+++ b/test/types/service.rb
@@ -118,7 +118,7 @@ class TestLocalService < Test::Unit::TestCase
     end
 
     def mktestsvcs
-        tstsvcs.collect { |svc,svcargs|
+        list = tstsvcs.collect { |svc,svcargs|
             args = svcargs.dup
             args[:name] = svc
             Puppet.type(:service).create(args)
@@ -167,11 +167,9 @@ class TestLocalService < Test::Unit::TestCase
 
         # test refreshing it
         assert_nothing_raised() {
-            service.refresh
+            service.provider.refresh
         }
 
-        assert(service.respond_to?(:refresh))
-
         # now stop it
         assert_nothing_raised() {
             service[:ensure] = :stopped
@@ -229,7 +227,7 @@ class TestLocalService < Test::Unit::TestCase
         mktestsvcs.each { |svc|
             val = nil
             assert_nothing_raised("Could not get status") {
-                val = svc.status
+                val = svc.provider.status
             }
             assert_instance_of(Symbol, val)
         }
@@ -242,29 +240,28 @@ class TestLocalService < Test::Unit::TestCase
             mktestsvcs.each { |svc|
                 startstate = nil
                 assert_nothing_raised("Could not get status") {
-                    startstate = svc.status
+                    startstate = svc.provider.status
                 }
                 cycleservice(svc)
 
                 svc[:ensure] = startstate
                 assert_apply(svc)
-                Puppet.type(:service).clear
                 Puppet.type(:component).clear
             }
         end
 
         def test_serviceenabledisable
             mktestsvcs.each { |svc|
+                assert(svc[:name], "Service has no name")
                 startstate = nil
                 svc[:check] = :enable
                 assert_nothing_raised("Could not get status") {
-                    startstate = svc.enabled?
+                    startstate = svc.provider.enabled?
                 }
                 cycleenable(svc)
 
                 svc[:enable] = startstate
                 assert_apply(svc)
-                Puppet.type(:service).clear
                 Puppet.type(:component).clear
             }
         end
@@ -299,7 +296,6 @@ class TestLocalService < Test::Unit::TestCase
                 svc[:enable] = startenable
                 svc[:ensure] = startensure
                 assert_apply(svc)
-                Puppet.type(:service).clear
                 Puppet.type(:component).clear
             end
         end
diff --git a/test/types/state.rb b/test/types/state.rb
index 406b9af6b..638372afe 100644
--- a/test/types/state.rb
+++ b/test/types/state.rb
@@ -32,6 +32,7 @@ class TestState < Test::Unit::TestCase
     def test_newvalue
         state = newstate()
 
+        # These are bogus because they don't define events. :/
         assert_nothing_raised {
             state.newvalue(:one) do
                 @is = 1
@@ -51,6 +52,7 @@ class TestState < Test::Unit::TestCase
         }
 
         assert_equal(:one, inst.should)
+        ret = nil
         assert_nothing_raised { inst.set_one }
         assert_equal(1, inst.is)
 
@@ -87,6 +89,43 @@ class TestState < Test::Unit::TestCase
 
         assert_equal("yayness".upcase, inst.is)
     end
+
+    def test_newvalue_event_option
+        state = newstate()
+
+        assert_nothing_raised do
+            state.newvalue(:myvalue, :event => :fake_valued) do
+                @is = :valued
+            end
+            state.newvalue(:other, :event => "fake_other") do
+                @is = :valued
+            end
+        end
+        inst = newinst(state)
+
+        assert_nothing_raised {
+            inst.should = :myvalue
+        }
+
+        ret = nil
+        assert_nothing_raised {
+            ret = inst.sync
+        }
+
+        assert_equal(:fake_valued, ret,
+                     "Event did not get returned correctly")
+
+        assert_nothing_raised {
+            inst.should = :other
+        }
+
+        assert_nothing_raised {
+            ret = inst.sync
+        }
+
+        assert_equal(:fake_other, ret,
+                     "Event did not get returned correctly")
+    end
 end
 
 # $Id$
diff --git a/test/types/type.rb b/test/types/type.rb
index 333c5683f..48e0b4323 100644
--- a/test/types/type.rb
+++ b/test/types/type.rb
@@ -35,20 +35,22 @@ class TestType < Test::Unit::TestCase
             #    next
             #end
 
-            assert(
-                type.namevar,
-                "Failed to retrieve namevar for %s" % name
-            )
+            assert_nothing_raised {
+                assert(
+                    type.namevar,
+                    "Failed to retrieve namevar for %s" % name
+                )
 
-            assert_not_nil(
-                type.states,
-                "States for %s are nil" % name
-            )
+                assert_not_nil(
+                    type.states,
+                    "States for %s are nil" % name
+                )
 
-            assert_not_nil(
-                type.validstates,
-                "Valid states for %s are nil" % name
-            )
+                assert_not_nil(
+                    type.validstates,
+                    "Valid states for %s are nil" % name
+                )
+            }
         }
     end
 
@@ -464,6 +466,63 @@ end
         assert_equal("yaytest", File.read(path),
             "Exec did not correctly copy file.")
     end
+
+    def test_newstate_options
+        # Create a type with a fake provider
+        providerclass = Class.new do
+            def method_missing(method, *args)
+                return method
+            end
+        end
+        self.class.const_set("ProviderClass", providerclass)
+
+        type = Puppet::Type.newtype(:mytype) do
+            newparam(:name) do
+                isnamevar
+            end
+            def provider
+                @provider ||= ProviderClass.new
+
+                @provider
+            end
+        end
+
+        # Now make a state with no options.
+        state = nil
+        assert_nothing_raised do
+            state = type.newstate(:noopts) do
+            end
+        end
+
+        # Now create an instance
+        obj = type.create(:name => :myobj)
+
+        inst = state.new(:parent => obj)
+
+        # And make sure it's correctly setting @is
+        ret = nil
+        assert_nothing_raised {
+            ret = inst.retrieve
+        }
+
+        assert_equal(:noopts, inst.is)
+
+        # Now create a state with a different way of doing it
+        state = nil
+        assert_nothing_raised do
+            state = type.newstate(:setretrieve, :retrieve => :yayness)
+        end
+
+        inst = state.new(:parent => obj)
+
+        # And make sure it's correctly setting @is
+        ret = nil
+        assert_nothing_raised {
+            ret = inst.retrieve
+        }
+
+        assert_equal(:yayness, inst.is)
+    end
 end
 
 # $Id$
diff --git a/test/types/user.rb b/test/types/user.rb
index 87e90ff22..008f39272 100755
--- a/test/types/user.rb
+++ b/test/types/user.rb
@@ -1,11 +1,9 @@
 if __FILE__ == $0
     $:.unshift '..'
     $:.unshift '../../lib'
-    $puppetbase = "../../../../language/trunk"
+    $puppetbase = "../.."
 end
 
-# $Id$
-
 require 'etc'
 require 'puppet/type'
 require 'puppettest'
@@ -13,90 +11,37 @@ require 'test/unit'
 
 class TestUser < Test::Unit::TestCase
 	include TestPuppet
-    def setup
-        super
-        @@tmpusers = []
-    end
 
-    def teardown
-        @@tmpusers.each { |user|
-            unless missing?(user)
-                remove(user)
+    p = Puppet::Type.type(:user).provide :fake, :parent => TestPuppet::FakeProvider do
+        @name = :fake
+        apimethods
+        def create
+            @ensure = :present
+            @model.eachstate do |state|
+                next if state.name == :ensure
+                state.sync
             end
-        }
-        super
-        #Puppet.type(:user).clear
-    end
-
-    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
-
-            assert_equal("", output, "User %s is present:\n%s" % [user, output])
         end
 
-        def current?(param, name)
-            state = Puppet.type(:user).states.find { |st|
-                st.name == param
-            }
-
-            output = %x{nireport / /users name #{state.netinfokey}}
-            output.split("\n").each { |line|
-                if line =~ /^(\w+)\s+(.+)$/
-                    user = $1
-                    id = $2.sub(/\s+$/, '')
-                    if user == name
-                        if id =~ /^[-0-9]+$/
-                            return Integer(id)
-                        else
-                            return id
-                        end
-                    end
-                else
-                    raise "Could not match %s" % line
-                end
-            }
-
-            return nil
+        def delete
+            @ensure = :absent
+            @model.eachstate do |state|
+                send(state.name.to_s + "=", :absent)
+            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
+        def exists?
+            if defined? @ensure and @ensure == :present
+                true
+            else
+                false
             end
         end
+    end
 
-        def current?(param, name)
-            state = Puppet.type(:user).states.find { |st|
-                st.name == param
-            }
-
-            assert_nothing_raised {
-                obj = Etc.getpwnam(name)
-                return obj.send(state.posixmethod)
-            }
-
-            return nil
-        end
+    FakeUserProvider = p
 
-        def remove(user)
-            system("userdel %s" % user)
-        end
-    end
+    @@fakeproviders[:group] = p
 
     def findshell(old = nil)
         %w{/bin/sh /bin/bash /sbin/sh /bin/ksh /bin/zsh /bin/csh /bin/tcsh
@@ -110,6 +55,16 @@ class TestUser < Test::Unit::TestCase
         }
     end
 
+    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 {
@@ -122,19 +77,21 @@ class TestUser < Test::Unit::TestCase
             )
         }
 
+        assert(user, "Did not create user")
+
         return user
     end
 
     def attrtest_ensure(user)
-        old = user.is(:ensure)
+        old = user.provider.ensure
         user[:ensure] = :absent
 
         comp = newcomp("ensuretest", user)
         assert_apply(user)
-        assert(missing?(user.name), "User is still present")
+        assert(!user.provider.exists?, "User is still present")
         user[:ensure] = :present
         assert_events([:user_created], comp)
-        assert(!missing?(user.name), "User is absent")
+        assert(user.provider.exists?, "User is absent")
         user[:ensure] = :absent
         trans = assert_events([:user_removed], comp)
 
@@ -146,19 +103,19 @@ class TestUser < Test::Unit::TestCase
 
     def attrtest_comment(user)
         user.retrieve
-        old = user.is(:comment)
+        old = user.provider.comment
         user[:comment] = "A different comment"
 
         comp = newcomp("commenttest", user)
 
-        trans = assert_events([:user_modified], comp, "user")
+        trans = assert_events([:user_changed], comp, "user")
 
-        assert_equal("A different comment", current?(:comment, user[:name]),
+        assert_equal("A different comment", user.provider.comment,
             "Comment was not changed")
 
-        assert_rollback_events(trans, [:user_modified], "user")
+        assert_rollback_events(trans, [:user_changed], "user")
 
-        assert_equal(old, current?(:comment, user[:name]),
+        assert_equal(old, user.provider.comment,
             "Comment was not reverted")
     end
 
@@ -166,24 +123,24 @@ class TestUser < Test::Unit::TestCase
         obj = nil
         comp = newcomp("hometest", user)
 
-        old = current?(:home, user[:name])
+        old = user.provider.home
         user[:home] = old
 
         trans = assert_events([], comp, "user")
 
         user[:home] = "/tmp"
 
-        trans = assert_events([:user_modified], comp, "user")
+        trans = assert_events([:user_changed], comp, "user")
 
-        assert_equal("/tmp", current?(:home, user[:name]), "Home was not changed")
+        assert_equal("/tmp", user.provider.home, "Home was not changed")
 
-        assert_rollback_events(trans, [:user_modified], "user")
+        assert_rollback_events(trans, [:user_changed], "user")
 
-        assert_equal(old, current?(:home, user[:name]), "Home was not reverted")
+        assert_equal(old, user.provider.home, "Home was not reverted")
     end
 
     def attrtest_shell(user)
-        old = current?(:shell, user[:name])
+        old = user.provider.shell
         comp = newcomp("shelltest", user)
 
         user[:shell] = old
@@ -199,19 +156,21 @@ class TestUser < Test::Unit::TestCase
 
         user[:shell] = newshell
 
-        trans = assert_events([:user_modified], comp, "user")
+        trans = assert_events([:user_changed], comp, "user")
 
-        assert_equal(newshell, current?(:shell, user[:name]),
+        user.retrieve
+        assert_equal(newshell, user.provider.shell,
             "Shell was not changed")
 
-        assert_rollback_events(trans, [:user_modified], "user")
+        assert_rollback_events(trans, [:user_changed], "user")
+        user.retrieve
 
-        assert_equal(old, current?(:shell, user[:name]), "Shell was not reverted")
+        assert_equal(old, user.provider.shell, "Shell was not reverted")
     end
 
     def attrtest_gid(user)
         obj = nil
-        old = current?(:gid,user.name)
+        old = user.provider.gid
         comp = newcomp("gidtest", user)
 
         user.retrieve
@@ -239,7 +198,7 @@ class TestUser < Test::Unit::TestCase
             user[:gid] = newgid
         }
 
-        trans = assert_events([:user_modified], comp, "user")
+        trans = assert_events([:user_changed], comp, "user")
 
         # then by id
         newgid = Etc.getgrnam(newgid).gid
@@ -252,23 +211,21 @@ class TestUser < Test::Unit::TestCase
 
         assert_events([], comp, "user")
 
-        assert_equal(newgid, current?(:gid,user[:name]), "GID was not changed")
+        assert_equal(newgid, user.provider.gid, "GID was not changed")
 
-        assert_rollback_events(trans, [:user_modified], "user")
+        assert_rollback_events(trans, [:user_changed], "user")
 
-        assert_equal(old, current?(:gid,user[:name]), "GID was not reverted")
+        assert_equal(old, user.provider.gid, "GID was not reverted")
     end
 
     def attrtest_uid(user)
         obj = nil
         comp = newcomp("uidtest", user)
 
-        old = current?(:uid, user[:name])
-        user[:uid] = old
+        user.provider.uid = 1
 
-        trans = assert_events([], comp, "user")
-
-        newuid = old
+        old = 1
+        newuid = 1
         while true
             newuid += 1
 
@@ -287,13 +244,13 @@ class TestUser < Test::Unit::TestCase
             user[:uid] = newuid
         }
 
-        trans = assert_events([:user_modified], comp, "user")
+        trans = assert_events([:user_changed], comp, "user")
 
-        assert_equal(newuid, current?(:uid, user[:name]), "UID was not changed")
+        assert_equal(newuid, user.provider.uid, "UID was not changed")
 
-        assert_rollback_events(trans, [:user_modified], "user")
+        assert_rollback_events(trans, [:user_changed], "user")
 
-        assert_equal(old, current?(:uid, user[:name]), "UID was not reverted")
+        assert_equal(old, user.provider.uid, "UID was not reverted")
     end
 
     def attrtest_groups(user)
@@ -311,11 +268,7 @@ class TestUser < Test::Unit::TestCase
         5.times do |i|
             i += 1
             name = "pptstgr%s" % i
-            groups << Puppet.type(:group).create(
-                :name => name,
-                :gid => max + i
-            )
-
+            groups << name
             if i < 3
                 main << name
             else
@@ -323,9 +276,6 @@ class TestUser < Test::Unit::TestCase
             end
         end
 
-        # Create our test groups
-        assert_apply(*groups)
-
         assert(user[:membership] == :minimum, "Membership did not default correctly")
 
         assert_nothing_raised {
@@ -353,6 +303,10 @@ class TestUser < Test::Unit::TestCase
         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")
+
         user.retrieve
 
         assert(user.state(:groups).is, "Did not retrieve group list")
@@ -365,7 +319,7 @@ class TestUser < Test::Unit::TestCase
             user[:groups] = main
         }
 
-        assert_equal((main + extra).sort.join(","), user.state(:groups).should)
+        assert_equal((main + extra).sort, user.state(:groups).should.sort)
 
         assert_nothing_raised {
             user.retrieve
@@ -393,7 +347,7 @@ class TestUser < Test::Unit::TestCase
 
         assert(!user.insync?, "User is incorrectly in sync")
 
-        assert_events([:user_modified], user)
+        assert_events([:user_changed], user)
         assert_nothing_raised {
             user.retrieve
         }
@@ -401,75 +355,35 @@ class TestUser < Test::Unit::TestCase
         list = user.state(:groups).is
         assert_equal(main.sort, list.sort, "Group list is not equal")
 
-        # Now delete our groups
-        groups.each do |group|
-            group[:ensure] = :absent
-        end
-
         user.delete(:groups)
-
-        assert_apply(*groups)
-    end
-
-    # Disabled, because this is testing too much internal implementation
-    def disabled_test_eachmethod
-        obj = Etc.getpwuid(Process.uid)
-
-        assert(obj, "Could not retrieve test group object")
-
-        Puppet.type(:user).validstates.each { |name|
-            assert_nothing_raised {
-                method = state.posixmethod
-                assert(method, "State %s has no infomethod" % name)
-                assert(obj.respond_to?(method),
-                    "State %s has an invalid method %s" %
-                    [name, method])
-            }
-        }
     end
 
-    def test_checking
-        require 'etc'
-
-        name = nil
-        assert_nothing_raised {
-            name = Etc.getpwuid(Process.uid).name
-        }
+    def test_autorequire
+        file = tempfile()
+        comp = nil
         user = nil
+        group =nil
+        home = nil
+        ogroup = nil
         assert_nothing_raised {
-            checks = Puppet.type(:user).validstates
             user = Puppet.type(:user).create(
-                :name => name,
-                :check => checks
+                :name => "pptestu",
+                :home => file,
+                :gid => "pptestg",
+                :groups => "yayness"
             )
+            home = Puppet.type(:file).create(
+                :path => file,
+                :ensure => "directory"
+            )
+            group = Puppet.type(:group).create(
+                :name => "pptestg"
+            )
+            ogroup = Puppet.type(:group).create(
+                :name => "yayness"
+            )
+            comp = newcomp(user, group, home, ogroup)
         }
-
-        assert_nothing_raised {
-            user.retrieve
-        }
-
-        assert_equal(Process.uid, user.is(:uid), "Retrieved UID does not match")
-    end
-
-    def test_autorequire
-        file = tempfile()
-        user = Puppet.type(:user).create(
-            :name => "pptestu",
-            :home => file,
-            :gid => "pptestg",
-            :groups => "yayness"
-        )
-        home = Puppet.type(:file).create(
-            :path => file,
-            :ensure => "directory"
-        )
-        group = Puppet.type(:group).create(
-            :name => "pptestg"
-        )
-        ogroup = Puppet.type(:group).create(
-            :name => "yayness"
-        )
-        comp = newcomp(user, group, home, ogroup)
         comp.finalize
         comp.retrieve
 
@@ -478,86 +392,52 @@ class TestUser < Test::Unit::TestCase
         assert(user.requires?(ogroup), "User did not require other groups")
     end
 
-    if Process.uid == 0
-        def test_simpleuser
-            name = "pptest"
-
-            assert(missing?(name), "User %s is present" % name)
-
-            user = mkuser(name)
-
-            @@tmpusers << name
-
-            comp = newcomp("usercomp", user)
+    def test_simpleuser
+        name = "pptest"
 
-            trans = assert_events([:user_created], comp, "user")
+        user = mkuser(name)
 
-            assert_equal("Puppet Testing User", current?(:comment, user[:name]),
-                "Comment was not set")
+        comp = newcomp("usercomp", user)
 
-            assert_rollback_events(trans, [:user_removed], "user")
+        trans = assert_events([:user_created], comp, "user")
 
-            assert(missing?(user[:name]))
-        end
-
-        def test_allstates
-            user = nil
-            name = "pptest"
+        assert_equal(user.should(:comment), user.provider.comment,
+            "Comment was not set correctly")
 
-            assert(missing?(name), "User %s is present" % name)
+        assert_rollback_events(trans, [:user_removed], "user")
 
-            user = mkuser(name)
+        assert(! user.provider.exists?, "User did not get deleted")
+    end
 
-            @@tmpusers << name
+    def test_allusermodelstates
+        user = nil
+        name = "pptest"
 
-            comp = newcomp("usercomp", user)
+        user = mkuser(name)
 
-            trans = assert_events([:user_created], comp, "user")
+        assert(! user.provider.exists?, "User %s is present" % name)
 
-            user.retrieve
-            assert_equal("Puppet Testing User", current?(:comment, user[:name]),
-                "Comment was not set")
+        comp = newcomp("usercomp", user)
 
-            tests = Puppet.type(:user).validstates
+        trans = assert_events([:user_created], comp, "user")
 
-            tests.each { |test|
-                next unless test.to_s =~ /groups/
-                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[:ensure] = :absent
-            assert_apply(user)
-        end
+        user.retrieve
+        assert_equal("Puppet Testing User", user.provider.comment,
+            "Comment was not set")
 
-        def test_duplicateIDs
-            user1 = mkuser("user1")
-            user1[:uid] = 125
-            user2 = mkuser("user2")
-            user2[:uid] = 125
+        tests = Puppet.type(:user).validstates
 
-            cleanup do
-                user1[:ensure] = :absent
-                user2[:ensure] = :absent
-                assert_apply(user1, user2)
+        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
+        }
 
-            assert_apply(user1)
-
-            # 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[:allowdupe] = true
-            }
-            assert_apply(user2)
-            user2.retrieve
-            assert_equal(:present, user2.state(:ensure).is,
-                         "User did not get created")
-        end
-    else
-        $stderr.puts "Not root; skipping user creation/modification tests"
+        user[:ensure] = :absent
+        assert_apply(user)
     end
 end
+
+# $Id$