Successfully modified all tests and code so that all language tests pass again. This is the majority of the work necessary to make the separate "configuration" object work.

9 files changed, 275 insertions, 290 deletions

diff --git a/test/language/ast.rb b/test/language/ast.rb
index 000a56a89..f62b2340c 100755
--- a/test/language/ast.rb
+++ b/test/language/ast.rb
@@ -119,7 +119,7 @@ class TestAST < Test::Unit::TestCase
 
         # Now try evaluating the node
         assert_nothing_raised do
-            mynode.evaluate :scope => scope
+            mynode.evaluate :scope => scope, :resource => scope.resource
         end
 
         # Make sure that we can find each of the files
@@ -136,7 +136,7 @@ class TestAST < Test::Unit::TestCase
 
         newscope = mkscope :parser => parser
         assert_nothing_raised do
-            child.evaluate :scope => newscope
+            child.evaluate :scope => newscope, :resource => scope.resource
         end
 
         assert(newscope.findresource("File[/tmp/base]"),
diff --git a/test/language/ast/definition.rb b/test/language/ast/definition.rb
index 51948b01f..7db5d2849 100755
--- a/test/language/ast/definition.rb
+++ b/test/language/ast/definition.rb
@@ -41,6 +41,7 @@ class TestASTDefinition < Test::Unit::TestCase
     def test_evaluate
         parser = mkparser
         config = mkconfig
+        config.send(:evaluate_main)
         scope = config.topscope
         klass = parser.newdefine "yayness",
             :arguments => [["owner", stringobj("nobody")], %w{mode}],
@@ -49,13 +50,16 @@ class TestASTDefinition < Test::Unit::TestCase
                         "owner" => varref("owner"), "mode" => varref("mode"))]
             )
 
-        resource = stub 'resource',
+        resource = Puppet::Parser::Resource.new(
             :title => "first",
-            :name => "first",
             :type => "yayness",
-            :to_hash => {"mode" => "755"},
             :exported => false,
-            :virtual => false 
+            :virtual => false,
+            :scope => scope,
+            :source => scope.source
+        )
+        resource.send(:set_parameter, "name", "first")
+        resource.send(:set_parameter, "mode", "755")
 
         resource.stubs(:title)
         assert_nothing_raised do
@@ -76,13 +80,17 @@ class TestASTDefinition < Test::Unit::TestCase
         end
 
         # Now create another with different args
-        resource2 = stub 'resource',
+        resource2 = Puppet::Parser::Resource.new(
             :title => "second",
-            :name => "second",
             :type => "yayness",
-            :to_hash => {"mode" => "755", "owner" => "daemon"},
             :exported => false,
-            :virtual => false 
+            :virtual => false,
+            :scope => scope,
+            :source => scope.source
+        )
+        resource2.send(:set_parameter, "name", "second")
+        resource2.send(:set_parameter, "mode", "755")
+        resource2.send(:set_parameter, "owner", "daemon")
 
         assert_nothing_raised do
             klass.evaluate(:scope => scope, :resource => resource2)
@@ -110,13 +118,14 @@ class TestASTDefinition < Test::Unit::TestCase
             # inside the loop so the subscope expectations work.
             klass = parser.newdefine "yayness%s" % i
 
-            resource = stub 'resource',
+            resource = Puppet::Parser::Resource.new(
                 :title => hash[:title],
-                :name => hash[:name] || hash[:title],
                 :type => "yayness%s" % i,
-                :to_hash => {},
                 :exported => false,
-                :virtual => false 
+                :virtual => false,
+                :scope => scope,
+                :source => scope.source
+            )
 
             subscope = klass.subscope(scope, resource)
 
diff --git a/test/language/ast/hostclass.rb b/test/language/ast/hostclass.rb
index c88152913..b53f6d5c0 100755
--- a/test/language/ast/hostclass.rb
+++ b/test/language/ast/hostclass.rb
@@ -27,13 +27,14 @@ class TestASTHostClass < Test::Unit::TestCase
                         "owner" => "nobody", "mode" => "755")]
             )
 
+        resource = Puppet::Parser::Resource.new(:type => "class", :title => "first", :scope => scope)
         assert_nothing_raised do
-            klass.evaluate(:scope => scope)
+            klass.evaluate(:scope => scope, :resource => resource)
         end
 
         # Then try it again
         assert_nothing_raised do
-            klass.evaluate(:scope => scope)
+            klass.evaluate(:scope => scope, :resource => resource)
         end
 
         assert(scope.compile.class_scope(klass), "Class was not considered evaluated")
@@ -69,11 +70,11 @@ class TestASTHostClass < Test::Unit::TestCase
             )
 
         assert_nothing_raised do
-            newsub.evaluate(:scope => scope)
+            newsub.evaluate(:scope => scope, :resource => resource)
         end
 
         assert_nothing_raised do
-            moresub.evaluate(:scope => scope)
+            moresub.evaluate(:scope => scope, :resource => resource)
         end
 
         assert(scope.compile.class_scope(newbase), "Did not eval newbase")
@@ -115,7 +116,7 @@ class TestASTHostClass < Test::Unit::TestCase
         assert_equal("funtest", define.namespace,
             "component namespace was not set in the definition")
 
-        newscope = klass.subscope(scope)
+        newscope = klass.subscope(scope, mock("resource"))
 
         assert_equal(["funtest"], newscope.namespaces,
             "Scope did not inherit namespace")
@@ -143,6 +144,7 @@ class TestASTHostClass < Test::Unit::TestCase
         assert_nothing_raised do
             ret = scope.compile.evaluate_classes(["sub"], scope)
         end
+        scope.compile.send(:evaluate_generators)
 
         subscope = scope.compile.class_scope(scope.findclass("sub"))
         assert(subscope, "could not find sub scope")
diff --git a/test/language/ast/resourceref.rb b/test/language/ast/resourceref.rb
index dd7e7037f..33a80ad40 100755
--- a/test/language/ast/resourceref.rb
+++ b/test/language/ast/resourceref.rb
@@ -44,7 +44,7 @@ class TestASTResourceRef < Test::Unit::TestCase
         @parser.newdefine "one"
         @parser.newdefine "one::two"
         @parser.newdefine "three"
-        twoscope = @scope.newscope(:type => "one", :namespace => "one")
+        twoscope = @scope.newscope(:namespace => "one")
         assert(twoscope.finddefine("two"), "Could not find 'two' definition")
         title = "title"
 
diff --git a/test/language/compile.rb b/test/language/compile.rb
index a4adcd963..0d9c9e32a 100755
--- a/test/language/compile.rb
+++ b/test/language/compile.rb
@@ -26,44 +26,46 @@ class TestCompile < Test::Unit::TestCase
         @parser = mock 'parser'
     end
 
-    def mkconfig(options = {})
+    def mkcompile(options = {})
         if node = options[:node]
             options.delete(:node)
         else
             node = mknode
         end
-        @config = Compile.new(node, mkparser, options)
+        @compile = Compile.new(node, mkparser, options)
     end
 
     def test_initialize
-        config = nil
-        assert_nothing_raised("Could not init config with all required options") do
-            config = Compile.new("foo", "parser")
+        compile = nil
+        node = stub 'node', :name => "foo"
+        parser = mock 'parser'
+        assert_nothing_raised("Could not init compile with all required options") do
+            compile = Compile.new(node, parser)
         end
 
-        assert_equal("foo", config.node, "Did not set node correctly")
-        assert_equal("parser", config.parser, "Did not set parser correctly")
+        assert_equal(node, compile.node, "Did not set node correctly")
+        assert_equal(parser, compile.parser, "Did not set parser correctly")
 
         # We're not testing here whether we call initvars, because it's too difficult to
         # mock.
 
         # Now try it with some options
-        assert_nothing_raised("Could not init config with extra options") do
-            config = Compile.new("foo", "parser", :ast_nodes => false)
+        assert_nothing_raised("Could not init compile with extra options") do
+            compile = Compile.new(node, parser, :ast_nodes => false)
         end
 
-        assert_equal(false, config.ast_nodes?, "Did not set ast_nodes? correctly")
+        assert_equal(false, compile.ast_nodes?, "Did not set ast_nodes? correctly")
     end
 
     def test_initvars
-        config = mkconfig
+        compile = mkcompile
         [:class_scopes, :resource_table, :exported_resources, :resource_overrides].each do |table|
-            assert_instance_of(Hash, config.send(:instance_variable_get, "@#{table}"), "Did not set %s table correctly" % table)
+            assert_instance_of(Hash, compile.send(:instance_variable_get, "@#{table}"), "Did not set %s table correctly" % table)
         end
-        assert_instance_of(Scope, config.topscope, "Did not create a topscope")
-        graph = config.instance_variable_get("@scope_graph")
+        assert_instance_of(Scope, compile.topscope, "Did not create a topscope")
+        graph = compile.instance_variable_get("@scope_graph")
         assert_instance_of(GRATR::Digraph, graph, "Did not create scope graph")
-        assert(graph.vertex?(config.topscope), "Did not add top scope as a vertex in the graph")
+        assert(graph.vertex?(compile.topscope), "Did not add top scope as a vertex in the graph")
     end
 
     # Make sure we store and can retrieve references to classes and their scopes.
@@ -71,134 +73,135 @@ class TestCompile < Test::Unit::TestCase
         klass = mock 'ast_class'
         klass.expects(:classname).returns("myname")
 
-        config = mkconfig
-        config.expects(:tag).with("myname")
+        compile = mkcompile
+        compile.configuration.expects(:tag).with("myname")
         
         assert_nothing_raised("Could not set class") do
-            config.class_set "myname", "myscope"
+            compile.class_set "myname", "myscope"
         end
         # First try to retrieve it by name.
-        assert_equal("myscope", config.class_scope("myname"), "Could not retrieve class scope by name")
+        assert_equal("myscope", compile.class_scope("myname"), "Could not retrieve class scope by name")
 
         # Then by object
-        assert_equal("myscope", config.class_scope(klass), "Could not retrieve class scope by object")
+        assert_equal("myscope", compile.class_scope(klass), "Could not retrieve class scope by object")
     end
     
     def test_classlist
-        config = mkconfig
+        compile = mkcompile
 
-        config.class_set "", "empty"
-        config.class_set "one", "yep"
-        config.class_set "two", "nope"
+        compile.class_set "", "empty"
+        compile.class_set "one", "yep"
+        compile.class_set "two", "nope"
 
         # Make sure our class list is correct
-        assert_equal(%w{one two}.sort, config.classlist.sort, "Did not get correct class list")
+        assert_equal(%w{one two}.sort, compile.classlist.sort, "Did not get correct class list")
     end
 
     # Make sure collections get added to our internal array
     def test_add_collection
-        config = mkconfig
+        compile = mkcompile
         assert_nothing_raised("Could not add collection") do
-            config.add_collection "nope"
+            compile.add_collection "nope"
         end
-        assert_equal(%w{nope}, config.instance_variable_get("@collections"), "Did not add collection")
+        assert_equal(%w{nope}, compile.instance_variable_get("@collections"), "Did not add collection")
     end
 
     # Make sure we create a graph of scopes.
     def test_newscope
-        config = mkconfig
-        graph = config.instance_variable_get("@scope_graph")
-        assert_instance_of(Scope, config.topscope, "Did not create top scope")
+        compile = mkcompile
+        graph = compile.instance_variable_get("@scope_graph")
+        assert_instance_of(Scope, compile.topscope, "Did not create top scope")
         assert_instance_of(GRATR::Digraph, graph, "Did not create graph")
 
-        assert(graph.vertex?(config.topscope), "The top scope is not a vertex in the graph")
+        assert(graph.vertex?(compile.topscope), "The top scope is not a vertex in the graph")
 
         # Now that we've got the top scope, create a new, subscope
         subscope = nil
         assert_nothing_raised("Could not create subscope") do
-            subscope = config.newscope(config.topscope)
+            subscope = compile.newscope(compile.topscope)
         end
         assert_instance_of(Scope, subscope, "Did not create subscope")
-        assert(graph.edge?(config.topscope, subscope), "An edge between top scope and subscope was not added")
+        assert(graph.edge?(compile.topscope, subscope), "An edge between top scope and subscope was not added")
 
         # Make sure a scope can find its parent.
-        assert(config.parent(subscope), "Could not look up parent scope on compile")
-        assert_equal(config.topscope.object_id, config.parent(subscope).object_id, "Did not get correct parent scope from compile")
-        assert_equal(config.topscope.object_id, subscope.parent.object_id, "Scope did not correctly retrieve its parent scope")
+        assert(compile.parent(subscope), "Could not look up parent scope on compile")
+        assert_equal(compile.topscope.object_id, compile.parent(subscope).object_id, "Did not get correct parent scope from compile")
+        assert_equal(compile.topscope.object_id, subscope.parent.object_id, "Scope did not correctly retrieve its parent scope")
 
         # Now create another, this time specifying options
         another = nil
         assert_nothing_raised("Could not create subscope") do
-            another = config.newscope(subscope, :name => "testing")
+            another = compile.newscope(subscope, :level => 5)
         end
-        assert_equal("testing", another.name, "did not set scope option correctly")
+        assert_equal(5, another.level, "did not set scope option correctly")
         assert_instance_of(Scope, another, "Did not create second subscope")
         assert(graph.edge?(subscope, another), "An edge between parent scope and second subscope was not added")
 
         # Make sure it can find its parent.
-        assert(config.parent(another), "Could not look up parent scope of second subscope on compile")
-        assert_equal(subscope.object_id, config.parent(another).object_id, "Did not get correct parent scope of second subscope from compile")
+        assert(compile.parent(another), "Could not look up parent scope of second subscope on compile")
+        assert_equal(subscope.object_id, compile.parent(another).object_id, "Did not get correct parent scope of second subscope from compile")
         assert_equal(subscope.object_id, another.parent.object_id, "Second subscope did not correctly retrieve its parent scope")
 
         # And make sure both scopes show up in the right order in the search path
-        assert_equal([another.object_id, subscope.object_id, config.topscope.object_id], another.scope_path.collect { |p| p.object_id },
+        assert_equal([another.object_id, subscope.object_id, compile.topscope.object_id], another.scope_path.collect { |p| p.object_id },
             "Did not get correct scope path")
     end
 
     # The heart of the action.
     def test_compile
-        config = mkconfig
+        compile = mkcompile
+        compile.instance_variable_get("@configuration").expects(:extract).returns(:config)
         [:set_node_parameters, :evaluate_main, :evaluate_ast_node, :evaluate_node_classes, :evaluate_generators, :fail_on_unevaluated, :finish].each do |method|
-            config.expects(method)
+            compile.expects(method)
         end
-        config.expects(:extract).returns(:config)
-        assert_equal(:config, config.compile, "Did not return the results of the extraction")
+        assert_equal(:config, compile.compile, "Did not return the results of the extraction")
     end
 
     # Test setting the node's parameters into the top scope.
     def test_set_node_parameters
-        config = mkconfig
+        compile = mkcompile
         @node.parameters = {"a" => "b", "c" => "d"}
-        scope = config.topscope
+        scope = compile.topscope
         @node.parameters.each do |param, value|
             scope.expects(:setvar).with(param, value)
         end
 
         assert_nothing_raised("Could not call 'set_node_parameters'") do
-            config.send(:set_node_parameters)
+            compile.send(:set_node_parameters)
         end
     end
 
     # Test that we can evaluate the main class, which is the one named "" in namespace
     # "".
     def test_evaluate_main
-        config = mkconfig
+        compile = mkcompile
         main = mock 'main_class'
-        config.topscope.expects(:source=).with(main)
-        main.expects(:safeevaluate).with(:scope => config.topscope, :nosubscope => true)
+        compile.topscope.expects(:source=).with(main)
         @parser.expects(:findclass).with("", "").returns(main)
 
         assert_nothing_raised("Could not call evaluate_main") do
-            config.send(:evaluate_main)
+            compile.send(:evaluate_main)
         end
+
+        assert(compile.resources.find { |r| r.to_s == "Class[main]" }, "Did not create a 'main' resource")
     end
 
     # Make sure we either don't look for nodes, or that we find and evaluate the right object.
     def test_evaluate_ast_node
         # First try it with ast_nodes disabled
-        config = mkconfig :ast_nodes => false
-        config.expects(:ast_nodes?).returns(false)
-        config.parser.expects(:nodes).never
+        compile = mkcompile :ast_nodes => false
+        compile.expects(:ast_nodes?).returns(false)
+        compile.parser.expects(:nodes).never
 
         assert_nothing_raised("Could not call evaluate_ast_node when ast nodes are disabled") do
-            config.send(:evaluate_ast_node)
+            compile.send(:evaluate_ast_node)
         end
 
         # Now try it with them enabled, but no node found.
         nodes = mock 'node_hash'
-        config = mkconfig :ast_nodes => true
-        config.expects(:ast_nodes?).returns(true)
-        config.parser.expects(:nodes).returns(nodes).times(4)
+        compile = mkcompile :ast_nodes => true
+        compile.expects(:ast_nodes?).returns(true)
+        compile.parser.expects(:nodes).returns(nodes).times(4)
 
         # Set some names for our test
         @node.names = %w{a b c}
@@ -211,17 +214,17 @@ class TestCompile < Test::Unit::TestCase
 
         # And make sure the lack of a node throws an exception
         assert_raise(Puppet::ParseError, "Did not fail when we couldn't find an ast node") do
-            config.send(:evaluate_ast_node)
+            compile.send(:evaluate_ast_node)
         end
 
         # Finally, make sure it works dandily when we have a node
         nodes = mock 'hash'
-        config = mkconfig :ast_nodes => true
-        config.expects(:ast_nodes?).returns(true)
-        config.parser.expects(:nodes).returns(nodes).times(3)
+        compile = mkcompile :ast_nodes => true
+        compile.expects(:ast_nodes?).returns(true)
+        compile.parser.expects(:nodes).returns(nodes).times(3)
 
         node = mock 'node'
-        node.expects(:safeevaluate).with(:scope => config.topscope)
+        node.expects(:safeevaluate).with(:scope => compile.topscope)
         # Set some names for our test
         @node.names = %w{a b c}
         nodes.expects(:[]).with("a").returns(nil)
@@ -231,17 +234,17 @@ class TestCompile < Test::Unit::TestCase
 
         # And make sure the lack of a node throws an exception
         assert_nothing_raised("Failed when a node was found") do
-            config.send(:evaluate_ast_node)
+            compile.send(:evaluate_ast_node)
         end
 
         # Lastly, check when we actually find the default.
         nodes = mock 'hash'
-        config = mkconfig :ast_nodes => true
-        config.expects(:ast_nodes?).returns(true)
-        config.parser.expects(:nodes).returns(nodes).times(4)
+        compile = mkcompile :ast_nodes => true
+        compile.expects(:ast_nodes?).returns(true)
+        compile.parser.expects(:nodes).returns(nodes).times(4)
 
         node = mock 'node'
-        node.expects(:safeevaluate).with(:scope => config.topscope)
+        node.expects(:safeevaluate).with(:scope => compile.topscope)
         # Set some names for our test
         @node.names = %w{a b c}
         nodes.expects(:[]).with("a").returns(nil)
@@ -251,59 +254,64 @@ class TestCompile < Test::Unit::TestCase
 
         # And make sure the lack of a node throws an exception
         assert_nothing_raised("Failed when a node was found") do
-            config.send(:evaluate_ast_node)
+            compile.send(:evaluate_ast_node)
         end
     end
 
     def test_evaluate_node_classes
-        config = mkconfig
+        compile = mkcompile
         @node.classes = %w{one two three four}
-        config.expects(:evaluate_classes).with(%w{one two three four}, config.topscope)
+        compile.expects(:evaluate_classes).with(%w{one two three four}, compile.topscope)
         assert_nothing_raised("could not call evaluate_node_classes") do
-            config.send(:evaluate_node_classes)
+            compile.send(:evaluate_node_classes)
         end
     end
 
     def test_evaluate_classes
-        config = mkconfig
+        compile = mkcompile
+        compile.parser.expects(:findclass).with("", "").returns(stub('main', :classname => ""))
+        compile.send :evaluate_main
         classes = {
-            "one" => mock('class one'),
-            "three" => mock('class three')
+            "one" => stub('class one', :classname => "one"),
+            "three" => stub('class three', :classname => "three")
         }
 
         classes.each do |name, obj|
-            config.parser.expects(:findclass).with("", name).returns(obj)
-            obj.expects(:safeevaluate).with(:scope => config.topscope)
+            compile.parser.expects(:findclass).with("", name).returns(obj)
         end
         %w{two four}.each do |name|
-            config.parser.expects(:findclass).with("", name).returns(nil)
+            compile.parser.expects(:findclass).with("", name).returns(nil)
         end
 
-        config.expects(:tag).with("two")
-        config.expects(:tag).with("four")
+        %w{one two three four}.each do |name|
+            compile.configuration.expects(:tag).with(name)
+        end
 
         result = nil
         assert_nothing_raised("could not call evaluate_node_classes") do
-            result = config.send(:evaluate_classes, %w{one two three four}, config.topscope)
+            result = compile.send(:evaluate_classes, %w{one two three four}, compile.topscope)
+        end
+        %w{one three}.each do |found|
+            assert(compile.resources.find { |r| r.to_s == "Class[#{found}]" }, "Did not create a class resource for %s" % found)
         end
         assert_equal(%w{one three}, result, "Did not return the list of evaluated classes")
     end
 
     def test_evaluate_collections
-        config = mkconfig
+        compile = mkcompile
 
         colls = []
 
         # Make sure we return false when there's nothing there.
-        assert(! config.send(:evaluate_collections), "Returned true when there were no collections")
+        assert(! compile.send(:evaluate_collections), "Returned true when there were no collections")
 
         # And when the collections fail to evaluate.
         colls << mock("coll1-false")
         colls << mock("coll2-false")
         colls.each { |c| c.expects(:evaluate).returns(false) }
 
-        config.instance_variable_set("@collections", colls)
-        assert(! config.send(:evaluate_collections), "Returned true when collections both evaluated nothing")
+        compile.instance_variable_set("@collections", colls)
+        assert(! compile.send(:evaluate_collections), "Returned true when collections both evaluated nothing")
 
         # Now have one of the colls evaluate
         colls.clear
@@ -311,7 +319,7 @@ class TestCompile < Test::Unit::TestCase
         colls << mock("coll2-one-true")
         colls[0].expects(:evaluate).returns(true)
         colls[1].expects(:evaluate).returns(false)
-        assert(config.send(:evaluate_collections), "Did not return true when one collection evaluated true")
+        assert(compile.send(:evaluate_collections), "Did not return true when one collection evaluated true")
 
         # And have them both eval true
         colls.clear
@@ -319,21 +327,21 @@ class TestCompile < Test::Unit::TestCase
         colls << mock("coll2-both-true")
         colls[0].expects(:evaluate).returns(true)
         colls[1].expects(:evaluate).returns(true)
-        assert(config.send(:evaluate_collections), "Did not return true when both collections evaluated true")
+        assert(compile.send(:evaluate_collections), "Did not return true when both collections evaluated true")
     end
 
     def test_unevaluated_resources
-        config = mkconfig
+        compile = mkcompile
         resources = {}
-        config.instance_variable_set("@resource_table", resources)
+        compile.instance_variable_set("@resource_table", resources)
 
         # First test it when the table is empty
-        assert_nil(config.send(:unevaluated_resources), "Somehow found unevaluated resources in an empty table")
+        assert_nil(compile.send(:unevaluated_resources), "Somehow found unevaluated resources in an empty table")
 
         # Then add a builtin resources
         resources["one"] = mock("builtin only")
         resources["one"].expects(:builtin?).returns(true)
-        assert_nil(config.send(:unevaluated_resources), "Considered a builtin resource unevaluated")
+        assert_nil(compile.send(:unevaluated_resources), "Considered a builtin resource unevaluated")
 
         # And do both builtin and non-builtin but already evaluated
         resources.clear
@@ -342,14 +350,14 @@ class TestCompile < Test::Unit::TestCase
         resources["two"] = mock("evaled (with builtin)")
         resources["two"].expects(:builtin?).returns(false)
         resources["two"].expects(:evaluated?).returns(true)
-        assert_nil(config.send(:unevaluated_resources), "Considered either a builtin or evaluated resource unevaluated")
+        assert_nil(compile.send(:unevaluated_resources), "Considered either a builtin or evaluated resource unevaluated")
 
         # Now a single unevaluated resource.
         resources.clear
         resources["one"] = mock("unevaluated")
         resources["one"].expects(:builtin?).returns(false)
         resources["one"].expects(:evaluated?).returns(false)
-        assert_equal([resources["one"]], config.send(:unevaluated_resources), "Did not find unevaluated resource")
+        assert_equal([resources["one"]], compile.send(:unevaluated_resources), "Did not find unevaluated resource")
 
         # With two uneval'ed resources, and an eval'ed one thrown in
         resources.clear
@@ -363,7 +371,7 @@ class TestCompile < Test::Unit::TestCase
         resources["three"].expects(:builtin?).returns(false)
         resources["three"].expects(:evaluated?).returns(true)
 
-        result = config.send(:unevaluated_resources)
+        result = compile.send(:unevaluated_resources)
         %w{one two}.each do |name|
             assert(result.include?(resources[name]), "Did not find %s in the unevaluated list" % name)
         end
@@ -371,11 +379,11 @@ class TestCompile < Test::Unit::TestCase
 
     def test_evaluate_definitions
         # First try the case where there's nothing to return
-        config = mkconfig
-        config.expects(:unevaluated_resources).returns(nil)
+        compile = mkcompile
+        compile.expects(:unevaluated_resources).returns(nil)
 
         assert_nothing_raised("Could not test for unevaluated resources") do
-            assert(! config.send(:evaluate_definitions), "evaluate_definitions returned true when no resources were evaluated")
+            assert(! compile.send(:evaluate_definitions), "evaluate_definitions returned true when no resources were evaluated")
         end
 
         # Now try it with resources left to evaluate
@@ -385,22 +393,22 @@ class TestCompile < Test::Unit::TestCase
         res2 = mock("resource2")
         res2.expects(:evaluate)
         resources << res1 << res2
-        config = mkconfig
-        config.expects(:unevaluated_resources).returns(resources)
+        compile = mkcompile
+        compile.expects(:unevaluated_resources).returns(resources)
 
         assert_nothing_raised("Could not test for unevaluated resources") do
-            assert(config.send(:evaluate_definitions), "evaluate_definitions returned false when resources were evaluated")
+            assert(compile.send(:evaluate_definitions), "evaluate_definitions returned false when resources were evaluated")
         end
     end
 
     def test_evaluate_generators
         # First try the case where we have nothing to do
-        config = mkconfig
-        config.expects(:evaluate_definitions).returns(false)
-        config.expects(:evaluate_collections).returns(false)
+        compile = mkcompile
+        compile.expects(:evaluate_definitions).returns(false)
+        compile.expects(:evaluate_collections).returns(false)
 
         assert_nothing_raised("Could not call :eval_iterate") do
-            config.send(:evaluate_generators)
+            compile.send(:evaluate_generators)
         end
 
         # FIXME I could not get this test to work, but the code is short
@@ -408,39 +416,39 @@ class TestCompile < Test::Unit::TestCase
         # It's important that collections are evaluated before definitions,
         # so make sure that's the case by verifying that collections get tested
         # twice but definitions only once.
-        #config = mkconfig
-        #config.expects(:evaluate_collections).returns(true).returns(false)
-        #config.expects(:evaluate_definitions).returns(false)
-        #config.send(:eval_iterate)
+        #compile = mkcompile
+        #compile.expects(:evaluate_collections).returns(true).returns(false)
+        #compile.expects(:evaluate_definitions).returns(false)
+        #compile.send(:eval_iterate)
     end
 
     def test_store
-        config = mkconfig
+        compile = mkcompile
         Puppet.features.expects(:rails?).returns(true)
         Puppet::Rails.expects(:connect)
 
         node = mock 'node'
         resource_table = mock 'resources'
         resource_table.expects(:values).returns(:resources)
-        config.instance_variable_set("@node", node)
-        config.instance_variable_set("@resource_table", resource_table)
-        config.expects(:store_to_active_record).with(node, :resources)
-        config.send(:store)
+        compile.instance_variable_set("@node", node)
+        compile.instance_variable_set("@resource_table", resource_table)
+        compile.expects(:store_to_active_record).with(node, :resources)
+        compile.send(:store)
     end
 
     def test_store_to_active_record
-        config = mkconfig
+        compile = mkcompile
         node = mock 'node'
         node.expects(:name).returns("myname")
         Puppet::Rails::Host.stubs(:transaction).yields
         Puppet::Rails::Host.expects(:store).with(node, :resources)
-        config.send(:store_to_active_record, node, :resources)
+        compile.send(:store_to_active_record, node, :resources)
     end
 
     # Make sure that 'finish' gets called on all of our resources.
     def test_finish
-        config = mkconfig
-        table = config.instance_variable_get("@resource_table")
+        compile = mkcompile
+        table = compile.instance_variable_get("@resource_table")
 
         # Add a resource that does respond to :finish
         yep = mock("finisher")
@@ -453,17 +461,17 @@ class TestCompile < Test::Unit::TestCase
         dnf.expects(:respond_to?).with(:finish).returns(false)
         table["dnf"] = dnf
 
-        config.send(:finish)
+        compile.send(:finish)
     end
 
     def test_verify_uniqueness
-        config = mkconfig
+        compile = mkcompile
 
-        resources = config.instance_variable_get("@resource_table")
+        resources = compile.instance_variable_get("@resource_table")
         resource = mock("noconflict")
         resource.expects(:ref).returns("File[yay]")
         assert_nothing_raised("Raised an exception when there should have been no conflict") do
-            config.send(:verify_uniqueness, resource)
+            compile.send(:verify_uniqueness, resource)
         end
 
         # Now try the case where our type is isomorphic
@@ -477,7 +485,7 @@ class TestCompile < Test::Unit::TestCase
         faketype.expects(:name).returns("whatever")
         Puppet::Type.expects(:type).with("testtype").returns(faketype)
         assert_nothing_raised("Raised an exception when was a conflict in non-isomorphic types") do
-            config.send(:verify_uniqueness, isoconflict)
+            compile.send(:verify_uniqueness, isoconflict)
         end
 
         # Now test for when we actually have an exception
@@ -495,63 +503,62 @@ class TestCompile < Test::Unit::TestCase
         faketype.expects(:isomorphic?).returns(true)
         Puppet::Type.expects(:type).with("conflict").returns(faketype)
         assert_raise(Puppet::ParseError, "Did not fail when two isomorphic resources conflicted") do
-            config.send(:verify_uniqueness, conflict)
+            compile.send(:verify_uniqueness, conflict)
         end
     end
 
     def test_store_resource
         # Run once when there's no conflict
-        config = mkconfig
-        table = config.instance_variable_get("@resource_table")
+        compile = mkcompile
+        table = compile.instance_variable_get("@resource_table")
         resource = mock("resource")
         resource.expects(:ref).returns("yay")
-        config.expects(:verify_uniqueness).with(resource)
-        scope = mock("scope")
+        compile.expects(:verify_uniqueness).with(resource)
+        scope = stub("scope", :resource => mock('resource'))
 
-        graph = config.instance_variable_get("@resource_graph")
-        graph.expects(:add_edge!).with(scope, resource)
+        compile.configuration.expects(:add_edge!).with(scope.resource, resource)
 
         assert_nothing_raised("Could not store resource") do
-            config.store_resource(scope, resource)
+            compile.store_resource(scope, resource)
         end
         assert_equal(resource, table["yay"], "Did not store resource in table")
 
         # Now for conflicts
-        config = mkconfig
-        table = config.instance_variable_get("@resource_table")
+        compile = mkcompile
+        table = compile.instance_variable_get("@resource_table")
         resource = mock("resource")
-        config.expects(:verify_uniqueness).with(resource).raises(ArgumentError)
+        compile.expects(:verify_uniqueness).with(resource).raises(ArgumentError)
 
         assert_raise(ArgumentError, "Did not raise uniqueness exception") do
-            config.store_resource(scope, resource)
+            compile.store_resource(scope, resource)
         end
         assert(table.empty?, "Conflicting resource was stored in table")
     end
 
     def test_fail_on_unevaluated
-        config = mkconfig
-        config.expects(:fail_on_unevaluated_overrides)
-        config.expects(:fail_on_unevaluated_resource_collections)
-        config.send :fail_on_unevaluated
+        compile = mkcompile
+        compile.expects(:fail_on_unevaluated_overrides)
+        compile.expects(:fail_on_unevaluated_resource_collections)
+        compile.send :fail_on_unevaluated
     end
 
     def test_store_override
         # First test the case when the resource is not present.
-        config = mkconfig
-        overrides = config.instance_variable_get("@resource_overrides")
+        compile = mkcompile
+        overrides = compile.instance_variable_get("@resource_overrides")
         override = Object.new
         override.expects(:ref).returns(:myref).times(2)
         override.expects(:override=).with(true)
 
         assert_nothing_raised("Could not call store_override") do
-            config.store_override(override)
+            compile.store_override(override)
         end
         assert_instance_of(Array, overrides[:myref], "Overrides table is not a hash of arrays")
         assert_equal(override, overrides[:myref][0], "Did not store override in appropriately named array")
 
         # And when the resource already exists.
         resource = mock 'resource'
-        resources = config.instance_variable_get("@resource_table")
+        resources = compile.instance_variable_get("@resource_table")
         resources[:resref] = resource
 
         override = mock 'override'
@@ -559,34 +566,34 @@ class TestCompile < Test::Unit::TestCase
         override.expects(:override=).with(true)
         override.expects(:ref).returns(:resref)
         assert_nothing_raised("Could not call store_override when the resource already exists.") do
-            config.store_override(override)
+            compile.store_override(override)
         end
     end
 
     def test_resource_overrides
-        config = mkconfig
-        overrides = config.instance_variable_get("@resource_overrides")
+        compile = mkcompile
+        overrides = compile.instance_variable_get("@resource_overrides")
         overrides[:test] = :yay
         resource = mock 'resource'
         resource.expects(:ref).returns(:test)
 
-        assert_equal(:yay, config.resource_overrides(resource), "Did not return overrides from table")
+        assert_equal(:yay, compile.resource_overrides(resource), "Did not return overrides from table")
     end
 
     def test_fail_on_unevaluated_resource_collections
-        config = mkconfig
-        collections = config.instance_variable_get("@collections")
+        compile = mkcompile
+        collections = compile.instance_variable_get("@collections")
 
         # Make sure we're fine when the list is empty
         assert_nothing_raised("Failed when no collections were present") do
-            config.send :fail_on_unevaluated_resource_collections
+            compile.send :fail_on_unevaluated_resource_collections
         end
 
         # And that we're fine when we've got collections but with no resources
         collections << mock('coll')
         collections[0].expects(:resources).returns(nil)
         assert_nothing_raised("Failed when no resource collections were present") do
-            config.send :fail_on_unevaluated_resource_collections
+            compile.send :fail_on_unevaluated_resource_collections
         end
 
         # But that we do fail when we've got resource collections left.
@@ -600,17 +607,17 @@ class TestCompile < Test::Unit::TestCase
         collections[1].expects(:resources).returns([:one, :two])
 
         assert_raise(Puppet::ParseError, "Did not fail on unevaluated resource collections") do
-            config.send :fail_on_unevaluated_resource_collections
+            compile.send :fail_on_unevaluated_resource_collections
         end
     end
 
     def test_fail_on_unevaluated_overrides
-        config = mkconfig
-        overrides = config.instance_variable_get("@resource_overrides")
+        compile = mkcompile
+        overrides = compile.instance_variable_get("@resource_overrides")
 
         # Make sure we're fine when the list is empty
         assert_nothing_raised("Failed when no collections were present") do
-            config.send :fail_on_unevaluated_overrides
+            compile.send :fail_on_unevaluated_overrides
         end
 
         # But that we fail if there are any overrides left in the table.
@@ -619,44 +626,44 @@ class TestCompile < Test::Unit::TestCase
         overrides[:bar] = [mock("override")]
         overrides[:bar][0].expects(:ref).returns("yay")
         assert_raise(Puppet::ParseError, "Failed to fail when overrides remain") do
-            config.send :fail_on_unevaluated_overrides
+            compile.send :fail_on_unevaluated_overrides
         end
     end
 
     def test_find_resource
-        config = mkconfig
-        resources = config.instance_variable_get("@resource_table")
+        compile = mkcompile
+        resources = compile.instance_variable_get("@resource_table")
 
         assert_nothing_raised("Could not call findresource when the resource table was empty") do
-            assert_nil(config.findresource("yay", "foo"), "Returned a non-existent resource")
-            assert_nil(config.findresource("yay[foo]"), "Returned a non-existent resource")
+            assert_nil(compile.findresource("yay", "foo"), "Returned a non-existent resource")
+            assert_nil(compile.findresource("yay[foo]"), "Returned a non-existent resource")
         end
 
         resources["Foo[bar]"] = :yay
         assert_nothing_raised("Could not call findresource when the resource table was not empty") do
-            assert_equal(:yay, config.findresource("foo", "bar"), "Returned a non-existent resource")
-            assert_equal(:yay, config.findresource("Foo[bar]"), "Returned a non-existent resource")
+            assert_equal(:yay, compile.findresource("foo", "bar"), "Returned a non-existent resource")
+            assert_equal(:yay, compile.findresource("Foo[bar]"), "Returned a non-existent resource")
         end
     end
 
     # #620 - Nodes and classes should conflict, else classes don't get evaluated
     def test_nodes_and_classes_name_conflict
         # Test node then class
-        config = mkconfig
+        compile = mkcompile
         node = stub :nodescope? => true
         klass = stub :nodescope? => false
-        config.class_set("one", node)
+        compile.class_set("one", node)
         assert_raise(Puppet::ParseError, "Did not fail when replacing node with class") do
-            config.class_set("one", klass)
+            compile.class_set("one", klass)
         end
 
         # and class then node
-        config = mkconfig
+        compile = mkcompile
         node = stub :nodescope? => true
         klass = stub :nodescope? => false
-        config.class_set("two", klass)
+        compile.class_set("two", klass)
         assert_raise(Puppet::ParseError, "Did not fail when replacing node with class") do
-            config.class_set("two", node)
+            compile.class_set("two", node)
         end
     end
 end
diff --git a/test/language/functions.rb b/test/language/functions.rb
index 6cea89066..efa506218 100755
--- a/test/language/functions.rb
+++ b/test/language/functions.rb
@@ -49,9 +49,10 @@ class TestLangFunctions < Test::Unit::TestCase
 
     def test_taggedfunction
         scope = mkscope
+        tags = []
+        scope.resource.stubs(:tags).returns(tags)
 
-        tag = "yayness"
-        scope.tag(tag)
+        tags << "yayness"
 
         {"yayness" => true, "booness" => false}.each do |tag, retval|
             func = taggedobj(tag, :rvalue)
@@ -318,7 +319,7 @@ class TestLangFunctions < Test::Unit::TestCase
         [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
             # Make a virtual resource
             virtual = mkresource(:type => type, :title => title,
-                :virtual => true, :params => {})
+                :virtual => true, :params => {}, :scope => scope)
         
             scope.compile.store_resource(scope, virtual)
 
@@ -434,7 +435,7 @@ class TestLangFunctions < Test::Unit::TestCase
             scope.function_include "myclass"
         end
 
-        assert(scope.compile.classlist.include?("myclass"),
+        assert(scope.compile.resources.find { |r| r.to_s == "Class[myclass]" }, 
             "class was not evaluated")
 
         # Now try multiple classes at once
@@ -445,7 +446,7 @@ class TestLangFunctions < Test::Unit::TestCase
         end
 
         classes.each do |c|
-            assert(scope.compile.classlist.include?(c),
+            assert(scope.compile.resources.find { |r| r.to_s == "Class[#{c}]" },
                 "class %s was not evaluated" % c)
         end
 
diff --git a/test/language/parser.rb b/test/language/parser.rb
index 0406e99ba..36e058b11 100755
--- a/test/language/parser.rb
+++ b/test/language/parser.rb
@@ -497,7 +497,7 @@ file { "/tmp/yayness":
             scope.source = klass
 
             assert_nothing_raised do
-                ret.classes[""].evaluate :scope => scope
+                ret.classes[""].evaluate :scope => scope, :resource => Puppet::Parser::Resource.new(:type => "mydefine", :title => 'whatever', :scope => scope, :source => scope.source)
             end
 
             # Make sure we can find both of them
diff --git a/test/language/resource.rb b/test/language/resource.rb
index f594691c6..8978a3a37 100755
--- a/test/language/resource.rb
+++ b/test/language/resource.rb
@@ -25,7 +25,7 @@ class TestResource < PuppetTest::TestCase
 
     def test_initialize
         args = {:type => "resource", :title => "testing",
-            :source => "source", :scope => "scope"}
+            :scope => mkscope}
         # Check our arg requirements
         args.each do |name, value|
             try = args.dup
@@ -35,12 +35,14 @@ class TestResource < PuppetTest::TestCase
             end
         end
 
-        Reference.expects(:new).with(:type => "resource", :title => "testing", :scope => "scope").returns(:ref)
-
         res = nil
         assert_nothing_raised do
             res = Parser::Resource.new(args)
         end
+
+        ref = res.instance_variable_get("@ref")
+        assert_equal("resource", ref.type, "did not set resource type")
+        assert_equal("testing", ref.title, "did not set resource title")
     end
 
     def test_merge
@@ -213,8 +215,8 @@ class TestResource < PuppetTest::TestCase
         # First try translating a builtin resource.  Make sure we use some references
         # and arrays, to make sure they translate correctly.
         source = mock("source")
-        scope = mock("scope")
-        scope.expects(:tags).returns([])
+        scope = mkscope
+        scope.stubs(:tags).returns([])
         refs = []
         4.times { |i| refs << Puppet::Parser::Resource::Reference.new(:title => "file%s" % i, :type => "file") }
         res = Parser::Resource.new :type => "file", :title => "/tmp",
@@ -245,16 +247,15 @@ class TestResource < PuppetTest::TestCase
     # FIXME This isn't a great test, but I need to move on.
     def test_to_transbucket
         bucket = mock("transbucket")
-        Puppet::TransBucket.expects(:new).with([]).returns(bucket)
         source = mock("source")
-        scope = mock("scope")
+        scope = mkscope
         res = Parser::Resource.new :type => "mydefine", :title => "yay",
             :source => source, :scope => scope
 
-        bucket.expects(:name=).with("yay")
-        bucket.expects(:type=).with("mydefine")
 
-        assert_equal(bucket, res.to_trans, "Resource did not return the bucket")
+        result = res.to_trans
+        assert_equal("yay", result.name, "did not set bucket name correctly")
+        assert_equal("mydefine", result.type, "did not set bucket type correctly")
     end
 
     def test_evaluate
@@ -309,7 +310,7 @@ class TestResource < PuppetTest::TestCase
 
     def test_proxymethods
         res = Parser::Resource.new :type => "evaltest", :title => "yay",
-            :source => mock("source"), :scope => mock('scope')
+            :source => mock("source"), :scope => mkscope
 
         assert_equal("evaltest", res.type)
         assert_equal("yay", res.title)
@@ -337,7 +338,7 @@ class TestResource < PuppetTest::TestCase
         # Now create an obj that uses it
         res = mkresource :type => "file", :title => "/tmp/resource",
             :params => {:require => ref}
-        res.scope = stub(:tags => [])
+        res.scope = mkscope
 
         trans = nil
         assert_nothing_raised do
@@ -351,7 +352,7 @@ class TestResource < PuppetTest::TestCase
         two = Parser::Resource::Reference.new(:type => "file", :title => "/tmp/ref2")
         res = mkresource :type => "file", :title => "/tmp/resource2",
             :params => {:require => [ref, two]}
-        res.scope = stub(:tags => [])
+        res.scope = mkscope
 
         trans = nil
         assert_nothing_raised do
@@ -420,7 +421,7 @@ class TestResource < PuppetTest::TestCase
     # part of #629 -- the undef keyword.  Make sure 'undef' params get skipped.
     def test_undef_and_to_hash
         res = mkresource :type => "file", :title => "/tmp/testing",
-            :source => mock("source"), :scope => mock("scope"),
+            :source => mock("source"), :scope => mkscope,
             :params => {:owner => :undef, :mode => "755"}
 
         hash = nil
@@ -470,6 +471,37 @@ class TestResource < PuppetTest::TestCase
         assert(newres.exported?, "Exported defined resource generated non-exported resources")
         assert(newres.virtual?, "Exported defined resource generated non-virtual resources")
     end
-end
 
-# $Id$
+    # Make sure tags behave appropriately.
+    def test_tags
+        scope_resource = stub 'scope_resource', :tags => %w{srone srtwo}
+        scope = stub 'scope', :resource => scope_resource
+        resource = Puppet::Parser::Resource.new(:type => "file", :title => "yay", :scope => scope, :source => mock('source'))
+
+        # Make sure we get the scope resource's tags, plus the type and title
+        %w{srone srtwo yay file}.each do |tag|
+            assert(resource.tags.include?(tag), "Did not tag resource with %s" % tag)
+        end
+
+        # make sure we can only set legal tags
+        ["an invalid tag", "-anotherinvalid", "bad*tag"].each do |tag|
+            assert_raise(Puppet::ParseError, "Tag #{tag} was considered valid") do
+                resource.tag tag
+            end
+        end
+
+        # make sure good tags make it through.
+        tags = %w{good-tag yaytag GoodTag another_tag a ab A}
+        tags.each do |tag|
+            assert_nothing_raised("Tag #{tag} was considered invalid") do
+                resource.tag tag
+            end
+        end
+
+        # make sure we get each of them.
+        ptags = resource.tags
+        tags.each do |tag|
+            assert(ptags.include?(tag), "missing #{tag}")
+        end
+    end
+end
diff --git a/test/language/scope.rb b/test/language/scope.rb
index 66bc632bf..213226241 100755
--- a/test/language/scope.rb
+++ b/test/language/scope.rb
@@ -93,7 +93,7 @@ class TestScope < Test::Unit::TestCase
         scopes = {}
         classes = ["", "one", "one::two", "one::two::three"].each do |name|
             klass = parser.newclass(name)
-            klass.evaluate(:scope => scope)
+            Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
             scopes[name] = scope.compile.class_scope(klass)
         end
 
@@ -194,16 +194,8 @@ class TestScope < Test::Unit::TestCase
         parser = mkparser
         klass = parser.newclass("")
         scope = mkscope(:parser => parser)
-        klass.evaluate(:scope => scope)
+        Puppet::Parser::Resource.new(:type => "class", :title => :main, :scope => scope, :source => mock('source')).evaluate
 
-        klass = parser.newclass("one")
-        klass.evaluate(:scope => scope)
-
-        klass = parser.newclass("one::two")
-        klass.evaluate(:scope => scope)
-
-
-        scope = scope.compile.class_scope("")
         assert_nothing_raised {
             scope.setvar("test","value")
         }
@@ -212,7 +204,7 @@ class TestScope < Test::Unit::TestCase
 
         %w{one one::two one::two::three}.each do |name|
             klass = parser.newclass(name)
-            klass.evaluate(:scope => scope)
+            Puppet::Parser::Resource.new(:type => "class", :title => name, :scope => scope, :source => mock('source')).evaluate
             scopes[name] = scope.compile.class_scope(klass)
             scopes[name].setvar("test", "value-%s" % name.sub(/.+::/,''))
         end
@@ -267,41 +259,13 @@ class TestScope < Test::Unit::TestCase
         end
     end
 
-    def test_validtags
-        scope = mkscope()
-
-        ["a class", "a.class"].each do |bad|
-            assert_raise(Puppet::ParseError, "Incorrectly allowed %s" % bad.inspect) do
-                scope.tag(bad)
-            end
-        end
-
-        ["a-class", "a_class", "Class", "class", "yayNess"].each do |good|
-            assert_nothing_raised("Incorrectly banned %s" % good.inspect) do
-                scope.tag(good)
-            end
-        end
-
-    end
-
     def test_tagfunction
         scope = mkscope
-        
-        assert_nothing_raised {
-            scope.function_tag(["yayness", "booness"])
-        }
-
-        assert(scope.tags.include?("yayness"), "tag 'yayness' did not get set")
-        assert(scope.tags.include?("booness"), "tag 'booness' did not get set")
+        resource = mock 'resource'
+        scope.resource = resource
+        resource.expects(:tag).with("yayness", "booness")
 
-        # Now verify that the 'tagged' function works correctly
-        assert(scope.function_tagged("yayness"),
-            "tagged function incorrectly returned false")
-        assert(scope.function_tagged("booness"),
-            "tagged function incorrectly returned false")
-
-        assert(! scope.function_tagged("funtest"),
-            "tagged function incorrectly returned true")
+        scope.function_tag(%w{yayness booness})
     end
 
     def test_includefunction
@@ -323,6 +287,8 @@ class TestScope < Test::Unit::TestCase
             function.evaluate :scope => scope
         end
 
+        scope.compile.send(:evaluate_generators)
+
         [myclass, otherclass].each do |klass|
             assert(scope.compile.class_scope(klass),
                 "%s was not set" % klass.classname)
@@ -372,6 +338,10 @@ class TestScope < Test::Unit::TestCase
         # Create a default source
         config.topscope.source = parser.newclass "", ""
 
+        # And a scope resource
+        scope_res = stub 'scope_resource', :virtual? => true, :exported? => false, :tags => []
+        config.topscope.resource = scope_res
+
         args = AST::ASTArray.new(
             :file => tempfile(),
             :line => rand(100),
@@ -470,42 +440,6 @@ Host <<||>>"
         $stderr.puts "No ActiveRecord -- skipping collection tests"
     end
 
-    # Make sure tags behave appropriately.
-    def test_tags
-        parser, scope, source = mkclassframing
-
-        # First make sure we can only set legal tags
-        ["an invalid tag", "-anotherinvalid", "bad*tag"].each do |tag|
-            assert_raise(Puppet::ParseError, "Tag #{tag} was considered valid") do
-                scope.tag tag
-            end
-        end
-
-        # Now make sure good tags make it through.
-        tags = %w{good-tag yaytag GoodTag another_tag a ab A}
-        tags.each do |tag|
-            assert_nothing_raised("Tag #{tag} was considered invalid") do
-                scope.tag tag
-            end
-        end
-
-        # And make sure we get each of them.
-        ptags = scope.tags
-        tags.each do |tag|
-            assert(ptags.include?(tag), "missing #{tag}")
-        end
-
-
-        # Now create a subscope and set some tags there
-        newscope = scope.newscope(:type => 'subscope')
-
-        # set some tags
-        newscope.tag "onemore", "yaytag"
-
-        # And make sure we get them plus our parent tags
-        assert_equal((ptags + %w{onemore subscope}).sort, newscope.tags.sort)
-    end
-
     def test_namespaces
         parser, scope, source = mkclassframing