puppet 0.24.9 → 0.25.0

data/test/puppet/defaults.rb

@@ -11,7 +11,7 @@ class TestPuppetDefaults < Test::Unit::TestCase
     @@dirs = %w{rrddir confdir vardir logdir statedir}
     @@files = %w{statefile manifest masterlog}
     @@normals = %w{puppetport masterport server}
-    @@booleans = %w{rrdgraph noop}
+    @@booleans = %w{noop}
 
     def testVersion
         assert( Puppet.version =~ /^[0-9]+(\.[0-9]+)*/, "got invalid version number %s" % Puppet.version )

data/test/puppet/tc_suidmanager.rb

@@ -84,7 +84,7 @@ class TestSUIDManager < Test::Unit::TestCase
                                                ).returns('output')
 
 
-            output = Puppet::Util::SUIDManager.run_and_capture 'yay', 
+            output = Puppet::Util::SUIDManager.run_and_capture 'yay',
                                                                @user.uid,
                                                                @user.gid
 

data/test/rails/railsparameter.rb

@@ -8,10 +8,10 @@ require 'puppettest'
 require 'puppettest/railstesting'
 
 # Don't do any tests w/out this class
-if defined? ActiveRecord::Base
+if defined? ::ActiveRecord::Base
 class TestRailsParameter < Test::Unit::TestCase
     include PuppetTest::RailsTesting
-    
+
     def params
         {"myname" => "myval", "multiple" => %w{one two three}}
     end
@@ -27,9 +27,9 @@ class TestRailsParameter < Test::Unit::TestCase
         host = Puppet::Rails::Host.new(:name => "myhost")
 
         host.save
-        
+
         resource = host.resources.create(
-            :title => "/tmp/to_resource", 
+            :title => "/tmp/to_resource",
             :restype => "file",
             :exported => true)
 

data/test/ral/manager/attributes.rb

@@ -29,7 +29,7 @@ class TestTypeAttributes < Test::Unit::TestCase
         # and a param
         type.newparam(:param)
 
-        inst = type.create(:name => "yay")
+        inst = type.new(:name => "yay")
 
         # Make sure we can set each of them, including a metaparam
         [:param, :property, :noop].each do |param|
@@ -66,7 +66,7 @@ class TestTypeAttributes < Test::Unit::TestCase
             type.newproperty(prop) {}
         end
 
-        inst = type.create(:name => "yay")
+        inst = type.new(:name => "yay")
 
         inst[:one] = "boo"
         one = inst.property(:one)
@@ -88,7 +88,7 @@ class TestTypeAttributes < Test::Unit::TestCase
         @num ||= 0
         @num += 1
         name = "name%s" % @num
-        inst = type.create(:name => name)
+        inst = type.new(:name => name)
         [:meta, :param, :prop].each do |name|
             klass = type.attrclass(name)
             assert(klass, "did not get class for %s" % name)
@@ -139,47 +139,12 @@ class TestTypeAttributes < Test::Unit::TestCase
         end
     end
 
-    def test_setdefaults
-        type = mktype
-        type.newparam(:name) {}
-        
-        # Make one of each param type
-        {
-            :meta2 => :newmetaparam, :param2 => :newparam, :prop2 => :newproperty
-        }.each do |name, method|
-            assert_nothing_raised("Could not make %s of type %s" % [name, method]) do
-                type.send(method, name) do
-                    defaultto "testing"
-                end
-            end
-        end
-
-        inst = type.create(:name => 'yay')
-        assert_nothing_raised do
-            inst.setdefaults
-        end
-
-        [:meta2, :param2, :prop2].each do |name|
-            assert(inst.value(name), "did not get a value for %s" % name)
-        end
-
-        # Try a default of "false"
-        type.newparam(:falsetest) do
-            defaultto false
-        end
-
-        assert_nothing_raised do
-            inst.setdefaults
-        end
-        assert_equal(false, inst[:falsetest], "false default was not set")
-    end
-
     def test_alias_parameter
         type = mktype
         type.newparam(:name) {}
         type.newparam(:one) {}
         type.newproperty(:two) {}
-        
+
         aliases = {
             :three => :one,
             :four => :two
@@ -197,7 +162,7 @@ class TestTypeAttributes < Test::Unit::TestCase
 
         assert_nil(type.attr_alias(:name), "got invalid alias info for name")
 
-        inst = type.create(:name => "my name")
+        inst = type.new(:name => "my name")
         assert(inst, "could not create instance")
 
         aliases.each do |new, old|
@@ -207,7 +172,7 @@ class TestTypeAttributes < Test::Unit::TestCase
             end
 
             case old
-            when :one: # param
+            when :one # param
                 assert_equal(val, inst[new],
                     "Incorrect alias value for %s in []" % new)
             else
@@ -219,27 +184,6 @@ class TestTypeAttributes < Test::Unit::TestCase
         end
     end
 
-    # Make sure eachattr is called in the parameter order.
-    def test_eachattr
-        type = mktype
-        name = type.newparam(:name) {}
-        one = type.newparam(:one) {}
-        two = type.newproperty(:two) {}
-        type.provide(:testing) {}
-        provider = type.attrclass(:provider)
-        should = [[name, :param], [provider, :param], [two, :property], [one, :param]]
-        assert_nothing_raised do
-            result = nil
-            type.eachattr do |obj, name|
-                result = [obj, name]
-                shouldary = should.shift
-                assert_equal(shouldary, result, "Did not get correct parameter")
-                break if should.empty?
-            end
-        end
-        assert(should.empty?, "Did not get all of the parameters.")
-    end
-
     # Make sure newattr handles required features correctly.
     def test_newattr_and_required_features
         # Make a type with some features
@@ -262,16 +206,16 @@ class TestTypeAttributes < Test::Unit::TestCase
 
         # Now make sure that we get warnings and no properties in those cases where our providers do not support the features requested
         [nope, maybe, yep].each_with_index do |prov, i|
-            resource = type.create(:provider => prov.name, :name => "test%s" % i, :none => "a", :one => "b", :two => "c")
+            resource = type.new(:provider => prov.name, :name => "test%s" % i, :none => "a", :one => "b", :two => "c")
 
             case prov.name
-            when :nope:
+            when :nope
                 yes = [:none]
                 no = [:one, :two]
-            when :maybe:
+            when :maybe
                 yes = [:none, :one]
                 no = [:two]
-            when :yep:
+            when :yep
                 yes = [:none, :one, :two]
                 no = []
             end
@@ -292,7 +236,7 @@ class TestTypeAttributes < Test::Unit::TestCase
         file = Puppet::Type.type(:file)
         klass = file.attrclass(:check)
 
-        resource = file.create(:path => tempfile)
+        resource = file.new(:path => tempfile)
         inst = klass.new(:resource => resource)
 
         {:property => [:owner, :group], :parameter => [:ignore, :recurse], :metaparam => [:require, :subscribe]}.each do |attrtype, attrs|
@@ -343,7 +287,7 @@ class TestTypeAttributes < Test::Unit::TestCase
         end
         cleanup { Puppet::Type.rmtype(:unsupported) }
 
-        obj = type.create(:name => "test", :check => :yep)
+        obj = type.new(:name => "test", :check => :yep)
         obj.expects(:newattr).with(:nope).never
         obj[:check] = :all
     end

data/test/ral/manager/instances.rb

@@ -64,9 +64,9 @@ class TestTypeInstances < Test::Unit::TestCase
 
         # Now make a couple of instances, so we know we correctly match instead of always
         # trying to create new ones.
-        one = @type.create(:name => :one, :ensure => :present)
-        three = @type.create(:name => :three, :ensure => :present, :provider => :sub)
-        five = @type.create(:name => :five, :ensure => :present, :provider => :yep)
+        one = @type.new(:name => :one, :ensure => :present)
+        three = @type.new(:name => :three, :ensure => :present, :provider => :sub)
+        five = @type.new(:name => :five, :ensure => :present, :provider => :yep)
 
         result = nil
         assert_nothing_raised("Could not get instance list") do
@@ -89,21 +89,5 @@ class TestTypeInstances < Test::Unit::TestCase
         # Now make sure the resources have an 'ensure' property to go with the value in the provider
         assert(resources[:one].send(:instance_variable_get, "@parameters").include?(:ensure), "Did not create ensure property")
     end
-
-    # Make sure resources are entirely deleted.
-    def test_delete
-        aliases = %w{one}
-        catalog = mk_catalog
-        obj = @type.create(:name => "testing", :alias => "two", :catalog => catalog)
-        aliases << "two"
-
-        @type.alias("two", obj)
-
-        obj.remove
-        assert_nil(@type["testing"], "Object was not removed from objects hash")
-        assert_nil(@type["one"], "Object's alias was not removed")
-        assert_nil(@type["two"], "Object's second alias was not removed")
-
-    end
 end
 

data/test/ral/manager/manager.rb

@@ -9,19 +9,19 @@ require 'puppettest'
 
 class TestTypeManager < Test::Unit::TestCase
     include PuppetTest
-    
+
     class FakeManager
         extend Puppet::MetaType::Manager
         def self.clear
             @types = {}
         end
     end
-    
+
     def teardown
         super
         FakeManager.clear
     end
-    
+
     # Make sure we can remove defined types
     def test_rmtype
         assert_nothing_raised {
@@ -30,22 +30,22 @@ class TestTypeManager < Test::Unit::TestCase
             end
         }
         assert(FakeManager.type(:testing), "Did not get fake type")
-        
+
         assert_nothing_raised do
             FakeManager.rmtype(:testing)
         end
-        
+
         assert_nil(FakeManager.type(:testing), "Type was not removed")
         assert(! defined?(FakeManager::Testing), "Constant was not removed")
     end
-    
+
     def test_newtype
         assert_nothing_raised do
             FakeManager.newtype(:testing, :self_refresh => true) do
                 newparam(:name, :namevar => true)
             end
         end
-        
+
         test = FakeManager.type(:testing)
         assert(test, "did not get type")
         assert(test.self_refresh, "did not set attribute")

data/test/ral/manager/provider.rb

@@ -6,7 +6,7 @@ require 'puppettest'
 require 'mocha'
 
 class TestTypeProviders < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
 
     def setup
         super
@@ -54,7 +54,7 @@ class TestTypeProviders < Test::Unit::TestCase
         # first make sure we can pass the name in
         resource = nil
         assert_nothing_raised("Could not create provider instance by name") do
-            resource = @type.create :name => "yay", :provider => :testing
+            resource = @type.new :name => "yay", :provider => :testing
         end
 
         assert_instance_of(provider, resource.provider, "Did not create provider instance")
@@ -62,7 +62,7 @@ class TestTypeProviders < Test::Unit::TestCase
         # Now make sure we can pass in an instance
         provinst = provider.new(:name => "foo")
         assert_nothing_raised("Could not pass in provider instance") do
-            resource = @type.create :name => "foo", :provider => provinst
+            resource = @type.new :name => "foo", :provider => provinst
         end
 
         assert_equal(provinst, resource.provider, "Did not retain provider instance")
@@ -74,11 +74,11 @@ class TestTypeProviders < Test::Unit::TestCase
         end
 
         # And make sure the provider must be a valid provider type for this resource
-        pkgprov = Puppet::Type.type(:package).create(:name => "yayness").provider
+        pkgprov = Puppet::Type.type(:package).new(:name => "yayness").provider
         assert(provider, "did not get package provider")
 
         assert_raise(Puppet::Error, "Did not fail on invalid provider instance") do
-            resource = @type.create :name => "bar", :provider => pkgprov
+            resource = @type.new :name => "bar", :provider => pkgprov
         end
 
     end
@@ -89,7 +89,7 @@ class TestTypeProviders < Test::Unit::TestCase
         Puppet::Type.type(:user).provider(:useradd).stubs(:suitable?).returns false
 
         assert_nothing_raised("Unsuitable providers failed at initialization") do
-            Puppet::Type.type(:user).create :name => "luke", :ensure => :present, :provider => :useradd
+            Puppet::Type.type(:user).new :name => "luke", :ensure => :present, :provider => :useradd
         end
     end
 
@@ -98,7 +98,7 @@ class TestTypeProviders < Test::Unit::TestCase
     def test_unsuitable_providers_should_fail_at_evaluation
         Puppet::Type.type(:user).provider(:useradd).stubs(:suitable?).returns false
 
-        user = Puppet::Type.type(:user).create :name => "luke", :ensure => :present, :provider => :useradd
+        user = Puppet::Type.type(:user).new :name => "luke", :ensure => :present, :provider => :useradd
         assert_raise(Puppet::Error, "Unsuitable provider did not fail at evaluation") do
             user.evaluate
         end

data/test/ral/manager/type.rb

@@ -6,7 +6,7 @@ require 'puppettest'
 require 'mocha'
 
 class TestType < Test::Unit::TestCase
-	include PuppetTest
+    include PuppetTest
     def test_typemethods
         Puppet::Type.eachtype { |type|
             name = nil
@@ -52,7 +52,7 @@ class TestType < Test::Unit::TestCase
         path = tempfile()
         assert_nothing_raised() {
             system("rm -f %s" % path)
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 :path => path,
                 :ensure => "file",
                 :recurse => true,
@@ -65,10 +65,9 @@ class TestType < Test::Unit::TestCase
         assert_nothing_raised() {
             file.evaluate
         }
-        Puppet.type(:file).clear
         assert_nothing_raised() {
             system("rm -f %s" % path)
-            file = Puppet.type(:file).create(
+            file = Puppet::Type.type(:file).new(
                 "path" => path,
                 "ensure" => "file",
                 "recurse" => true,
@@ -102,7 +101,7 @@ class TestType < Test::Unit::TestCase
         # currently groups are the only objects with the namevar as a property
         group = nil
         assert_nothing_raised {
-            group = Puppet.type(:group).create(
+            group = Puppet::Type.type(:group).new(
                 :name => "testing"
             )
         }
@@ -110,48 +109,8 @@ class TestType < Test::Unit::TestCase
         assert_equal("testing", group.name, "Could not retrieve name")
     end
 
-    # Verify that values get merged correctly
-    def test_mergepropertyvalues
-        file = tempfile()
-
-        # Create the first version
-        assert_nothing_raised {
-            Puppet.type(:file).create(
-                :path => file,
-                :owner => ["root", "bin"]
-            )
-        }
-
-        # Make sure no other statements are allowed
-        assert_raise(Puppet::Error) {
-            Puppet.type(:file).create(
-                :path => file,
-                :group => "root"
-            )
-        }
-    end
-
-    def test_aliases_to_self_are_not_failures
-        resource = Puppet.type(:file).create(
-            :name => "/path/to/some/missing/file",
-            :ensure => "file"
-        )
-        resource.stubs(:path).returns("")
-
-        catalog = stub 'catalog'
-        catalog.expects(:resource).with(:file, "/path/to/some/missing/file").returns(resource)
-        resource.catalog = catalog
-
-        # Verify our adding ourselves as an alias isn't an error.
-        assert_nothing_raised("Could not add alias") {
-            resource[:alias] = "/path/to/some/missing/file"
-        }
-
-        assert_equal(resource.object_id, Puppet.type(:file)["/path/to/some/missing/file"].object_id, "Could not retrieve alias to self")
-    end
-
-    def test_aliases_are_added_to_class_and_catalog
-        resource = Puppet.type(:file).create(
+    def test_aliases_are_added_to_catalog
+        resource = Puppet::Type.type(:file).new(
             :name => "/path/to/some/missing/file",
             :ensure => "file"
         )
@@ -165,12 +124,10 @@ class TestType < Test::Unit::TestCase
         assert_nothing_raised("Could not add alias") {
             resource[:alias] = "funtest"
         }
-
-        assert_equal(resource.object_id, Puppet.type(:file)["funtest"].object_id, "Could not retrieve alias")
     end
 
     def test_aliasing_fails_without_a_catalog
-        resource = Puppet.type(:file).create(
+        resource = Puppet::Type.type(:file).new(
             :name => "/no/such/file",
             :ensure => "file"
         )
@@ -180,78 +137,10 @@ class TestType < Test::Unit::TestCase
         }
     end
 
-    def test_catalogs_are_set_during_initialization_if_present_on_the_transobject
-        trans = Puppet::TransObject.new("/path/to/some/file", :file)
-        trans.catalog = :my_config
-        resource = trans.to_type
-        assert_equal(resource.catalog, trans.catalog, "Did not set catalog on initialization")
-    end
-
-    # Verify that requirements don't depend on file order
-    def test_prereqorder
-        one = tempfile()
-        two = tempfile()
-
-        twoobj = nil
-        oneobj = nil
-        assert_nothing_raised("Could not create prereq that doesn't exist yet") {
-            twoobj = Puppet.type(:file).create(
-                :name => two,
-                :require => [:file, one]
-            )
-        }
-
-        assert_nothing_raised {
-            oneobj = Puppet.type(:file).create(
-                :name => one
-            )
-        }
-
-        comp = mk_catalog(twoobj, oneobj)
-
-        assert_nothing_raised {
-            comp.finalize
-        }
-
-
-        assert(twoobj.requires?(oneobj), "Requirement was not created")
-    end
-
-    # Verify that names are aliases, not equivalents
-    def test_nameasalias
-        file = nil
-        # Create the parent dir, so we make sure autorequiring the parent dir works
-        parentdir = tempfile()
-        dir = Puppet.type(:file).create(
-            :name => parentdir,
-            :ensure => "directory"
-        )
-        assert_apply(dir)
-        path = File.join(parentdir, "subdir")
-        name = "a test file"
-        transport = Puppet::TransObject.new(name, "file")
-        transport[:path] = path
-        transport[:ensure] = "file"
-        assert_nothing_raised {
-            file = transport.to_type
-        }
-
-        assert_equal(path, file[:path])
-        assert_equal(name, file.title)
-
-        assert_nothing_raised {
-            file.retrieve
-        }
-
-        assert_apply(file)
-
-        assert(Puppet.type(:file)[name], "Could not look up object by name")
-    end
-
     def test_ensuredefault
         user = nil
         assert_nothing_raised {
-            user = Puppet.type(:user).create(
+            user = Puppet::Type.type(:user).new(
                 :name => "pptestAA",
                 :check => [:uid]
             )
@@ -261,7 +150,7 @@ class TestType < Test::Unit::TestCase
         assert(! user.property(:ensure), "User got an ensure property")
 
         assert_nothing_raised {
-            user = Puppet.type(:user).create(
+            user = Puppet::Type.type(:user).new(
                 :name => "pptestAB",
                 :comment => "Testingness"
             )
@@ -270,7 +159,7 @@ class TestType < Test::Unit::TestCase
         assert(user.property(:ensure), "User did not add ensure property")
 
         assert_nothing_raised {
-            user = Puppet.type(:user).create(
+            user = Puppet::Type.type(:user).new(
                 :name => "pptestBC",
                 :comment => "A fake user"
             )
@@ -386,41 +275,10 @@ class TestType < Test::Unit::TestCase
         assert_equal(:yayness, ret)
     end
 
-    def test_name_vs_title
-        path = tempfile()
-
-        trans = nil
-
-        assert_nothing_raised {
-            trans = Puppet::TransObject.new(path, :file)
-        }
-
-        file = nil
-        assert_nothing_raised {
-            file = Puppet::Type.newfile(trans)
-        }
-
-        assert(file.respond_to?(:title),
-            "No 'title' method")
-
-        assert(file.respond_to?(:name),
-            "No 'name' method")
-
-        assert_equal(file.title, file.name,
-            "Name and title were not marked equal")
-
-        assert_nothing_raised {
-            file.title = "My file"
-        }
-
-        assert_equal("My file", file.title)
-        assert_equal(path, file.name)
-    end
-
     # Make sure the title is sufficiently differentiated from the namevar.
     def test_title_at_creation_with_hash
         file = nil
-        fileclass = Puppet::Type.type(:file) 
+        fileclass = Puppet::Type.type(:file)
 
         path = tempfile()
         assert_nothing_raised do
@@ -434,7 +292,6 @@ class TestType < Test::Unit::TestCase
         assert_equal(path, file[:name], "Did not get correct name")
 
         file = nil
-        Puppet::Type.type(:file).clear
 
         # Now make sure we can specify both and still get the right answers
         assert_nothing_raised do
@@ -450,183 +307,56 @@ class TestType < Test::Unit::TestCase
         assert_equal(path, file[:name], "Did not get correct name")
     end
 
-    # Make sure the "create" class method behaves appropriately.
-    def test_class_create
-        title = "Myfile"
-        validate = proc do |element|
-            assert(element, "Did not create file")
-            assert_instance_of(Puppet::Type.type(:file), element)
-            assert_equal(title, element.title, "Title is not correct")
-        end
-        type = :file
-        args = {:path => tempfile(), :owner => "root"}
-
-        trans = Puppet::TransObject.new(title, type)
-        args.each do |name, val| trans[name] = val end
-
-        # First call it on the appropriate typeclass
-        obj = nil
-        assert_nothing_raised do
-            obj = Puppet::Type.type(:file).create(trans)
-        end
-
-        validate.call(obj)
-
-        # Now try it using the class method on Type
-        oldid = obj.object_id
-        obj = nil
-        Puppet::Type.type(:file).clear
-
-        assert_nothing_raised {
-            obj = Puppet::Type.create(trans)
-        }
-
-        validate.call(obj)
-        assert(oldid != obj.object_id, "Got same object back")
-
-        # Now try the same things with hashes instead of a transobject
-        oldid = obj.object_id
-        obj = nil
-        Puppet::Type.type(:file).clear
-        hash = {
-            :type => :file,
-            :title => "Myfile",
-            :path => tempfile(),
-            :owner => "root"
-        }
-
-        # First call it on the appropriate typeclass
-        obj = nil
-        assert_nothing_raised do
-            obj = Puppet::Type.type(:file).create(hash)
-        end
-
-        validate.call(obj)
-        assert_equal(:file, obj.should(:type),
-            "Type param did not pass through")
-
-        assert(oldid != obj.object_id, "Got same object back")
-
-        # Now try it using the class method on Type
-        oldid = obj.object_id
-        obj = nil
-        Puppet::Type.type(:file).clear
-
-        assert_nothing_raised {
-            obj = Puppet::Type.create(hash)
-        }
-
-        validate.call(obj)
-        assert(oldid != obj.object_id, "Got same object back")
-        assert_nil(obj.should(:type),
-            "Type param passed through")
-    end
-
-    def test_multiplenames
-        obj = nil
-        path = tempfile()
-        assert_raise ArgumentError do
-            obj = Puppet::Type.type(:file).create(
-                :name => path,
-                :path => path
-            )
-        end
-    end
-
-    def test_title_and_name
-        obj = nil
-        path = tempfile()
-        fileobj = Puppet::Type.type(:file)
-
-        assert_nothing_raised do
-            obj = fileobj.create(
-                :title => "myfile",
-                :path => path
-            )
-        end
-
-        assert_equal(obj, fileobj["myfile"],
-            "Could not retrieve obj by title")
-
-        assert_equal(obj, fileobj[path],
-            "Could not retrieve obj by name")
-    end
-
-    # Make sure default providers behave correctly
-    def test_defaultproviders
-        # Make a fake type
-        type = Puppet::Type.newtype(:defaultprovidertest) do
-            newparam(:name) do end
-        end
-
-        basic = type.provide(:basic) do
-            defaultfor :operatingsystem => :somethingelse,
-                :operatingsystemrelease => :yayness
-        end
-
-        assert_equal(basic, type.defaultprovider)
-        type.defaultprovider = nil
-
-        greater = type.provide(:greater) do
-            defaultfor :operatingsystem => Facter.value("operatingsystem")
-        end
-
-        assert_equal(greater, type.defaultprovider)
-    end
-
     # Make sure that we can have multiple non-isomorphic objects with the same name,
     # but not with isomorphic objects.
     def test_isomorphic_names
+        catalog = mk_catalog
         # First do execs, since they're not isomorphic.
         echo = Puppet::Util.binary "echo"
         exec1 = exec2 = nil
         assert_nothing_raised do
-            exec1 = Puppet::Type.type(:exec).create(
+            exec1 = Puppet::Type.type(:exec).new(
                 :title => "exec1",
                 :command => "#{echo} funtest"
             )
         end
+        catalog.add_resource(exec1)
         assert_nothing_raised do
-            exec2 = Puppet::Type.type(:exec).create(
+            exec2 = Puppet::Type.type(:exec).new(
                 :title => "exec2",
                 :command => "#{echo} funtest"
             )
         end
-
-        assert_apply(exec1, exec2)
+        catalog.add_resource(exec2)
 
         # Now do files, since they are. This should fail.
         file1 = file2 = nil
         path = tempfile()
-        assert_nothing_raised do
-            file1 = Puppet::Type.type(:file).create(
-                :title => "file1",
-                :path => path,
-                :content => "yayness"
-            )
-        end
-
-        # This will fail, but earlier systems will catch it.
-        assert_raise(Puppet::Error) do
-            file2 = Puppet::Type.type(:file).create(
-                :title => "file2",
-                :path => path,
-                :content => "rahness"
-            )
-        end
+        file1 = Puppet::Type.type(:file).new(
+            :title => "file1",
+            :path => path,
+            :content => "yayness"
+        )
+        catalog.add_resource(file1)
 
-        assert(file1, "Did not create first file")
-        assert_nil(file2, "Incorrectly created second file")
+        file2 = Puppet::Type.type(:file).new(
+            :title => "file2",
+            :path => path,
+            :content => "rahness"
+        )
+        assert_raise(ArgumentError) { catalog.add_resource(file2) }
     end
 
     def test_tags
-        obj = Puppet::Type.type(:file).create(:path => tempfile())
+        obj = Puppet::Type.type(:file).new(:path => tempfile())
 
-        tags = [:some, :test, :tags]
+        tags = ["some", "test", "tags"]
 
         obj.tags = tags
 
-        assert_equal(tags + [:file], obj.tags)
+        # tags can be stored in an unordered set, so we sort
+        # them for the assert_equal to work
+        assert_equal((tags << "file").sort, obj.tags.sort)
     end
 
     def disabled_test_list
@@ -654,20 +384,6 @@ class TestType < Test::Unit::TestCase
         end
     end
 
-    # Make sure that classes behave like hashes.
-    def test_class_hash_behaviour
-        path = tempfile()
-
-        filetype = Puppet::Type.type(:file)
-        one = Puppet::Type.newfile :path => path
-
-        assert_equal(one, filetype[path], "Did not get file back")
-
-        assert_raise(Puppet::Error) do
-            filetype[path] = one
-        end
-    end
-
     def test_ref
         path = tempfile()
         Puppet::Type.type(:exec) # uggh, the methods need to load the types
@@ -677,7 +393,7 @@ class TestType < Test::Unit::TestCase
         exec = Puppet::Type.newexec(:title => "yay", :command => "/bin/echo yay")
         assert_equal("Exec[yay]", exec.ref)
     end
-    
+
     def test_path
         config = mk_catalog
 
@@ -685,7 +401,7 @@ class TestType < Test::Unit::TestCase
         type = Puppet::Type.type(:exec)
         mk = Proc.new do |i, hash|
             hash[:title] = "exec%s" % i
-            hash[:command] = "/bin/echo"
+            hash[:command] = "/bin/echo %s" % i
             if parent = hash[:parent]
                 hash.delete(:parent)
             end
@@ -696,33 +412,33 @@ class TestType < Test::Unit::TestCase
             end
             res
         end
-        
+
         exec = mk.call(1, {})
-        
+
         assert_equal("/Exec[exec1]", exec.path)
-        
+
         comp = Puppet::Type.newcomponent :title => "My[component]", :type => "Yay"
         config.add_resource comp
-        
+
         exec = mk.call(2, :parent => comp)
-        
+
         assert_equal("/My[component]/Exec[exec2]", exec.path)
-        
+
         comp = Puppet::Type.newcomponent :name => "Other[thing]"
         config.add_resource comp
         exec = mk.call(3, :parent => comp)
         assert_equal("/Other[thing]/Exec[exec3]", exec.path)
-        
+
         comp = Puppet::Type.newcomponent :type => "server", :name => "server"
         config.add_resource comp
         exec = mk.call(4, :parent => comp)
         assert_equal("/server/Exec[exec4]", exec.path)
-        
+
         comp = Puppet::Type.newcomponent :type => "whatever", :name => "class[main]"
         config.add_resource comp
         exec = mk.call(5, :parent => comp)
         assert_equal("//Exec[exec5]", exec.path)
-        
+
         newcomp = Puppet::Type.newcomponent :type => "yay", :name => "Good[bad]"
         config.add_resource newcomp
         config.add_edge comp, newcomp
@@ -730,56 +446,45 @@ class TestType < Test::Unit::TestCase
         assert_equal("//Good[bad]/Exec[exec6]", exec.path)
     end
 
-    def test_evaluate
-        faketype = Puppet::Type.newtype(:faketype) do
-            newparam(:name) {}
-        end
-        cleanup { Puppet::Type.rmtype(:faketype) }
-        faketype.provide(:fake) do
-        end
-
-        obj = faketype.create :name => "yayness", :provider => :fake
-        assert(obj, "did not create object")
-
-        obj.expects(:retrieve)
-        obj.expects(:propertychanges).returns([])
-        obj.expects(:cache)
-
-        obj.evaluate
-    end
-
     # Partially test #704, but also cover the rest of the schedule management bases.
     def test_schedule
-        Puppet::Type.type(:schedule).create(:name => "maint")
+        schedule = Puppet::Type.type(:schedule).new(:name => "maint")
+        catalog = mk_catalog(schedule)
 
         {"maint" => true, nil => false, :fail => :fail}.each do |name, should|
             args = {:name => tempfile, :ensure => :file}
             if name
                 args[:schedule] = name
             end
-            resource = Puppet::Type.type(:file).create(args)
+            resource = Puppet::Type.type(:file).new(args)
+            catalog.add_resource(resource)
 
             if should == :fail
                 assert_raise(Puppet::Error, "Did not fail on missing schedule") do
                     resource.schedule
                 end
+            elsif should == false
+                assert_nil(resource.schedule, "Set the schedule tho it is set to nil")
             else
                 sched = nil
                 assert_nothing_raised("Failed when schedule was %s" % sched) do
                     sched = resource.schedule
                 end
 
+                assert(sched, "Did not find schedule %s" % sched.inspect)
+
                 if should
                     assert_equal(name, sched.name, "did not get correct schedule back")
                 end
             end
+            catalog.remove_resource(resource)
         end
     end
 
     # #801 -- resources only checked in noop should be rescheduled immediately.
     def test_reschedule_when_noop
         Puppet::Type.type(:schedule).mkdefaultschedules
-        file = Puppet::Type.type(:file).create(:path => "/tmp/whatever", :mode => "755", :noop => true, :schedule => :daily, :ensure => :file)
+        file = Puppet::Type.type(:file).new(:path => "/tmp/whatever", :mode => "755", :noop => true, :schedule => :daily, :ensure => :file)
 
         assert(file.noop?, "File not considered in noop")
         assert(file.scheduled?, "File is not considered scheduled")