diff --git a/lib/puppet/parser/scope.rb b/lib/puppet/parser/scope.rb
index b79b344e3..bb8725096 100644
--- a/lib/puppet/parser/scope.rb
+++ b/lib/puppet/parser/scope.rb
@@ -1,454 +1,445 @@
 # The scope class, which handles storing and retrieving variables and types and
 # such.
 
 require 'puppet/parser/parser'
 require 'puppet/parser/templatewrapper'
 require 'puppet/transportable'
 require 'strscan'
 
 require 'puppet/resource/type_collection_helper'
 
 class Puppet::Parser::Scope
     include Puppet::Resource::TypeCollectionHelper
     require 'puppet/parser/resource'
 
     AST = Puppet::Parser::AST
 
     Puppet::Util.logmethods(self)
 
     include Enumerable
     include Puppet::Util::Errors
     attr_accessor :level, :source, :resource
     attr_accessor :base, :keyword, :nodescope
     attr_accessor :top, :translated, :compiler
     attr_accessor :parent
+    attr_reader :namespaces
 
     # A demeterific shortcut to the catalog.
     def catalog
         compiler.catalog
     end
 
     def environment
         compiler.environment
     end
 
     # Proxy accessors
     def host
         @compiler.node.name
     end
 
     # Is the value true?  This allows us to control the definition of truth
     # in one place.
     def self.true?(value)
         if value == false or value == "" or value == :undef
             return false
         else
             return true
         end
     end
 
     # Is the value a number?, return the correct object or nil if not a number
     def self.number?(value)
         unless value.is_a?(Fixnum) or value.is_a?(Bignum) or value.is_a?(Float) or value.is_a?(String)
             return nil
         end
 
         if value.is_a?(String)
             if value =~ /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/
                 return value.to_f
             elsif value =~ /^0x[0-9a-f]+$/i
                 return value.to_i(16)
             elsif value =~ /^0[0-7]+$/
                 return value.to_i(8)
             elsif value =~ /^-?\d+$/
                 return value.to_i
             else
                 return nil
             end
         end
         # it is one of Fixnum,Bignum or Float
         return value
     end
 
     # Add to our list of namespaces.
     def add_namespace(ns)
         return false if @namespaces.include?(ns)
         if @namespaces == [""]
             @namespaces = [ns]
         else
             @namespaces << ns
         end
     end
 
     # Are we the top scope?
     def topscope?
         @level == 1
     end
 
     def find_hostclass(name)
-        @namespaces.each do |namespace|
-            if r = known_resource_types.find_hostclass(namespace, name)
-                return r
-            end
-        end
-        return nil
+        known_resource_types.find_hostclass(namespaces, name)
     end
 
     def find_definition(name)
-        @namespaces.each do |namespace|
-            if r = known_resource_types.find_definition(namespace, name)
-                return r
-            end
-        end
-        return nil
+        known_resource_types.find_definition(namespaces, name)
     end
 
     def findresource(string, name = nil)
         compiler.findresource(string, name)
     end
 
     # Initialize our new scope.  Defaults to having no parent.
     def initialize(hash = {})
         if hash.include?(:namespace)
             if n = hash[:namespace]
                 @namespaces = [n]
             end
             hash.delete(:namespace)
         else
             @namespaces = [""]
         end
         hash.each { |name, val|
             method = name.to_s + "="
             if self.respond_to? method
                 self.send(method, val)
             else
                 raise Puppet::DevError, "Invalid scope argument %s" % name
             end
         }
 
         @tags = []
 
         # The symbol table for this scope.  This is where we store variables.
         @symtable = {}
 
         # the ephemeral symbol tables
         # those should not persist long, and are used for the moment only
         # for $0..$xy capture variables of regexes
         @ephemeral = {}
 
         # All of the defaults set for types.  It's a hash of hashes,
         # with the first key being the type, then the second key being
         # the parameter.
         @defaults = Hash.new { |dhash,type|
             dhash[type] = {}
         }
 
         # The table for storing class singletons.  This will only actually
         # be used by top scopes and node scopes.
         @class_scopes = {}
     end
 
     # Store the fact that we've evaluated a class, and store a reference to
     # the scope in which it was evaluated, so that we can look it up later.
     def class_set(name, scope)
         return parent.class_set(name,scope) if parent
         if existing = @class_scopes[name]
             if existing.nodescope? != scope.nodescope?
                 raise Puppet::ParseError, "Cannot have classes, nodes, or definitions with the same name"
             else
                 raise Puppet::DevError, "Somehow evaluated %s %s twice" % [ existing.nodescope? ? "node" : "class", name]
             end
         end
         @class_scopes[name] = scope
     end
 
     # Return the scope associated with a class.  This is just here so
     # that subclasses can set their parent scopes to be the scope of
     # their parent class, and it's also used when looking up qualified
     # variables.
     def class_scope(klass)
         # They might pass in either the class or class name
         k = klass.respond_to?(:name) ? klass.name : klass
         @class_scopes[k] || (parent && parent.class_scope(k))
     end
 
     # Collect all of the defaults set at any higher scopes.
     # This is a different type of lookup because it's additive --
     # it collects all of the defaults, with defaults in closer scopes
     # overriding those in later scopes.
     def lookupdefaults(type)
         values = {}
 
         # first collect the values from the parents
         unless parent.nil?
             parent.lookupdefaults(type).each { |var,value|
                 values[var] = value
             }
         end
 
         # then override them with any current values
         # this should probably be done differently
         if @defaults.include?(type)
             @defaults[type].each { |var,value|
                 values[var] = value
             }
         end
 
         #Puppet.debug "Got defaults for %s: %s" %
         #    [type,values.inspect]
         return values
     end
 
     # Look up a defined type.
     def lookuptype(name)
         find_definition(name) || find_hostclass(name)
     end
 
     def lookup_qualified_var(name, usestring)
         parts = name.split(/::/)
         shortname = parts.pop
         klassname = parts.join("::")
         klass = find_hostclass(klassname)
         unless klass
             warning "Could not look up qualified variable '%s'; class %s could not be found" % [name, klassname]
             return usestring ? "" : :undefined
         end
         unless kscope = class_scope(klass)
             warning "Could not look up qualified variable '%s'; class %s has not been evaluated" % [name, klassname]
             return usestring ? "" : :undefined
         end
         return kscope.lookupvar(shortname, usestring)
     end
 
     private :lookup_qualified_var
 
     # Look up a variable.  The simplest value search we do.  Default to returning
     # an empty string for missing values, but support returning a constant.
     def lookupvar(name, usestring = true)
         table = ephemeral?(name) ? @ephemeral : @symtable
         # If the variable is qualified, then find the specified scope and look the variable up there instead.
         if name =~ /::/
             return lookup_qualified_var(name, usestring)
         end
         # We can't use "if table[name]" here because the value might be false
         if table.include?(name)
             if usestring and table[name] == :undef
                 return ""
             else
                 return table[name]
             end
         elsif self.parent
             return parent.lookupvar(name, usestring)
         elsif usestring
             return ""
         else
             return :undefined
         end
     end
 
     # Return a hash containing our variables and their values, optionally (and
     # by default) including the values defined in our parent.  Local values
     # shadow parent values.
     def to_hash(recursive = true)
         if recursive and parent then
             target = parent.to_hash(recursive)
         end
         target ||= Hash.new
         @symtable.keys.each { |name|
             value = @symtable[name]
             if value == :undef then
                 target.delete(name)
             else
                 target[name] = value
             end
         }
         return target
     end
 
     def namespaces
         @namespaces.dup
     end
 
     # Create a new scope and set these options.
     def newscope(options = {})
         compiler.newscope(self, options)
     end
 
     # Is this class for a node?  This is used to make sure that
     # nodes and classes with the same name conflict (#620), which
     # is required because of how often the names are used throughout
     # the system, including on the client.
     def nodescope?
         self.nodescope
     end
 
     # Return the list of scopes up to the top scope, ordered with our own first.
     # This is used for looking up variables and defaults.
     def scope_path
         if parent
             [self, parent.scope_path].flatten.compact
         else
             [self]
         end
     end
 
     # Set defaults for a type.  The typename should already be downcased,
     # so that the syntax is isolated.  We don't do any kind of type-checking
     # here; instead we let the resource do it when the defaults are used.
     def setdefaults(type, params)
         table = @defaults[type]
 
         # if we got a single param, it'll be in its own array
         params = [params] unless params.is_a?(Array)
 
         params.each { |param|
             #Puppet.debug "Default for %s is %s => %s" %
             #    [type,ary[0].inspect,ary[1].inspect]
             if table.include?(param.name)
                 raise Puppet::ParseError.new("Default already defined for %s { %s }; cannot redefine" % [type, param.name], param.line, param.file)
             end
             table[param.name] = param
         }
     end
 
     # Set a variable in the current scope.  This will override settings
     # in scopes above, but will not allow variables in the current scope
     # to be reassigned.
     def setvar(name,value, options = {})
         table = options[:ephemeral] ? @ephemeral : @symtable
         #Puppet.debug "Setting %s to '%s' at level %s mode append %s" %
         #    [name.inspect,value,self.level, append]
         if table.include?(name)
             unless options[:append]
                 error = Puppet::ParseError.new("Cannot reassign variable %s" % name)
             else
                 error = Puppet::ParseError.new("Cannot append, variable %s is defined in this scope" % name)
             end
             if options[:file]
                 error.file = options[:file]
             end
             if options[:line]
                 error.line = options[:line]
             end
             raise error
         end
 
         unless options[:append]
             table[name] = value
         else # append case
             # lookup the value in the scope if it exists and insert the var
             table[name] = lookupvar(name)
             # concatenate if string, append if array, nothing for other types
             case value
             when Array
                 table[name] += value
             when Hash
                 raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported" unless value.is_a?(Hash)
                 table[name].merge!(value)
             else
                 table[name] << value
             end
         end
     end
 
     # Return an interpolated string.
     def strinterp(string, file = nil, line = nil)
         # Most strings won't have variables in them.
         ss = StringScanner.new(string)
         out = ""
         while not ss.eos?
             if ss.scan(/^\$\{((\w*::)*\w+|[0-9]+)\}|^\$([0-9])|^\$((\w*::)*\w+)/)
                 # If it matches the backslash, then just retun the dollar sign.
                 if ss.matched == '\\$'
                     out << '$'
                 else # look the variable up
                     # make sure $0-$9 are lookupable only if ephemeral
                     var = ss[1] || ss[3] || ss[4]
                     if var and var =~ /^[0-9]+$/ and not ephemeral?(var)
                         next
                     end
                     out << lookupvar(var).to_s || ""
                 end
             elsif ss.scan(/^\\(.)/)
                 # Puppet.debug("Got escape: pos:%d; m:%s" % [ss.pos, ss.matched])
                 case ss[1]
                 when 'n'
                     out << "\n"
                 when 't'
                     out << "\t"
                 when 's'
                     out << " "
                 when '\\'
                     out << '\\'
                 when '$'
                     out << '$'
                 else
                     str = "Unrecognised escape sequence '#{ss.matched}'"
                     if file
                         str += " in file %s" % file
                     end
                     if line
                         str += " at line %s" % line
                     end
                     Puppet.warning str
                     out << ss.matched
                 end
             elsif ss.scan(/^\$/)
                 out << '$'
             elsif ss.scan(/^\\\n/) # an escaped carriage return
                 next
             else
                 tmp = ss.scan(/[^\\$]+/)
                 # Puppet.debug("Got other: pos:%d; m:%s" % [ss.pos, tmp])
                 unless tmp
                     error = Puppet::ParseError.new("Could not parse string %s" %
                         string.inspect)
                     {:file= => file, :line= => line}.each do |m,v|
                         error.send(m, v) if v
                     end
                     raise error
                 end
                 out << tmp
             end
         end
 
         return out
     end
 
     # Return the tags associated with this scope.  It's basically
     # just our parents' tags, plus our type.  We don't cache this value
     # because our parent tags might change between calls.
     def tags
         resource.tags
     end
 
     # Used mainly for logging
     def to_s
         "Scope(%s)" % @resource.to_s
     end
 
     # Undefine a variable; only used for testing.
     def unsetvar(var)
         table = ephemeral?(var) ? @ephemeral : @symtable
         if table.include?(var)
             table.delete(var)
         end
     end
 
     def unset_ephemeral_var
         @ephemeral = {}
     end
 
     def ephemeral?(name)
         @ephemeral.include?(name)
     end
 
     def ephemeral_from(match, file = nil, line = nil)
         raise(ArgumentError,"Invalid regex match data") unless match.is_a?(MatchData)
 
         setvar("0", match[0], :file => file, :line => line, :ephemeral => true)
         match.captures.each_with_index do |m,i|
             setvar("#{i+1}", m, :file => file, :line => line, :ephemeral => true)
         end
     end
 end
diff --git a/lib/puppet/resource/type_collection.rb b/lib/puppet/resource/type_collection.rb
index 7ca95b1b8..a0bd2ddf5 100644
--- a/lib/puppet/resource/type_collection.rb
+++ b/lib/puppet/resource/type_collection.rb
@@ -1,182 +1,189 @@
 class Puppet::Resource::TypeCollection
     attr_reader :environment
 
     def initialize(env)
         @environment = env.is_a?(String) ? Puppet::Node::Environment.new(env) : env
         @hostclasses = {}
         @definitions = {}
         @nodes = {}
 
         # So we can keep a list and match the first-defined regex
         @node_list = []
 
         @watched_files = {}
     end
 
     def <<(thing)
         add(thing)
         self
     end
 
     def add(instance)
         method = "add_#{instance.type}"
         send(method, instance)
         instance.code_collection = self
         instance
     end
 
     def add_hostclass(instance)
         dupe_check(instance, @hostclasses) { |dupe| "Class #{instance.name} is already defined#{dupe.error_context}; cannot redefine" }
         dupe_check(instance, @definitions) { |dupe| "Definition #{instance.name} is already defined#{dupe.error_context}; cannot be redefined as a class" }
 
         @hostclasses[instance.name] = instance
         instance
     end
 
     def hostclass(name)
         @hostclasses[munge_name(name)]
     end
 
     def add_node(instance)
         dupe_check(instance, @nodes) { |dupe| "Node #{instance.name} is already defined#{dupe.error_context}; cannot redefine" }
 
         @node_list << instance
         @nodes[instance.name] = instance
         instance
     end
 
     def node(name)
         name = munge_name(name)
 
         if node = @nodes[name]
             return node
         end
 
         @node_list.each do |node|
             next unless node.name_is_regex?
             return node if node.match(name)
         end
         nil
     end
 
     def node_exists?(name)
         @nodes[munge_name(name)]
     end
 
     def nodes?
         @nodes.length > 0
     end
 
     def add_definition(code)
         @definitions[code.name] = code
     end
 
     def definition(name)
         @definitions[munge_name(name)]
     end
 
-    def find(namespace, name, type)
+    def find(namespaces, name, type)
         if r = find_fully_qualified(name, type)
             return r
         end
 
-        ary = namespace.split("::")
+        namespaces = Array(namespaces)
 
-        while ary.length > 0
-            tmp_namespace = ary.join("::")
-            if r = find_partially_qualified(tmp_namespace, name, type)
-                return r
+        namespaces.each do |namespace|
+            ary = namespace.split("::")
+
+            while ary.length > 0
+                tmp_namespace = ary.join("::")
+                if r = find_partially_qualified(tmp_namespace, name, type)
+                    return r
+                end
+
+                # Delete the second to last object, which reduces our namespace by one.
+                ary.pop
             end
 
-            # Delete the second to last object, which reduces our namespace by one.
-            ary.pop
+            if result = send(type, name)
+                return result
+            end
         end
-
-        send(type, name)
+        nil
     end
 
     def find_node(name)
         find("", name, :node)
     end
 
     def find_hostclass(namespace, name)
         find(namespace, name, :hostclass)
     end
 
     def find_definition(namespace, name)
         find(namespace, name, :definition)
     end
 
     [:hostclasses, :nodes, :definitions].each do |m|
         define_method(m) do
             instance_variable_get("@#{m}").dup
         end
     end
 
     def perform_initial_import
         parser = Puppet::Parser::Parser.new(environment)
         if code = Puppet.settings.uninterpolated_value(:code, environment.to_s) and code != ""
             parser.string = code
         else
             file = Puppet.settings.value(:manifest, environment.to_s)
             return unless File.exist?(file)
             parser.file = file
         end
         parser.parse
     rescue => detail
         msg = "Could not parse for environment #{environment}: #{detail}"
         error = Puppet::Error.new(msg)
         error.set_backtrace(detail.backtrace)
         raise error
     end
 
     def stale?
         @watched_files.values.detect { |file| file.changed? }
     end
 
     def version
         return @version if defined?(@version)
 
         if environment[:config_version] == ""
             @version = Time.now.to_i
             return @version
         end
 
         @version = Puppet::Util.execute([environment[:config_version]]).strip
 
     rescue Puppet::ExecutionFailure => e
         raise Puppet::ParseError, "Unable to set config_version: #{e.message}"
     end
 
     def watch_file(file)
         @watched_files[file] = Puppet::Util::LoadedFile.new(file)
     end
 
     def watching_file?(file)
         @watched_files.include?(file)
     end
 
     private
 
     def find_fully_qualified(name, type)
         return nil unless name =~ /^::/
 
         name = name.sub(/^::/, '')
 
         send(type, name)
     end
 
     def find_partially_qualified(namespace, name, type)
         send(type, [namespace, name].join("::"))
     end
 
     def munge_name(name)
         name.to_s.downcase
     end
 
     def dupe_check(instance, hash)
         return unless dupe = hash[instance.name]
         message = yield dupe
         instance.fail Puppet::ParseError, message
     end
 end
diff --git a/spec/unit/resource/type_collection.rb b/spec/unit/resource/type_collection.rb
index 2fc364d6b..3de5e504b 100644
--- a/spec/unit/resource/type_collection.rb
+++ b/spec/unit/resource/type_collection.rb
@@ -1,340 +1,347 @@
 #!/usr/bin/env ruby
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/resource/type_collection'
 require 'puppet/resource/type'
 
 describe Puppet::Resource::TypeCollection do
     before do
         @instance = Puppet::Resource::Type.new(:hostclass, "foo")
         @code = Puppet::Resource::TypeCollection.new("env")
     end
 
     it "should require an environment at initialization" do
         env = Puppet::Node::Environment.new("testing")
         Puppet::Resource::TypeCollection.new(env).environment.should equal(env)
     end
 
     it "should convert the environment into an environment instance if a string is provided" do
         env = Puppet::Node::Environment.new("testing")
         Puppet::Resource::TypeCollection.new("testing").environment.should equal(env)
     end
 
     it "should be able to add a resource type" do
         Puppet::Resource::TypeCollection.new("env").should respond_to(:add)
     end
 
     it "should consider '<<' to be an alias to 'add' but should return self" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:add).with "foo"
         loader.expects(:add).with "bar"
         loader << "foo" << "bar"
     end
 
     it "should set itself as the code collection for added resource types" do
         loader = Puppet::Resource::TypeCollection.new("env")
 
         node = Puppet::Resource::Type.new(:node, "foo")
 
         @code.add(node)
         @code.node("foo").should equal(node)
 
         node.code_collection.should equal(@code)
     end
 
     it "should store node resource types as nodes" do
         node = Puppet::Resource::Type.new(:node, "foo")
 
         @code.add(node)
         @code.node("foo").should equal(node)
     end
 
     it "should store hostclasses as hostclasses" do
         klass = Puppet::Resource::Type.new(:hostclass, "foo")
 
         @code.add(klass)
         @code.hostclass("foo").should equal(klass)
     end
 
     it "should store definitions as definitions" do
         define = Puppet::Resource::Type.new(:definition, "foo")
 
         @code.add(define)
         @code.definition("foo").should equal(define)
     end
 
     %w{hostclass node definition}.each do |data|
         it "should have a method for adding a #{data}" do
             Puppet::Resource::TypeCollection.new("env").should respond_to("add_" + data)
         end
 
         it "should use the name of the instance to add it" do
             loader = Puppet::Resource::TypeCollection.new("env")
             loader.send("add_#{data}", @instance)
             loader.send(data, @instance.name).should equal(@instance)
         end
 
         it "should fail to add a #{data} when one already exists" do
             loader = Puppet::Resource::TypeCollection.new("env")
             loader.add @instance
             lambda { loader.add(@instance) }.should raise_error(Puppet::ParseError)
         end
 
         it "should return the added #{data}" do
             loader = Puppet::Resource::TypeCollection.new("env")
 
             loader.add(@instance).should equal(@instance)
         end
 
         it "should be able to retrieve #{data} by name" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(data, "bar")
             loader.add instance
             loader.send(data, "bar").should equal(instance)
         end
 
         it "should retrieve #{data} insensitive to case" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(data, "Bar")
             loader.add instance
             loader.send(data, "bAr").should equal(instance)
         end
 
         it "should return nil when asked for a #{data} that has not been added" do
             Puppet::Resource::TypeCollection.new("env").send(data, "foo").should be_nil
         end
 
         it "should be able to retrieve all #{data}s" do
             plurals = { "hostclass" => "hostclasses", "node" => "nodes", "definition" => "definitions" }
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(data, "foo")
             loader.add instance
             loader.send(plurals[data]).should == { "foo" => instance }
         end
     end
 
     describe "when finding a qualified instance" do
         it "should return any found instance if the instance name is fully qualified" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
             loader.add instance
             loader.find("namespace", "::foo::bar", :hostclass).should equal(instance)
         end
 
         it "should return nil if the instance name is fully qualified and no such instance exists" do
             loader = Puppet::Resource::TypeCollection.new("env")
             loader.find("namespace", "::foo::bar", :hostclass).should be_nil
         end
 
-        it "should return the partially qualified object if it exists in the provided namespace" do
+        it "should return the partially qualified object if it exists in a provided namespace" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
             loader.add instance
             loader.find("foo", "bar::baz", :hostclass).should equal(instance)
         end
 
-        it "should return the unqualified object if it exists in the provided namespace" do
+        it "should be able to find partially qualified objects in any of the provided namespaces" do
+            loader = Puppet::Resource::TypeCollection.new("env")
+            instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
+            loader.add instance
+            loader.find(["nons", "foo", "otherns"], "bar::baz", :hostclass).should equal(instance)
+        end
+
+        it "should return the unqualified object if it exists in a provided namespace" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
             loader.add instance
             loader.find("foo", "bar", :hostclass).should equal(instance)
         end
 
         it "should return the unqualified object if it exists in the parent namespace" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar")
             loader.add instance
             loader.find("foo::bar::baz", "bar", :hostclass).should equal(instance)
         end
 
         it "should should return the partially qualified object if it exists in the parent namespace" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
             loader.add instance
             loader.find("foo::bar", "bar::baz", :hostclass).should equal(instance)
         end
 
         it "should return the qualified object if it exists in the root namespace" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
             loader.add instance
             loader.find("foo::bar", "foo::bar::baz", :hostclass).should equal(instance)
         end
 
         it "should return nil if the object cannot be found" do
             loader = Puppet::Resource::TypeCollection.new("env")
             instance = Puppet::Resource::Type.new(:hostclass, "foo::bar::baz")
             loader.add instance
             loader.find("foo::bar", "eh", :hostclass).should be_nil
         end
     end
 
     it "should use the generic 'find' method with an empty namespace to find nodes" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("", "bar", :node)
         loader.find_node("bar")
     end
 
     it "should use the generic 'find' method to find hostclasses" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("foo", "bar", :hostclass)
         loader.find_hostclass("foo", "bar")
     end
 
     it "should use the generic 'find' method to find definitions" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.expects(:find).with("foo", "bar", :definition)
         loader.find_definition("foo", "bar")
     end
 
     it "should indicate whether any nodes are defined" do
         loader = Puppet::Resource::TypeCollection.new("env")
         loader.add_node(Puppet::Resource::Type.new(:node, "foo"))
         loader.should be_nodes
     end
 
     it "should indicate whether no nodes are defined" do
         Puppet::Resource::TypeCollection.new("env").should_not be_nodes
     end
 
     describe "when finding nodes" do
         before :each do
             @loader = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should return any node whose name exactly matches the provided node name" do
             node = Puppet::Resource::Type.new(:node, "foo")
             @loader << node
 
             @loader.node("foo").should equal(node)
         end
 
         it "should return the first regex node whose regex matches the provided node name" do
             node1 = Puppet::Resource::Type.new(:node, /\w/)
             node2 = Puppet::Resource::Type.new(:node, /\d/)
             @loader << node1 << node2
 
             @loader.node("foo10").should equal(node1)
         end
 
         it "should preferentially return a node whose name is string-equal over returning a node whose regex matches a provided name" do
             node1 = Puppet::Resource::Type.new(:node, /\w/)
             node2 = Puppet::Resource::Type.new(:node, "foo")
             @loader << node1 << node2
 
             @loader.node("foo").should equal(node2)
         end
     end
 
     describe "when managing files" do
         before do
             @loader = Puppet::Resource::TypeCollection.new("env")
             Puppet::Util::LoadedFile.stubs(:new).returns stub("watched_file")
         end
 
         it "should have a method for specifying a file should be watched" do
             @loader.should respond_to(:watch_file)
         end
 
         it "should have a method for determining if a file is being watched" do
             @loader.watch_file("/foo/bar")
             @loader.should be_watching_file("/foo/bar")
         end
 
         it "should use LoadedFile to watch files" do
             Puppet::Util::LoadedFile.expects(:new).with("/foo/bar").returns stub("watched_file")
             @loader.watch_file("/foo/bar")
         end
 
         it "should be considered stale if any files have changed" do
             file1 = stub 'file1', :changed? => false
             file2 = stub 'file2', :changed? => true
             Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
             @loader.watch_file("/foo/bar")
             @loader.watch_file("/other/bar")
 
             @loader.should be_stale
         end
 
         it "should not be considered stable if no files have changed" do
             file1 = stub 'file1', :changed? => false
             file2 = stub 'file2', :changed? => false
             Puppet::Util::LoadedFile.expects(:new).times(2).returns(file1).then.returns(file2)
             @loader.watch_file("/foo/bar")
             @loader.watch_file("/other/bar")
 
             @loader.should_not be_stale
         end
     end
 
     describe "when performing initial import" do
         before do
             @parser = stub 'parser', :file= => nil, :string => nil, :parse => nil
             Puppet::Parser::Parser.stubs(:new).returns @parser
             @code = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should create a new parser instance" do
             Puppet::Parser::Parser.expects(:new).returns @parser
             @code.perform_initial_import
         end
 
         it "should set the parser's string to the 'code' setting and parse if code is available" do
             Puppet.settings[:code] = "my code"
             @parser.expects(:string=).with "my code"
             @parser.expects(:parse)
             @code.perform_initial_import
         end
 
         it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
             File.expects(:exist?).with("/my/file").returns true
             Puppet.settings[:manifest] = "/my/file"
             @parser.expects(:file=).with "/my/file"
             @parser.expects(:parse)
             @code.perform_initial_import
         end
 
         it "should not attempt to load a manifest if none is present" do
             File.expects(:exist?).with("/my/file").returns false
             Puppet.settings[:manifest] = "/my/file"
             @parser.expects(:file=).never
             @parser.expects(:parse).never
             @code.perform_initial_import
         end
 
         it "should fail helpfully if there is an error importing" do
             File.stubs(:exist?).returns true
             @parser.expects(:parse).raises ArgumentError
             lambda { @code.perform_initial_import }.should raise_error(Puppet::Error)
         end
     end
 
     describe "when determining the configuration version" do
         before do
             @code = Puppet::Resource::TypeCollection.new("env")
         end
 
         it "should default to the current time" do
             time = Time.now
 
             Time.stubs(:now).returns time
             @code.version.should == time.to_i
         end
 
         it "should use the output of the environment's config_version setting if one is provided" do
             @code.environment.stubs(:[]).with(:config_version).returns("/my/foo")
 
             Puppet::Util.expects(:execute).with(["/my/foo"]).returns "output\n"
             @code.version.should == "output"
         end
 
         it "should raise a puppet parser error if executing config_version fails" do
             @code.environment.stubs(:[]).with(:config_version).returns("test")
             Puppet::Util.expects(:execute).raises(Puppet::ExecutionFailure.new("msg"))
 
             lambda { @code.version }.should raise_error(Puppet::ParseError)
         end
 
     end
 end