puppet 0.24.9 → 0.25.0

data/test/language/ast.rb

@@ -15,6 +15,7 @@ class TestAST < Test::Unit::TestCase
     include PuppetTest::Support::Collection
 
     def test_if
+        scope = mkscope
         astif = nil
         astelse = nil
         fakeelse = FakeAST.new(:else)
@@ -35,14 +36,14 @@ class TestAST < Test::Unit::TestCase
         # We initialized it to true, so we should get that first
         ret = nil
         assert_nothing_raised {
-            ret = astif.evaluate("yay")
+            ret = astif.evaluate(scope)
         }
         assert_equal(:if, ret)
 
         # Now set it to false and check that
         faketest.evaluate = false
         assert_nothing_raised {
-            ret = astif.evaluate("yay")
+            ret = astif.evaluate(scope)
         }
         assert_equal(:else, ret)
     end

data/test/language/ast/casestatement.rb

@@ -9,21 +9,21 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestCaseStatement < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-	AST = Puppet::Parser::AST
-	
-	class ActiveAST < FakeAST
-	    def self.clear
-	        $evaluated = []
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    AST = Puppet::Parser::AST
+
+    class ActiveAST < FakeAST
+        def self.clear
+            $evaluated = []
         end
-	    def evaluate
-	        $evaluated ||= []
-	        $evaluated << @evaluate
+        def evaluate
+            $evaluated ||= []
+            $evaluated << @evaluate
         end
     end
-	
-	def test_evaluate
+
+    def test_evaluate
         ast = nil
         scope = mkscope
         param = nameobj("MyParam")

data/test/language/ast/resource.rb

@@ -9,9 +9,9 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestASTResource< Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-	AST = Puppet::Parser::AST
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    AST = Puppet::Parser::AST
 
     def setup
         super
@@ -31,7 +31,7 @@ class TestASTResource< Test::Unit::TestCase
         @parser.newdefine "three"
         twoscope = @scope.newscope(:namespace => "one")
         twoscope.resource = @scope.resource
-        assert(twoscope.finddefine("two"), "Could not find 'two' definition")
+        assert(twoscope.find_definition("two"), "Could not find 'two' definition")
         title = "title"
 
         # First try a qualified type

data/test/language/ast/resource_reference.rb

@@ -9,10 +9,10 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestASTResourceReference < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-	AST = Puppet::Parser::AST
-    
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    AST = Puppet::Parser::AST
+
     def newref(type, title)
         AST::ResourceReference.new(:type => type, :title => AST::String.new(:value => title))
     end
@@ -29,7 +29,7 @@ class TestASTResourceReference < Test::Unit::TestCase
         @parser.newdefine "one::two"
         @parser.newdefine "three"
         twoscope = @scope.newscope(:namespace => "one")
-        assert(twoscope.finddefine("two"), "Could not find 'two' definition")
+        assert(twoscope.find_definition("two"), "Could not find 'two' definition")
         title = "title"
 
         # First try a qualified type

data/test/language/ast/selector.rb

@@ -9,29 +9,29 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestSelector < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-	AST = Puppet::Parser::AST
-    
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    AST = Puppet::Parser::AST
+
     def test_evaluate
         scope = mkscope
         upperparam = nameobj("MYPARAM")
         lowerparam = nameobj("myparam")
-        
+
         should = {"MYPARAM" => "upper", "myparam" => "lower"}
-        
+
         maker = Proc.new do
             {
             :default => AST::ResourceParam.new(:param => AST::Default.new(:value => "default"), :value => FakeAST.new("default")),
             :lower => AST::ResourceParam.new(:param => FakeAST.new("myparam"), :value => FakeAST.new("lower")),
             :upper => AST::ResourceParam.new(:param => FakeAST.new("MYPARAM"), :value => FakeAST.new("upper")),
             }
-            
+
         end
-        
+
         # Start out case-sensitive
         Puppet[:casesensitive] = true
-        
+
         %w{MYPARAM myparam}.each do |str|
             param = nameobj(str)
             params = maker.call()
@@ -40,10 +40,10 @@ class TestSelector < Test::Unit::TestCase
             assert_nothing_raised { result = sel.evaluate(scope) }
             assert_equal(should[str], result, "did not case-sensitively match %s" % str)
         end
-        
+
         # then insensitive
         Puppet[:casesensitive] = false
-        
+
         %w{MYPARAM myparam}.each do |str|
             param = nameobj(str)
             params = maker.call()

data/test/language/ast/variable.rb

@@ -9,10 +9,10 @@ require 'puppettest'
 require 'puppettest/parsertesting'
 
 class TestVariable < Test::Unit::TestCase
-	include PuppetTest
-	include PuppetTest::ParserTesting
-	AST = Puppet::Parser::AST
-    
+    include PuppetTest
+    include PuppetTest::ParserTesting
+    AST = Puppet::Parser::AST
+
     def setup
         super
         @interp = mkinterp

data/test/language/functions.rb

@@ -359,8 +359,8 @@ class TestLangFunctions < Test::Unit::TestCase
     end
 
     def test_autoloading_functions
-        assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
-            "Got told autofunc already exists")
+        #assert_equal(false, Puppet::Parser::Functions.function(:autofunc),
+        #    "Got told autofunc already exists")
 
         dir = tempfile()
         $: << dir
@@ -388,17 +388,17 @@ class TestLangFunctions < Test::Unit::TestCase
     def test_realize
         scope = mkscope
         parser = scope.compiler.parser
-    
+
         realize = Puppet::Parser::Functions.function(:realize)
 
         # Make a definition
         parser.newdefine("mytype")
-        
+
         [%w{file /tmp/virtual}, %w{mytype yay}].each do |type, title|
             # Make a virtual resource
             virtual = mkresource(:type => type, :title => title,
                 :virtual => true, :params => {}, :scope => scope)
-        
+
             scope.compiler.add_resource(scope, virtual)
 
             ref = Puppet::Parser::Resource::Reference.new(
@@ -442,39 +442,39 @@ class TestLangFunctions < Test::Unit::TestCase
         assert_equal([none.to_s], scope.compiler.collections[0].resources,
             "Did not set resources in collection")
     end
-    
+
     def test_defined
         scope = mkscope
         parser = scope.compiler.parser
 
         defined = Puppet::Parser::Functions.function(:defined)
-        
+
         parser.newclass("yayness")
         parser.newdefine("rahness")
-        
+
         assert_nothing_raised do
             assert(scope.function_defined("yayness"), "yayness class was not considered defined")
             assert(scope.function_defined("rahness"), "rahness definition was not considered defined")
             assert(scope.function_defined("service"), "service type was not considered defined")
             assert(! scope.function_defined("fakness"), "fakeness was considered defined")
         end
-        
+
         # Now make sure any match in a list will work
         assert(scope.function_defined(["booness", "yayness", "fakeness"]),
             "A single answer was not sufficient to return true")
-        
+
         # and make sure multiple falses are still false
         assert(! scope.function_defined(%w{no otherno stillno}),
             "Multiple falses were somehow true")
-        
+
         # Now make sure we can test resources
         scope.compiler.add_resource(scope, mkresource(:type => "file", :title => "/tmp/rahness",
             :scope => scope, :source => scope.source,
             :params => {:owner => "root"}))
-        
+
         yep = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/rahness")
         nope = Puppet::Parser::Resource::Reference.new(:type => "file", :title => "/tmp/fooness")
-        
+
         assert(scope.function_defined([yep]), "valid resource was not considered defined")
         assert(! scope.function_defined([nope]), "invalid resource was considered defined")
     end
@@ -482,7 +482,7 @@ class TestLangFunctions < Test::Unit::TestCase
     def test_search
         parser = mkparser
         scope = mkscope(:parser => parser)
-        
+
         fun = parser.newdefine("yay::ness")
         foo = parser.newdefine("foo::bar")
 
@@ -493,8 +493,8 @@ class TestLangFunctions < Test::Unit::TestCase
 
         ffun = ffoo = nil
         assert_nothing_raised("Search path change did not work") do
-            ffun = scope.finddefine("ness")
-            ffoo = scope.finddefine('bar')
+            ffun = scope.find_definition("ness")
+            ffoo = scope.find_definition('bar')
         end
 
         assert(ffun, "Could not find definition in 'fun' namespace")

data/test/language/parser.rb

@@ -26,15 +26,6 @@ class TestParser < Test::Unit::TestCase
                 parser.file = file
                 parser.parse
             }
-
-            Puppet::Type.eachtype { |type|
-                type.each { |obj|
-                    assert(obj.file, "File is not set on %s" % obj.ref)
-                    assert(obj.name, "Name is not set on %s" % obj.ref)
-                    assert(obj.line, "Line is not set on %s" % obj.ref)
-                }
-            }
-            Puppet::Type.allclear
         }
     end
 
@@ -47,9 +38,8 @@ class TestParser < Test::Unit::TestCase
                 ast = parser.parse
                 config = mkcompiler(parser)
                 config.compile
-                #ast.classes[""].evaluate config.topscope
+                #ast.hostclass("").evaluate config.topscope
             }
-            Puppet::Type.allclear
         }
     end
 
@@ -293,7 +283,7 @@ class TestParser < Test::Unit::TestCase
             ret = parser.parse
         }
 
-        ret.classes[""].code.each do |obj|
+        ret.hostclass("").code.each do |obj|
             assert_instance_of(AST::Collection, obj)
         end
     end
@@ -318,7 +308,7 @@ class TestParser < Test::Unit::TestCase
             f.puts %{
 node nodeA, nodeB {
     file { "#{other}": ensure => file }
-    
+
 }
 }
         end
@@ -384,13 +374,13 @@ file { "/tmp/yayness":
         str1 = %{if true { #{exec.call("true")} }}
         ret = nil
         assert_nothing_raised {
-            ret = parser.parse(str1).classes[""].code[0]
+            ret = parser.parse(str1).hostclass("").code[0]
         }
         assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
         parser = mkparser
         str2 = %{if true { #{exec.call("true")} } else { #{exec.call("false")} }}
         assert_nothing_raised {
-            ret = parser.parse(str2).classes[""].code[0]
+            ret = parser.parse(str2).hostclass("").code[0]
         }
         assert_instance_of(Puppet::Parser::AST::IfStatement, ret)
         assert_instance_of(Puppet::Parser::AST::Else, ret.else)
@@ -402,8 +392,8 @@ file { "/tmp/yayness":
         assert_nothing_raised {
             parser.parse %{class myclass { class other {} }}
         }
-        assert(parser.classes["myclass"], "Could not find myclass")
-        assert(parser.classes["myclass::other"], "Could not find myclass::other")
+        assert(parser.hostclass("myclass"), "Could not find myclass")
+        assert(parser.hostclass("myclass::other"), "Could not find myclass::other")
 
         assert_nothing_raised {
             parser.parse "class base {}
@@ -411,17 +401,17 @@ file { "/tmp/yayness":
                 class deep::sub inherits base {}
             }"
         }
-        sub = parser.classes["container::deep::sub"]
+        sub = parser.hostclass("container::deep::sub")
         assert(sub, "Could not find sub")
-        
+
         # Now try it with a parent class being a fq class
         assert_nothing_raised {
             parser.parse "class container::one inherits container::deep::sub {}"
         }
-        sub = parser.classes["container::one"]
+        sub = parser.hostclass("container::one")
         assert(sub, "Could not find one")
         assert_equal("container::deep::sub", sub.parentclass)
-        
+
         # Finally, try including a qualified class
         assert_nothing_raised("Could not include fully qualified class") {
             parser.parse "include container::deep::sub"
@@ -436,17 +426,17 @@ file { "/tmp/yayness":
         assert_nothing_raised do
             out = parser.parse ""
 
-            assert_instance_of(Puppet::Parser::Parser::ASTSet, out)
-            assert_nil(parser.classes[""], "Got a 'main' class when we had no code")
+            assert_instance_of(Puppet::Parser::LoadedCode, out)
+            assert_nil(parser.hostclass(""), "Got a 'main' class when we had no code")
         end
 
         # Now try something a touch more complicated
         parser.initvars
         assert_nothing_raised do
             out = parser.parse "Exec { path => '/usr/bin:/usr/sbin' }"
-            assert_instance_of(Puppet::Parser::Parser::ASTSet, out)
-            assert_equal("", parser.classes[""].classname)
-            assert_equal("", parser.classes[""].namespace)
+            assert_instance_of(Puppet::Parser::LoadedCode, out)
+            assert_equal("", parser.hostclass("").classname)
+            assert_equal("", parser.hostclass("").namespace)
         end
     end
 
@@ -454,6 +444,9 @@ file { "/tmp/yayness":
     def test_virtualresources
         tests = [:virtual]
         if Puppet.features.rails?
+            catalog_cache_class = Puppet::Resource::Catalog.indirection.cache_class
+            facts_cache_class = Puppet::Node::Facts.indirection.cache_class
+            node_cache_class = Puppet::Node.indirection.cache_class
             Puppet[:storeconfigs] = true
             tests << :exported
         end
@@ -489,8 +482,8 @@ file { "/tmp/yayness":
                 ret = parser.parse("#{at}file { '/tmp/testing': owner => root }")
             end
 
-            assert_instance_of(AST::ASTArray, ret.classes[""].code)
-            resdef = ret.classes[""].code[0]
+            assert_instance_of(AST::ASTArray, ret.hostclass("").code)
+            resdef = ret.hostclass("").code[0]
             assert_instance_of(AST::Resource, resdef)
             assert_equal("/tmp/testing", resdef.title.value)
             # We always get an astarray back, so...
@@ -501,16 +494,25 @@ file { "/tmp/yayness":
                 ret = parser.parse("#{at}file { ['/tmp/1', '/tmp/2']: owner => root }")
             end
 
-            ret.classes[""].each do |res|
+            ret.hostclass("").each do |res|
                 assert_instance_of(AST::Resource, res)
                 check.call(res, "multiresource")
             end
         end
+        if Puppet.features.rails?
+            Puppet[:storeconfigs] = false
+            Puppet::Resource::Catalog.cache_class =  catalog_cache_class
+            Puppet::Node::Facts.cache_class = facts_cache_class
+            Puppet::Node.cache_class = node_cache_class
+        end
     end
 
     def test_collections
         tests = [:virtual]
         if Puppet.features.rails?
+            catalog_cache_class = Puppet::Resource::Catalog.indirection.cache_class
+            facts_cache_class = Puppet::Node::Facts.indirection.cache_class
+            node_cache_class = Puppet::Node.indirection.cache_class
             Puppet[:storeconfigs] = true
             tests << :exported
         end
@@ -529,10 +531,16 @@ file { "/tmp/yayness":
                 ret = parser.parse("File #{arrow}")
             end
 
-            coll = ret.classes[""].code[0]
+            coll = ret.hostclass("").code[0]
             assert_instance_of(AST::Collection, coll)
             assert_equal(form, coll.form)
         end
+        if Puppet.features.rails?
+            Puppet[:storeconfigs] = false
+            Puppet::Resource::Catalog.cache_class =  catalog_cache_class
+            Puppet::Node::Facts.cache_class = facts_cache_class
+            Puppet::Node.cache_class = node_cache_class
+        end
     end
 
     def test_collectionexpressions
@@ -543,7 +551,7 @@ file { "/tmp/yayness":
 
             res = nil
             assert_nothing_raised do
-                res = parser.parse(str).classes[""].code[0]
+                res = parser.parse(str).hostclass("").code[0]
             end
 
             assert_instance_of(AST::Collection, res)
@@ -566,7 +574,7 @@ file { "/tmp/yayness":
 
             res = nil
             assert_nothing_raised do
-                res = parser.parse(str).classes[""].code[0]
+                res = parser.parse(str).hostclass("").code[0]
             end
 
             assert_instance_of(AST::Collection, res)
@@ -590,7 +598,7 @@ file { "/tmp/yayness":
 
             res = nil
             assert_nothing_raised("Could not parse '#{test}'") do
-                res = parser.parse(str).classes[""].code[0]
+                res = parser.parse(str).hostclass("").code[0]
             end
 
             assert_instance_of(AST::Collection, res)
@@ -627,14 +635,14 @@ file { "/tmp/yayness":
         assert(code.length == 1, "Did not get the file")
         assert_instance_of(Puppet::TransObject, code[0])
     end
-    
+
     def test_fully_qualified_definitions
         parser = mkparser
 
         assert_nothing_raised("Could not parse fully-qualified definition") {
             parser.parse %{define one::two { }}
         }
-        assert(parser.definitions["one::two"], "Could not find one::two with no namespace")
+        assert(parser.definition("one::two"), "Could not find one::two with no namespace")
         
         # Now try using the definition
         assert_nothing_raised("Could not parse fully-qualified definition usage") {
@@ -693,7 +701,6 @@ file { "/tmp/yayness":
 
         manifest = File.join(modpath, "manifest.pp")
         manifest_texts.each do |txt|
-            Puppet::Type.allclear
             File.open(manifest, "w") { |f| f.puts txt }
 
             assert_nothing_raised {
@@ -775,7 +782,7 @@ file { "/tmp/yayness":
             result = parser.parse %{$variable = undef}
         }
 
-        main = result.classes[""].code
+        main = result.hostclass("").code
         children = main.children
         assert_instance_of(AST::VarDef, main.children[0])
         assert_instance_of(AST::Undef, main.children[0].value)
@@ -785,17 +792,17 @@ file { "/tmp/yayness":
     def test_parse
         parser = mkparser
 
-        str = "file { '/tmp/yay': ensure => file }\nclass yay {}\nnode foo {}\ndefine bar {}\n" 
+        str = "file { '/tmp/yay': ensure => file }\nclass yay {}\nnode foo {}\ndefine bar {}\n"
         result = nil
         assert_nothing_raised("Could not parse") do
             result = parser.parse(str)
         end
-        assert_instance_of(Puppet::Parser::Parser::ASTSet, result, "Did not get a ASTSet back from parsing")
+        assert_instance_of(Puppet::Parser::LoadedCode, result, "Did not get a ASTSet back from parsing")
 
-        assert_instance_of(AST::HostClass, result.classes["yay"], "Did not create 'yay' class")
-        assert_instance_of(AST::HostClass, result.classes[""], "Did not create main class")
-        assert_instance_of(AST::Definition, result.definitions["bar"], "Did not create 'bar' definition")
-        assert_instance_of(AST::Node, result.nodes["foo"], "Did not create 'foo' node")
+        assert_instance_of(AST::HostClass, result.hostclass("yay"), "Did not create 'yay' class")
+        assert_instance_of(AST::HostClass, result.hostclass(""), "Did not create main class")
+        assert_instance_of(AST::Definition, result.definition("bar"), "Did not create 'bar' definition")
+        assert_instance_of(AST::Node, result.node("foo"), "Did not create 'foo' node")
     end
 
     # Make sure our node gets added to the node table.
@@ -807,7 +814,7 @@ file { "/tmp/yayness":
             parser.newnode("mynode", :code => :yay)
         }
 
-        assert_equal(:yay, parser.nodes["mynode"].code)
+        assert_equal(:yay, parser.node("mynode").code)
 
         # Now make sure that trying to redefine it throws an error.
         assert_raise(Puppet::ParseError) {
@@ -823,8 +830,8 @@ file { "/tmp/yayness":
         parser.newnode(:foo)
 
         # And make sure we get things back correctly
-        assert_equal(:foo, parser.nodes["simplenode"].parentclass)
-        assert_nil(parser.nodes["simplenode"].code)
+        assert_equal(:foo, parser.node("simplenode").parentclass)
+        assert_nil(parser.node("simplenode").code)
 
         # Now make sure that trying to redefine it throws an error.
         assert_raise(Puppet::ParseError) {
@@ -838,8 +845,8 @@ file { "/tmp/yayness":
         }
 
         names.each do |name|
-            assert_equal(:yay, parser.nodes[name].code)
-            assert_equal(:foo, parser.nodes[name].parentclass)
+            assert_equal(:yay, parser.node(name).code)
+            assert_equal(:foo, parser.node(name).parentclass)
             # Now make sure that trying to redefine it throws an error.
             assert_raise(Puppet::ParseError) {
                 parser.newnode(name, {})
@@ -855,7 +862,7 @@ file { "/tmp/yayness":
                 :arguments => ["a", stringobj("b")])
         }
 
-        mydefine = parser.definitions["mydefine"]
+        mydefine = parser.definition("mydefine")
         assert(mydefine, "Could not find definition")
         assert_equal("", mydefine.namespace)
         assert_equal("mydefine", mydefine.classname)
@@ -870,9 +877,9 @@ file { "/tmp/yayness":
             parser.newdefine("other::mydefine", :code => :other,
                 :arguments => ["a", stringobj("b")])
         }
-        other = parser.definitions["other::mydefine"]
+        other = parser.definition("other::mydefine")
         assert(other, "Could not find definition")
-        assert(parser.definitions["other::mydefine"],
+        assert(parser.definition("other::mydefine"),
             "Could not find other::mydefine")
         assert_equal(:other, other.code)
         assert_equal("other", other.namespace)
@@ -901,10 +908,10 @@ file { "/tmp/yayness":
 
         assert(klass, "Did not return class")
 
-        assert(parser.classes["myclass"], "Could not find definition")
-        assert_equal("myclass", parser.classes["myclass"].classname)
+        assert(parser.hostclass("myclass"), "Could not find definition")
+        assert_equal("myclass", parser.hostclass("myclass").classname)
         assert_equal(%w{original code},
-             parser.classes["myclass"].code.evaluate(scope))
+             parser.hostclass("myclass").code.evaluate(scope))
 
         # Newclass behaves differently than the others -- it just appends
         # the code to the existing class.
@@ -914,7 +921,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class when appending")
         assert_equal(%w{original code something new},
-            parser.classes["myclass"].code.evaluate(scope))
+            parser.hostclass("myclass").code.evaluate(scope))
 
         # Now create the same class name in a different scope
         assert_nothing_raised {
@@ -922,7 +929,7 @@ file { "/tmp/yayness":
                             :code => mkcode.call(%w{something diff}))
         }
         assert(klass, "Did not return class")
-        other = parser.classes["other::myclass"]
+        other = parser.hostclass("other::myclass")
         assert(other, "Could not find class")
         assert_equal("other::myclass", other.classname)
         assert_equal("other::myclass", other.namespace)
@@ -938,7 +945,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class with no code")
         assert_equal(%w{yay test},
-            parser.classes["nocode"].code.evaluate(scope))
+            parser.hostclass("nocode").code.evaluate(scope))
 
         # Then try merging something into nothing
         parser.newclass("nocode2", :code => mkcode.call(%w{foo test}))
@@ -949,7 +956,7 @@ file { "/tmp/yayness":
         end
         assert(klass, "Did not return class with no code")
         assert_equal(%w{foo test},
-            parser.classes["nocode2"].code.evaluate(scope))
+            parser.hostclass("nocode2").code.evaluate(scope))
 
         # And lastly, nothing and nothing
         klass = parser.newclass("nocode3")
@@ -959,7 +966,7 @@ file { "/tmp/yayness":
             klass = parser.newclass("nocode3")
         end
         assert(klass, "Did not return class with no code")
-        assert_nil(parser.classes["nocode3"].code)
+        assert_nil(parser.hostclass("nocode3").code)
     end
 
     # Make sure you can't have classes and defines with the same name in the
@@ -997,7 +1004,7 @@ file { "/tmp/yayness":
             end
         end
     end
-    
+
     # Now make sure we get appropriate behaviour with parent class conflicts.
     def test_newclass_parentage
         parser = mkparser
@@ -1008,8 +1015,8 @@ file { "/tmp/yayness":
         assert_nothing_raised {
             parser.newclass("sub")
         }
-        assert(parser.classes["sub"], "Could not find definition")
-        assert_nil(parser.classes["sub"].parentclass)
+        assert(parser.hostclass("sub"), "Could not find definition")
+        assert_nil(parser.hostclass("sub").parentclass)
 
         # Make sure we can't set the parent class to ourself.
         assert_raise(Puppet::ParseError) {
@@ -1023,7 +1030,7 @@ file { "/tmp/yayness":
 
         # Make sure we get the right parent class, and make sure it's not an object.
         assert_equal("base1",
-                    parser.classes["sub"].parentclass)
+                    parser.hostclass("sub").parentclass)
 
         # Now make sure we get a failure if we try to conflict.
         assert_raise(Puppet::ParseError) {
@@ -1032,45 +1039,16 @@ file { "/tmp/yayness":
 
         # Make sure that failure didn't screw us up in any way.
         assert_equal("base1",
-                    parser.classes["sub"].parentclass)
+                    parser.hostclass("sub").parentclass)
         # But make sure we can create a class with a fq parent
         assert_nothing_raised {
             parser.newclass("another", :parent => "one::two::three")
         }
         assert_equal("one::two::three",
-                    parser.classes["another"].parentclass)
+                    parser.hostclass("another").parentclass)
 
     end
 
-    def test_fqfind
-        parser = mkparser
-
-        table = {}
-        # Define a bunch of things.
-        %w{a c a::b a::b::c a::c a::b::c::d a::b::c::d::e::f c::d}.each do |string|
-            table[string] = string
-        end
-
-        check = proc do |namespace, hash|
-            hash.each do |thing, result|
-                assert_equal(result, parser.fqfind(namespace, thing, table),
-                            "Could not find %s in %s" % [thing, namespace])
-            end
-        end
-
-        # Now let's do some test lookups.
-
-        # First do something really simple
-        check.call "a", "b" => "a::b", "b::c" => "a::b::c", "d" => nil, "::c" => "c"
-
-        check.call "a::b", "c" => "a::b::c", "b" => "a::b", "a" => "a"
-
-        check.call "a::b::c::d::e", "c" => "a::b::c", "::c" => "c",
-            "c::d" => "a::b::c::d", "::c::d" => "c::d"
-
-        check.call "", "a" => "a", "a::c" => "a::c"
-    end
-
     # Setup a module.
     def mk_module(name, files = {})
         mdir = File.join(@dir, name)
@@ -1105,20 +1083,20 @@ file { "/tmp/yayness":
         parser = mkparser
 
         # Make sure we fail like normal for actually missing classes
-        assert_nil(parser.findclass("", "nosuchclass"), "Did not return nil on missing classes")
+        assert_nil(parser.find_hostclass("", "nosuchclass"), "Did not return nil on missing classes")
 
         # test the simple case -- the module class itself
         name = "simple"
         mk_module(name, :init => [name])
 
         # Try to load the module automatically now
-        klass = parser.findclass("", name)
+        klass = parser.find_hostclass("", name)
         assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
         assert_equal(name, klass.classname, "Incorrect class was returned")
 
         # Try loading the simple module when we're in something other than the base namespace.
         parser = mkparser
-        klass = parser.findclass("something::else", name)
+        klass = parser.find_hostclass("something::else", name)
         assert_instance_of(AST::HostClass, klass, "Did not autoload class from module init file")
         assert_equal(name, klass.classname, "Incorrect class was returned")
 
@@ -1126,7 +1104,7 @@ file { "/tmp/yayness":
         name = "simpdef"
         mk_module(name, :define => true, :init => [name])
 
-        klass = parser.finddefine("", name)
+        klass = parser.find_definition("", name)
         assert_instance_of(AST::Definition, klass, "Did not autoload class from module init file")
         assert_equal(name, klass.classname, "Incorrect class was returned")
 
@@ -1137,13 +1115,13 @@ file { "/tmp/yayness":
         mk_module(modname, :init => %w{both both::sub})
 
         # First try it with a namespace
-        klass = parser.findclass("both", name)
+        klass = parser.find_hostclass("both", name)
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with a namespace")
         assert_equal("both::sub", klass.classname, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
-        klass = parser.findclass("", "both::sub")
+        klass = parser.find_hostclass("", "both::sub")
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from module init file with no namespace")
         assert_equal("both::sub", klass.classname, "Incorrect class was returned")
 
@@ -1155,13 +1133,13 @@ file { "/tmp/yayness":
         mk_module(modname, :init => %w{separate}, :sub => %w{separate::sub})
 
         # First try it with a namespace
-        klass = parser.findclass("separate", name)
+        klass = parser.find_hostclass("separate", name)
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with a namespace")
         assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
-        klass = parser.findclass("", "separate::sub")
+        klass = parser.find_hostclass("", "separate::sub")
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from separate file with no namespace")
         assert_equal("separate::sub", klass.classname, "Incorrect class was returned")
 
@@ -1173,14 +1151,14 @@ file { "/tmp/yayness":
 
         # First try it with a namespace
         assert_nothing_raised("Could not autoload file when module file is missing") do
-            klass = parser.findclass("alone", name)
+            klass = parser.find_hostclass("alone", name)
         end
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with a namespace")
         assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
 
         # Now try it using the fully qualified name
         parser = mkparser
-        klass = parser.findclass("", "alone::sub")
+        klass = parser.find_hostclass("", "alone::sub")
         assert_instance_of(AST::HostClass, klass, "Did not autoload sub class from alone file with no namespace")
         assert_equal("alone::sub", klass.classname, "Incorrect class was returned")
 
@@ -1188,25 +1166,25 @@ file { "/tmp/yayness":
         name = "mymod"
         mk_module(name, :define => true, :mydefine => ["mymod::mydefine"])
 
-        klass = parser.finddefine("", "mymod::mydefine")
+        klass = parser.find_definition("", "mymod::mydefine")
         assert_instance_of(AST::Definition, klass, "Did not autoload definition from its own file")
         assert_equal("mymod::mydefine", klass.classname, "Incorrect definition was returned")
     end
-    
+
     # Make sure class, node, and define methods are case-insensitive
     def test_structure_case_insensitivity
         parser = mkparser
-        
+
         result = nil
         assert_nothing_raised do
             result = parser.newclass "Yayness"
         end
-        assert_equal(result, parser.findclass("", "yayNess"))
+        assert_equal(result, parser.find_hostclass("", "yayNess"))
         
         assert_nothing_raised do
             result = parser.newdefine "FunTest"
         end
-        assert_equal(result, parser.finddefine("", "fUntEst"),
+        assert_equal(result, parser.find_definition("", "fUntEst"),
             "%s was not matched" % "fUntEst")
     end
 
@@ -1215,10 +1193,10 @@ file { "/tmp/yayness":
 
         # We use an exception to cut short the processing to simplify our stubbing
         #Puppet::Module.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).raises(Puppet::ParseError)
-        Puppet::Module.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).returns([])
+        Puppet::Parser::Files.expects(:find_manifests).with("test", {:cwd => ".", :environment => "something"}).returns([])
 
         assert_raise(Puppet::ImportError) do
-            parser.import("test") 
+            parser.import("test")
         end
     end