diff --git a/lib/puppet/indirector/resource_type/parser.rb b/lib/puppet/indirector/resource_type/parser.rb
index 8b1bed0a9..fd5b3938a 100644
--- a/lib/puppet/indirector/resource_type/parser.rb
+++ b/lib/puppet/indirector/resource_type/parser.rb
@@ -1,27 +1,32 @@
 require 'puppet/resource/type'
 require 'puppet/indirector/code'
 require 'puppet/indirector/resource_type'
 
 class Puppet::Indirector::ResourceType::Parser < Puppet::Indirector::Code
   desc "Return the data-form of a resource type."
 
   def find(request)
     krt = request.environment.known_resource_types
 
     # This is a bit ugly.
     [:hostclass, :definition, :node].each do |type|
-      if r = krt.send(type, request.key)
+      # We have to us 'find_<type>' here because it will
+      # load any missing types from disk, whereas the plain
+      # '<type>' method only returns from memory.
+      if r = krt.send("find_#{type}", [""], request.key)
         return r
       end
     end
     nil
   end
 
   def search(request)
     raise ArgumentError, "Only '*' is acceptable as a search request" unless request.key == "*"
     krt = request.environment.known_resource_types
-    result = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values].flatten
+    # Make sure we've got all of the types loaded.
+    krt.loader.import_all
+    result = [krt.hostclasses.values, krt.definitions.values, krt.nodes.values].flatten.reject { |t| t.name == "" }
     return nil if result.empty?
     result
   end
 end
diff --git a/lib/puppet/module.rb b/lib/puppet/module.rb
index 43266b2b5..059591ed8 100644
--- a/lib/puppet/module.rb
+++ b/lib/puppet/module.rb
@@ -1,204 +1,204 @@
 require 'puppet/util/logging'
 
 # Support for modules
 class Puppet::Module
   class Error < Puppet::Error; end
   class MissingModule < Error; end
   class IncompatibleModule < Error; end
   class UnsupportedPlatform < Error; end
   class IncompatiblePlatform < Error; end
   class MissingMetadata < Error; end
   class InvalidName < Error; end
 
   include Puppet::Util::Logging
 
   TEMPLATES = "templates"
   FILES = "files"
   MANIFESTS = "manifests"
   PLUGINS = "plugins"
 
   FILETYPES = [MANIFESTS, FILES, TEMPLATES, PLUGINS]
 
   # Return an array of paths by splitting the +modulepath+ config
   # parameter. Only consider paths that are absolute and existing
   # directories
   def self.modulepath(environment = nil)
     Puppet::Node::Environment.new(environment).modulepath
   end
 
   # Find and return the +module+ that +path+ belongs to. If +path+ is
   # absolute, or if there is no module whose name is the first component
   # of +path+, return +nil+
   def self.find(modname, environment = nil)
     return nil unless modname
     Puppet::Node::Environment.new(environment).module(modname)
   end
 
   attr_reader :name, :environment
   attr_writer :environment
 
   attr_accessor :source, :author, :version, :license, :puppetversion, :summary, :description, :project_page
 
   def has_metadata?
     return false unless metadata_file
 
     FileTest.exist?(metadata_file)
   end
 
   def initialize(name, environment = nil)
     @name = name
 
     assert_validity
 
     if environment.is_a?(Puppet::Node::Environment)
       @environment = environment
     else
       @environment = Puppet::Node::Environment.new(environment)
     end
 
     load_metadata if has_metadata?
 
     validate_puppet_version
     validate_dependencies
   end
 
   FILETYPES.each do |type|
     # A boolean method to let external callers determine if
     # we have files of a given type.
     define_method(type +'?') do
       return false unless path
       return false unless FileTest.exist?(subpath(type))
       return true
     end
 
     # A method for returning a given file of a given type.
     # e.g., file = mod.manifest("my/manifest.pp")
     #
     # If the file name is nil, then the base directory for the
     # file type is passed; this is used for fileserving.
     define_method(type.to_s.sub(/s$/, '')) do |file|
       return nil unless path
 
       # If 'file' is nil then they're asking for the base path.
       # This is used for things like fileserving.
       if file
         full_path = File.join(subpath(type), file)
       else
         full_path = subpath(type)
       end
 
       return nil unless FileTest.exist?(full_path)
       return full_path
     end
   end
 
   def exist?
     ! path.nil?
   end
 
   # Find the first 'files' directory.  This is used by the XMLRPC fileserver.
   def file_directory
     subpath("files")
   end
 
   def license_file
     return @license_file if defined?(@license_file)
 
     return @license_file = nil unless path
     @license_file = File.join(path, "License")
   end
 
   def load_metadata
     data = PSON.parse File.read(metadata_file)
     [:source, :author, :version, :license, :puppetversion].each do |attr|
       unless value = data[attr.to_s]
         unless attr == :puppetversion
           raise MissingMetadata, "No #{attr} module metadata provided for #{self.name}"
         end
       end
       send(attr.to_s + "=", value)
     end
   end
 
   # Return the list of manifests matching the given glob pattern,
   # defaulting to 'init.{pp,rb}' for empty modules.
   def match_manifests(rest)
     pat = File.join(path, MANIFESTS, rest || 'init')
     [manifest("init.pp"),manifest("init.rb")].compact + Dir.
       glob(pat + (File.extname(pat).empty? ? '.{pp,rb}' : '')).
       reject { |f| FileTest.directory?(f) }
   end
 
   def metadata_file
     return @metadata_file if defined?(@metadata_file)
 
     return @metadata_file = nil unless path
     @metadata_file = File.join(path, "metadata.json")
   end
 
   # Find this module in the modulepath.
   def path
-    environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.exist?(d) }
+    environment.modulepath.collect { |path| File.join(path, name) }.find { |d| FileTest.directory?(d) }
   end
 
   # Find all plugin directories.  This is used by the Plugins fileserving mount.
   def plugin_directory
     subpath("plugins")
   end
 
   def requires(name, version = nil)
     @requires ||= []
     @requires << [name, version]
   end
 
   def supports(name, version = nil)
     @supports ||= []
     @supports << [name, version]
   end
 
   def to_s
     result = "Module #{name}"
     result += "(#{path})" if path
     result
   end
 
   def validate_dependencies
     return unless defined?(@requires)
 
     @requires.each do |name, version|
       unless mod = environment.module(name)
         raise MissingModule, "Missing module #{name} required by #{self.name}"
       end
 
       if version and mod.version != version
         raise IncompatibleModule, "Required module #{name} is version #{mod.version} but #{self.name} requires #{version}"
       end
     end
   end
 
   def validate_puppet_version
     return unless puppetversion and puppetversion != Puppet.version
     raise IncompatibleModule, "Module #{self.name} is only compatible with Puppet version #{puppetversion}, not #{Puppet.version}"
   end
 
   private
 
   def subpath(type)
     return File.join(path, type) unless type.to_s == "plugins"
 
     backward_compatible_plugins_dir
   end
 
   def backward_compatible_plugins_dir
     if dir = File.join(path, "plugins") and FileTest.exist?(dir)
       Puppet.warning "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
       return dir
     else
       return File.join(path, "lib")
     end
   end
 
   def assert_validity
     raise InvalidName, "Invalid module name; module names must be alphanumeric (plus '-'), not '#{name}'" unless name =~ /^[-\w]+$/
   end
 end
diff --git a/lib/puppet/parser/type_loader.rb b/lib/puppet/parser/type_loader.rb
index 140c9f2ca..1fba73d0b 100644
--- a/lib/puppet/parser/type_loader.rb
+++ b/lib/puppet/parser/type_loader.rb
@@ -1,145 +1,173 @@
 require 'puppet/node/environment'
 
 class Puppet::Parser::TypeLoader
   include Puppet::Node::Environment::Helper
 
   # Helper class that makes sure we don't try to import the same file
   # more than once from either the same thread or different threads.
   class Helper
     include MonitorMixin
     def initialize
       super
       # These hashes are indexed by filename
       @state = {} # :doing or :done
       @thread = {} # if :doing, thread that's doing the parsing
       @cond_var = {} # if :doing, condition var that will be signaled when done.
     end
 
     # Execute the supplied block exactly once per file, no matter how
     # many threads have asked for it to run.  If another thread is
     # already executing it, wait for it to finish.  If this thread is
     # already executing it, return immediately without executing the
     # block.
     #
     # Note: the reason for returning immediately if this thread is
     # already executing the block is to handle the case of a circular
     # import--when this happens, we attempt to recursively re-parse a
     # file that we are already in the process of parsing.  To prevent
     # an infinite regress we need to simply do nothing when the
     # recursive import is attempted.
     def do_once(file)
       need_to_execute = synchronize do
         case @state[file]
         when :doing
           if @thread[file] != Thread.current
             @cond_var[file].wait
           end
           false
         when :done
           false
         else
           @state[file] = :doing
           @thread[file] = Thread.current
           @cond_var[file] = new_cond
           true
         end
       end
       if need_to_execute
         begin
           yield
         ensure
           synchronize do
             @state[file] = :done
             @thread.delete(file)
             @cond_var.delete(file).broadcast
           end
         end
       end
     end
   end
 
   # Import our files.
   def import(file, current_file = nil)
     return if Puppet[:ignoreimport]
 
     # use a path relative to the file doing the importing
     if current_file
       dir = current_file.sub(%r{[^/]+$},'').sub(/\/$/, '')
     else
       dir = "."
     end
     if dir == ""
       dir = "."
     end
 
     pat = file
     modname, files = Puppet::Parser::Files.find_manifests(pat, :cwd => dir, :environment => environment)
     if files.size == 0
       raise Puppet::ImportError.new("No file(s) found for import of '#{pat}'")
     end
 
     loaded_asts = []
     files.each do |file|
       unless file =~ /^#{File::SEPARATOR}/
         file = File.join(dir, file)
       end
       @loading_helper.do_once(file) do
         loaded_asts << parse_file(file)
       end
     end
     loaded_asts.inject([]) do |loaded_types, ast|
       loaded_types + known_resource_types.import_ast(ast, modname)
     end
   end
 
+  def import_all
+    require 'find'
+
+    module_names = []
+    # Collect the list of all known modules
+    environment.modulepath.each do |path|
+      Dir.chdir(path) do
+        Dir.glob("*").each do |dir|
+          next unless FileTest.directory?(dir)
+          module_names << dir
+        end
+      end
+    end
+
+    module_names.uniq!
+    # And then load all files from each module, but (relying on system
+    # behavior) only load files from the first module of a given name.  E.g.,
+    # given first/foo and second/foo, only files from first/foo will be loaded.
+    module_names.each do |name|
+      mod = Puppet::Module.new(name, environment)
+      Find.find(File.join(mod.path, "manifests")) do |path|
+        if path =~ /\.pp$/ or path =~ /\.rb$/
+          import(path)
+        end
+      end
+    end
+  end
+
   def known_resource_types
     environment.known_resource_types
   end
 
   def initialize(env)
     self.environment = env
     @loading_helper = Helper.new
   end
 
   # Try to load the object with the given fully qualified name.
   def try_load_fqname(type, fqname)
     return nil if fqname == "" # special-case main.
     name2files(fqname).each do |filename|
       begin
         imported_types = import(filename)
         if result = imported_types.find { |t| t.type == type and t.name == fqname }
           Puppet.debug "Automatically imported #{fqname} from #{filename} into #{environment}"
           return result
         end
       rescue Puppet::ImportError => detail
         # We couldn't load the item
         # I'm not convienced we should just drop these errors, but this
         # preserves existing behaviours.
       end
     end
     # Nothing found.
     return nil
   end
 
   def parse_file(file)
     Puppet.debug("importing '#{file}' in environment #{environment}")
     parser = Puppet::Parser::Parser.new(environment)
     parser.file = file
     return parser.parse
   end
 
   private
 
   # Return a list of all file basenames that should be tried in order
   # to load the object with the given fully qualified name.
   def name2files(fqname)
     result = []
     ary = fqname.split("::")
     while ary.length > 0
       result << ary.join(File::SEPARATOR)
       ary.pop
     end
     return result
   end
 
 end
diff --git a/lib/puppet/resource/type.rb b/lib/puppet/resource/type.rb
index b9cf6991a..48d8c1f48 100644
--- a/lib/puppet/resource/type.rb
+++ b/lib/puppet/resource/type.rb
@@ -1,349 +1,349 @@
 require 'puppet/parser/parser'
 require 'puppet/util/warnings'
 require 'puppet/util/errors'
 require 'puppet/util/inline_docs'
 require 'puppet/parser/ast/leaf'
 require 'puppet/dsl'
 
 class Puppet::Resource::Type
   Puppet::ResourceType = self
   include Puppet::Util::InlineDocs
   include Puppet::Util::Warnings
   include Puppet::Util::Errors
 
   RESOURCE_SUPERTYPES = [:hostclass, :node, :definition]
 
   attr_accessor :file, :line, :doc, :code, :ruby_code, :parent, :resource_type_collection
   attr_reader :type, :namespace, :arguments, :behaves_like, :module_name
 
   RESOURCE_SUPERTYPES.each do |t|
     define_method("#{t}?") { self.type == t }
   end
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource_type, :terminus_class => :parser
 
   def self.from_pson(data)
     name = data.delete('name') or raise ArgumentError, "Resource Type names must be specified"
     type = data.delete('type') || "definition"
 
     data = data.inject({}) { |result, ary| result[ary[0].intern] = ary[1]; result }
 
     new(type, name, data)
   end
 
   def to_pson_data_hash
-    data = [:code, :doc, :line, :file, :parent].inject({}) do |hash, param|
-      next hash unless value = self.send(param)
+    data = [:doc, :line, :file, :parent].inject({}) do |hash, param|
+      next hash unless (value = self.send(param)) and (value != "")
       hash[param.to_s] = value
       hash
     end
 
-    data['arguments'] = arguments.dup
+    data['arguments'] = arguments.dup unless arguments.empty?
 
     data['name'] = name
     data['type'] = type
 
     data
   end
 
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Are we a child of the passed class?  Do a recursive search up our
   # parentage tree to figure it out.
   def child_of?(klass)
     return false unless parent
 
     return(klass == parent_type ? true : parent_type.child_of?(klass))
   end
 
   # Now evaluate the code associated with this class or definition.
   def evaluate_code(resource)
     scope = resource.scope
 
     if tmp = evaluate_parent_type(resource)
       scope = tmp
     end
 
     scope = subscope(scope, resource) unless resource.title == :main
     scope.compiler.add_class(name) unless definition?
 
     set_resource_parameters(resource, scope)
 
     code.safeevaluate(scope) if code
 
     evaluate_ruby_code(resource, scope) if ruby_code
   end
 
   def initialize(type, name, options = {})
     @type = type.to_s.downcase.to_sym
     raise ArgumentError, "Invalid resource supertype '#{type}'" unless RESOURCE_SUPERTYPES.include?(@type)
 
     name = convert_from_ast(name) if name.is_a?(Puppet::Parser::AST::HostName)
 
     set_name_and_namespace(name)
 
     [:code, :doc, :line, :file, :parent].each do |param|
       next unless value = options[param]
       send(param.to_s + "=", value)
     end
 
     set_arguments(options[:arguments])
 
     @module_name = options[:module_name]
   end
 
   # This is only used for node names, and really only when the node name
   # is a regexp.
   def match(string)
     return string.to_s.downcase == name unless name_is_regex?
 
     @name =~ string
   end
 
   # Add code from a new instance to our code.
   def merge(other)
     fail "#{name} is not a class; cannot add code to it" unless type == :hostclass
     fail "#{other.name} is not a class; cannot add code from it" unless other.type == :hostclass
     fail "Cannot have code outside of a class/node/define because 'freeze_main' is enabled" if name == "" and Puppet.settings[:freeze_main]
 
     if parent and other.parent and parent != other.parent
       fail "Cannot merge classes with different parent classes (#{name} => #{parent} vs. #{other.name} => #{other.parent})"
     end
 
     # We know they're either equal or only one is set, so keep whichever parent is specified.
     self.parent ||= other.parent
 
     if other.doc
       self.doc ||= ""
       self.doc += other.doc
     end
 
     # This might just be an empty, stub class.
     return unless other.code
 
     unless self.code
       self.code = other.code
       return
     end
 
     array_class = Puppet::Parser::AST::ASTArray
     self.code = array_class.new(:children => [self.code]) unless self.code.is_a?(array_class)
 
     if other.code.is_a?(array_class)
       code.children += other.code.children
     else
       code.children << other.code
     end
   end
 
   # Make an instance of the resource type, and place it in the catalog
   # if it isn't in the catalog already.  This is only possible for
   # classes and nodes.  No parameters are be supplied--if this is a
   # parameterized class, then all parameters take on their default
   # values.
   def ensure_in_catalog(scope, parameters=nil)
     type == :definition and raise ArgumentError, "Cannot create resources for defined resource types"
     resource_type = type == :hostclass ? :class : :node
 
     # Do nothing if the resource already exists; this makes sure we don't
     # get multiple copies of the class resource, which helps provide the
     # singleton nature of classes.
     # we should not do this for classes with parameters
     # if parameters are passed, we should still try to create the resource
     # even if it exists so that we can fail
     # this prevents us from being able to combine param classes with include
     if resource = scope.catalog.resource(resource_type, name) and !parameters
       return resource
     end
     resource = Puppet::Parser::Resource.new(resource_type, name, :scope => scope, :source => self)
     if parameters
       parameters.each do |k,v|
         resource.set_parameter(k,v)
       end
     end
     instantiate_resource(scope, resource)
     scope.compiler.add_resource(scope, resource)
     resource
   end
 
   def instantiate_resource(scope, resource)
     # Make sure our parent class has been evaluated, if we have one.
     if parent && !scope.catalog.resource(resource.type, parent)
       parent_type(scope).ensure_in_catalog(scope)
     end
 
     if ['Class', 'Node'].include? resource.type
       scope.catalog.tag(*resource.tags)
     end
   end
 
   def name
     return @name unless @name.is_a?(Regexp)
     @name.source.downcase.gsub(/[^-\w:.]/,'').sub(/^\.+/,'')
   end
 
   def name_is_regex?
     @name.is_a?(Regexp)
   end
 
   # MQR TODO:
   #
   # The change(s) introduced by the fix for #4270 are mostly silly & should be 
   # removed, though we didn't realize it at the time.  If it can be established/
   # ensured that nodes never call parent_type and that resource_types are always
   # (as they should be) members of exactly one resource_type_collection the 
   # following method could / should be replaced with:
   #
   # def parent_type
   #   @parent_type ||= parent && (
   #     resource_type_collection.find_or_load([name],parent,type.to_sym) ||
   #     fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{resource_type_collection.environment}"
   #   )
   # end
   #
   # ...and then the rest of the changes around passing in scope reverted.
   #
   def parent_type(scope = nil)
     return nil unless parent
 
     unless @parent_type
       raise "Must pass scope to parent_type when called first time" unless scope
       unless @parent_type = scope.environment.known_resource_types.send("find_#{type}", [name], parent)
         fail Puppet::ParseError, "Could not find parent resource type '#{parent}' of type #{type} in #{scope.environment}"
       end
     end
 
     @parent_type
   end
 
   # Set any arguments passed by the resource as variables in the scope.
   def set_resource_parameters(resource, scope)
     set = {}
     resource.to_hash.each do |param, value|
       param = param.to_sym
       fail Puppet::ParseError, "#{resource.ref} does not accept attribute #{param}" unless valid_parameter?(param)
 
       exceptwrap { scope.setvar(param.to_s, value) }
 
       set[param] = true
     end
 
     if @type == :hostclass
       scope.setvar("title", resource.title.to_s.downcase) unless set.include? :title
       scope.setvar("name",  resource.name.to_s.downcase ) unless set.include? :name
     else
       scope.setvar("title", resource.title              ) unless set.include? :title
       scope.setvar("name",  resource.name               ) unless set.include? :name
     end
     scope.setvar("module_name", module_name) if module_name and ! set.include? :module_name
 
     if caller_name = scope.parent_module_name and ! set.include?(:caller_module_name)
       scope.setvar("caller_module_name", caller_name)
     end
     scope.class_set(self.name,scope) if hostclass? or node?
     # Verify that all required arguments are either present or
     # have been provided with defaults.
     arguments.each do |param, default|
       param = param.to_sym
       next if set.include?(param)
 
       # Even if 'default' is a false value, it's an AST value, so this works fine
       fail Puppet::ParseError, "Must pass #{param} to #{resource.ref}" unless default
 
       value = default.safeevaluate(scope)
       scope.setvar(param.to_s, value)
 
       # Set it in the resource, too, so the value makes it to the client.
       resource[param] = value
     end
 
   end
 
   # Create a new subscope in which to evaluate our code.
   def subscope(scope, resource)
     scope.newscope :resource => resource, :namespace => self.namespace, :source => self
   end
 
   # Check whether a given argument is valid.
   def valid_parameter?(param)
     param = param.to_s
 
     return true if param == "name"
     return true if Puppet::Type.metaparam?(param)
     return false unless defined?(@arguments)
     return(arguments.include?(param) ? true : false)
   end
 
   def set_arguments(arguments)
     @arguments = {}
     return if arguments.nil?
 
     arguments.each do |arg, default|
       arg = arg.to_s
       warn_if_metaparam(arg, default)
       @arguments[arg] = default
     end
   end
 
   private
 
   def convert_from_ast(name)
     value = name.value
     if value.is_a?(Puppet::Parser::AST::Regex)
       name = value.value
     else
       name = value
     end
   end
 
   def evaluate_parent_type(resource)
     return unless klass = parent_type(resource.scope) and parent_resource = resource.scope.compiler.catalog.resource(:class, klass.name) || resource.scope.compiler.catalog.resource(:node, klass.name)
     parent_resource.evaluate unless parent_resource.evaluated?
     parent_scope(resource.scope, klass)
   end
 
   def evaluate_ruby_code(resource, scope)
     Puppet::DSL::ResourceAPI.new(resource, scope, ruby_code).evaluate
   end
 
   # Split an fq name into a namespace and name
   def namesplit(fullname)
     ary = fullname.split("::")
     n = ary.pop || ""
     ns = ary.join("::")
     return ns, n
   end
 
   def parent_scope(scope, klass)
     scope.class_scope(klass) || raise(Puppet::DevError, "Could not find scope for #{klass.name}")
   end
 
   def set_name_and_namespace(name)
     if name.is_a?(Regexp)
       @name = name
       @namespace = ""
     else
       @name = name.to_s.downcase
 
       # Note we're doing something somewhat weird here -- we're setting
       # the class's namespace to its fully qualified name.  This means
       # anything inside that class starts looking in that namespace first.
       @namespace, ignored_shortname = @type == :hostclass ? [@name, ''] : namesplit(@name)
     end
   end
 
   def warn_if_metaparam(param, default)
     return unless Puppet::Type.metaparamclass(param)
 
     if default
       warnonce "#{param} is a metaparam; this value will inherit to all contained resources"
     else
       raise Puppet::ParseError, "#{param} is a metaparameter; please choose another parameter name in the #{self.name} definition"
     end
   end
 end
 
diff --git a/spec/unit/indirector/resource_type/parser_spec.rb b/spec/unit/indirector/resource_type/parser_spec.rb
index 739e58b35..27e61486c 100755
--- a/spec/unit/indirector/resource_type/parser_spec.rb
+++ b/spec/unit/indirector/resource_type/parser_spec.rb
@@ -1,75 +1,123 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../../spec_helper')
 
 require 'puppet/indirector/resource_type/parser'
+require 'puppet_spec/files'
 
 describe Puppet::Indirector::ResourceType::Parser do
+  include PuppetSpec::Files
+
   before do
     @terminus = Puppet::Indirector::ResourceType::Parser.new
     @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo")
-    @krt = Puppet::Resource::TypeCollection.new(@request.environment)
-    @request.environment.stubs(:known_resource_types).returns @krt
+    @krt = @request.environment.known_resource_types
   end
 
   it "should be registered with the resource_type indirection" do
     Puppet::Indirector::Terminus.terminus_class(:resource_type, :parser).should equal(Puppet::Indirector::ResourceType::Parser)
   end
 
   describe "when finding" do
-    it "should use the request's environment's list of known resource types" do
-      @request.environment.known_resource_types.expects(:hostclass).returns nil
+    it "should return any found type from the request's environment" do
+      type = Puppet::Resource::Type.new(:hostclass, "foo")
+      @request.environment.known_resource_types.add(type)
 
-      @terminus.find(@request)
+      @terminus.find(@request).should == type
     end
 
-    it "should return any found type" do
-      type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+    it "should attempt to load the type if none is found in memory" do
+      dir = tmpdir("find_a_type")
+      FileUtils.mkdir_p(dir)
+      Puppet[:modulepath] = dir
 
-      @terminus.find(@request).should == type
+      # Make a new request, since we've reset the env
+      @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar")
+
+      manifest_path = File.join(dir, "foo", "manifests")
+      FileUtils.mkdir_p(manifest_path)
+
+      File.open(File.join(manifest_path, "bar.pp"), "w") { |f| f.puts "class foo::bar {}" }
+
+      result = @terminus.find(@request)
+      result.should be_instance_of(Puppet::Resource::Type)
+      result.name.should == "foo::bar"
     end
 
     it "should return nil if no type can be found" do
       @terminus.find(@request).should be_nil
     end
 
     it "should prefer definitions to nodes" do
       type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       node = @krt.add(Puppet::Resource::Type.new(:node, "foo"))
 
       @terminus.find(@request).should == type
     end
   end
 
   describe "when searching" do
     before do
       @request.key = "*"
     end
 
     it "should use the request's environment's list of known resource types" do
       @request.environment.known_resource_types.expects(:hostclasses).returns({})
 
       @terminus.search(@request)
     end
 
     it "should fail if anyther other than '*' was provided as the search key" do
       @request.key = "foo*"
       lambda { @terminus.search(@request) }.should raise_error(ArgumentError)
     end
 
     it "should return all known types" do
       type = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
       node = @krt.add(Puppet::Resource::Type.new(:node, "bar"))
       define = @krt.add(Puppet::Resource::Type.new(:definition, "baz"))
 
       result = @terminus.search(@request)
       result.should be_include(type)
       result.should be_include(node)
       result.should be_include(define)
     end
 
+    it "should not return the 'main' class" do
+      main = @krt.add(Puppet::Resource::Type.new(:hostclass, ""))
+
+      # So there is a return value
+      foo = @krt.add(Puppet::Resource::Type.new(:hostclass, "foo"))
+
+      @terminus.search(@request).should_not be_include(main)
+    end
+
     it "should return nil if no types can be found" do
       @terminus.search(@request).should be_nil
     end
+
+    it "should load all resource types from all search paths" do
+      dir = tmpdir("searching_in_all")
+      first = File.join(dir, "first")
+      second = File.join(dir, "second")
+      FileUtils.mkdir_p(first)
+      FileUtils.mkdir_p(second)
+      Puppet[:modulepath] = "#{first}:#{second}"
+
+      # Make a new request, since we've reset the env
+      @request = Puppet::Indirector::Request.new(:resource_type, :search, "*")
+
+      onepath = File.join(first, "one", "manifests")
+      FileUtils.mkdir_p(onepath)
+      twopath = File.join(first, "two", "manifests")
+      FileUtils.mkdir_p(twopath)
+
+      File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
+      File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
+
+      result = @terminus.search(@request)
+      result.find { |t| t.name == "one::oneklass" }.should be_instance_of(Puppet::Resource::Type)
+      result.find { |t| t.name == "two::twoklass" }.should be_instance_of(Puppet::Resource::Type)
+    end
   end
 end
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index 54f5444ee..f3120e16b 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -1,545 +1,570 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'puppet_spec/files'
 
 describe Puppet::Module do
+  include PuppetSpec::Files
+
   before do
     # This is necessary because of the extra checks we have for the deprecated
     # 'plugins' directory
     FileTest.stubs(:exist?).returns false
   end
 
   it "should have a class method that returns a named module from a given environment" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns "yep"
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should == "yep"
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
     env = mock 'module'
     env.expects(:module).with("mymod").returns nil
     Puppet::Node::Environment.expects(:new).with("myenv").returns env
 
     Puppet::Module.find("mymod", "myenv").should be_nil
   end
 
   it "should support a 'version' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.version = 1.09
     mod.version.should == 1.09
   end
 
   it "should support a 'source' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.source = "http://foo/bar"
     mod.source.should == "http://foo/bar"
   end
 
   it "should support a 'project_page' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.project_page = "http://foo/bar"
     mod.project_page.should == "http://foo/bar"
   end
 
   it "should support an 'author' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.author = "Luke Kanies <luke@madstop.com>"
     mod.author.should == "Luke Kanies <luke@madstop.com>"
   end
 
   it "should support a 'license' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.license = "GPL2"
     mod.license.should == "GPL2"
   end
 
   it "should support a 'summary' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.summary = "GPL2"
     mod.summary.should == "GPL2"
   end
 
   it "should support a 'description' attribute" do
     mod = Puppet::Module.new("mymod")
     mod.description = "GPL2"
     mod.description.should == "GPL2"
   end
 
   it "should support specifying a compatible puppet version" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     mod.puppetversion.should == "0.25"
   end
 
   it "should validate that the puppet version is compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.expects(:version).returns "0.25"
     mod.validate_puppet_version
   end
 
   it "should fail if the specified puppet version is not compatible" do
     mod = Puppet::Module.new("mymod")
     mod.puppetversion = "0.25"
     Puppet.stubs(:version).returns "0.24"
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
   describe "when specifying required modules" do
     it "should support specifying a required module" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
     end
 
     it "should support specifying multiple required modules" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
     end
 
     it "should support specifying a required module and version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
     end
 
     it "should fail when required modules are missing" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
 
       mod.environment.expects(:module).with("foobar").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should fail when required modules are present but of the wrong version" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 2.0
 
       mod.environment.expects(:module).with("foobar").returns foobar
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::IncompatibleModule)
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
       mod = Puppet::Module.new("mymod")
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should fail when some dependencies are present but others aren't" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar"
       mod.requires "baz"
 
       mod.environment.expects(:module).with("foobar").returns Puppet::Module.new("foobar")
       mod.environment.expects(:module).with("baz").returns nil
 
       lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
     end
 
     it "should have valid dependencies when all dependencies are met" do
       mod = Puppet::Module.new("mymod")
       mod.requires "foobar", 1.0
       mod.requires "baz"
 
       foobar = Puppet::Module.new("foobar")
       foobar.version = 1.0
 
       baz = Puppet::Module.new("baz")
 
       mod.environment.expects(:module).with("foobar").returns foobar
       mod.environment.expects(:module).with("baz").returns baz
 
       lambda { mod.validate_dependencies }.should_not raise_error
     end
 
     it "should validate its dependendencies on initialization" do
       Puppet::Module.any_instance.expects(:validate_dependencies)
       Puppet::Module.new("mymod")
     end
   end
 
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris"
     end
 
     it "should support specifying a supported platform and version" do
       mod = Puppet::Module.new("mymod")
       mod.supports "solaris", 1.0
     end
 
     it "should fail when not running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
 
       mod.supports "hpux"
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::UnsupportedPlatform)
     end
 
     it "should fail when supported platforms are present but of the wrong version" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when no supported platforms have been specified" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       lambda { mod.validate_supported_platform }.should_not raise_error
     end
 
     it "should be considered supported when running on a supported platform" do
       pending "Not sure how to send client platform to the module"
       mod = Puppet::Module.new("mymod")
       Facter.expects(:value).with("operatingsystem").returns "Solaris"
       Facter.expects(:value).with("operatingsystemrelease").returns 2.0
 
       mod.supports "Solaris", 1.0
 
       lambda { mod.validate_supported_platform }.should raise_error(Puppet::Module::IncompatiblePlatform)
     end
 
     it "should be considered supported when running on any of multiple supported platforms" do
       pending "Not sure how to send client platform to the module"
     end
 
     it "should validate its platform support on initialization" do
       pending "Not sure how to send client platform to the module"
     end
   end
 
   it "should return nil if asked for a module whose name is 'nil'" do
     Puppet::Module.find(nil, "myenv").should be_nil
   end
 
   it "should provide support for logging" do
     Puppet::Module.ancestors.should be_include(Puppet::Util::Logging)
   end
 
   it "should be able to be converted to a string" do
     Puppet::Module.new("foo").to_s.should == "Module foo"
   end
 
   it "should add the path to its string form if the module is found" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a"
     mod.to_s.should == "Module foo(/a)"
   end
 
   it "should fail if its name is not alphanumeric" do
     lambda { Puppet::Module.new(".something") }.should raise_error(Puppet::Module::InvalidName)
   end
 
   it "should require a name at initialization" do
     lambda { Puppet::Module.new }.should raise_error(ArgumentError)
   end
 
   it "should convert an environment name into an Environment instance" do
     Puppet::Module.new("foo", "prod").environment.should be_instance_of(Puppet::Node::Environment)
   end
 
   it "should accept an environment at initialization" do
     Puppet::Module.new("foo", :prod).environment.name.should == :prod
   end
 
   it "should use the default environment if none is provided" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo").environment.should equal(env)
   end
 
   it "should use any provided Environment instance" do
     env = Puppet::Node::Environment.new
     Puppet::Module.new("foo", env).environment.should equal(env)
   end
 
   it "should return the path to the first found instance in its environment's module paths as its path" do
+    dir = tmpdir("deep_path")
+    first = File.join(dir, "first")
+    second = File.join(dir, "second")
+
+    FileUtils.mkdir_p(first)
+    FileUtils.mkdir_p(second)
+    Puppet[:modulepath] = "#{first}:#{second}"
+
+    modpath = File.join(first, "foo")
+    FileUtils.mkdir_p(modpath)
+
+    # Make a second one, which we shouldn't find
+    FileUtils.mkdir_p(File.join(second, "foo"))
+
     mod = Puppet::Module.new("foo")
-    env = mock 'environment'
-    mod.stubs(:environment).returns env
+    mod.path.should == modpath
+  end
+
+  it "should be able to find itself in a directory other than the first directory in the module path" do
+    dir = tmpdir("deep_path")
+    first = File.join(dir, "first")
+    second = File.join(dir, "second")
 
-    env.expects(:modulepath).returns %w{/a /b /c}
+    FileUtils.mkdir_p(first)
+    FileUtils.mkdir_p(second)
+    Puppet[:modulepath] = "#{first}:#{second}"
 
-    FileTest.expects(:exist?).with("/a/foo").returns false
-    FileTest.expects(:exist?).with("/b/foo").returns true
-    FileTest.expects(:exist?).with("/c/foo").never
+    modpath = File.join(second, "foo")
+    FileUtils.mkdir_p(modpath)
 
-    mod.path.should == "/b/foo"
+    mod = Puppet::Module.new("foo")
+    mod.should be_exist
+    mod.path.should == modpath
   end
 
   it "should be considered existent if it exists in at least one module path" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns "/a/foo"
     mod.should be_exist
   end
 
   it "should be considered nonexistent if it does not exist in any of the module paths" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns nil
     mod.should_not be_exist
   end
 
   [:plugins, :templates, :files, :manifests].each do |filetype|
     dirname = filetype == :plugins ? "lib" : filetype.to_s
     it "should be able to return individual #{filetype}" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should == path
     end
 
     it "should consider #{filetype} to be present if their base directory exists" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns true
       mod.send(filetype.to_s + "?").should be_true
     end
 
     it "should consider #{filetype} to be absent if their base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should consider #{filetype} to be absent if the module base directory does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s + "?").should be_false
     end
 
     it "should return nil if asked to return individual #{filetype} that don't exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       path = File.join("/a/foo", dirname, "my/file")
       FileTest.expects(:exist?).with(path).returns false
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return nil when asked for individual #{filetype} if the module does not exist" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns nil
       mod.send(filetype.to_s.sub(/s$/, ''), "my/file").should be_nil
     end
 
     it "should return the base directory if asked for a nil path" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
       base = File.join("/a/foo", dirname)
       FileTest.expects(:exist?).with(base).returns true
       mod.send(filetype.to_s.sub(/s$/, ''), nil).should == base
     end
   end
 
   %w{plugins files}.each do |filetype|
     short = filetype.sub(/s$/, '')
     dirname = filetype == "plugins" ? "lib" : filetype.to_s
     it "should be able to return the #{short} directory" do
       Puppet::Module.new("foo").should respond_to(short + "_directory")
     end
 
     it "should return the path to the #{short} directory" do
       mod = Puppet::Module.new("foo")
       mod.stubs(:path).returns "/a/foo"
 
       mod.send(short + "_directory").should == "/a/foo/#{dirname}"
     end
   end
 
   it "should throw a warning if plugins are in a 'plugins' directory rather than a 'lib' directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     FileTest.expects(:exist?).with("/a/foo/plugins").returns true
 
     mod.plugin_directory.should == "/a/foo/plugins"
     @logs.first.message.should == "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
     @logs.first.level.should == :warning
   end
 
   it "should default to 'lib' for the plugins directory" do
     mod = Puppet::Module.new("foo")
     mod.stubs(:path).returns "/a/foo"
     mod.plugin_directory.should == "/a/foo/lib"
   end
 end
 
 describe Puppet::Module, " when building its search path" do
   it "should use the current environment's search path if no environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with(nil).returns env
 
     Puppet::Module.modulepath.should == "eh"
   end
 
   it "should use the specified environment's search path if an environment is specified" do
     env = mock 'env'
     env.expects(:modulepath).returns "eh"
     Puppet::Node::Environment.expects(:new).with("foo").returns env
 
     Puppet::Module.modulepath("foo").should == "eh"
   end
 end
 
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod")
     @mod.stubs(:path).returns "/a"
     @pq_glob_with_extension = "yay/*.xx"
     @fq_glob_with_extension = "/a/manifests/#{@pq_glob_with_extension}"
   end
 
   it "should return all manifests matching the glob pattern" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
     FileTest.stubs(:directory?).returns false
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo bar}
   end
 
   it "should not return directories" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{foo bar})
 
     FileTest.expects(:directory?).with("foo").returns false
     FileTest.expects(:directory?).with("bar").returns true
     @mod.match_manifests(@pq_glob_with_extension).should == %w{foo}
   end
 
   it "should default to the 'init' file if no glob pattern is specified" do
     Dir.expects(:glob).with("/a/manifests/init.{pp,rb}").returns(%w{/a/manifests/init.pp})
 
     @mod.match_manifests(nil).should == %w{/a/manifests/init.pp}
   end
 
   it "should return all manifests matching the glob pattern in all existing paths" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns(%w{a b})
 
     @mod.match_manifests(@pq_glob_with_extension).should == %w{a b}
   end
 
   it "should match the glob pattern plus '.{pp,rb}' if no extention is specified" do
     Dir.expects(:glob).with("/a/manifests/yay/foo.{pp,rb}").returns(%w{yay})
 
     @mod.match_manifests("yay/foo").should == %w{yay}
   end
 
   it "should return an empty array if no manifests matched" do
     Dir.expects(:glob).with(@fq_glob_with_extension).returns([])
 
     @mod.match_manifests(@pq_glob_with_extension).should == []
   end
 end
 
 describe Puppet::Module do
   before do
     Puppet::Module.any_instance.stubs(:path).returns "/my/mod/path"
     @module = Puppet::Module.new("foo")
   end
 
   it "should use 'License' in its current path as its metadata file" do
     @module.license_file.should == "/my/mod/path/License"
   end
 
   it "should return nil as its license file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").license_file.should be_nil
   end
 
   it "should cache the license file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.license_file.should == mod.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
     @module.metadata_file.should == "/my/mod/path/metadata.json"
   end
 
   it "should return nil as its metadata file when the module has no path" do
     Puppet::Module.any_instance.stubs(:path).returns nil
     Puppet::Module.new("foo").metadata_file.should be_nil
   end
 
   it "should cache the metadata file" do
     Puppet::Module.any_instance.expects(:path).once.returns nil
     mod = Puppet::Module.new("foo")
     mod.metadata_file.should == mod.metadata_file
   end
 
   it "should know if it has a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns true
 
     @module.should be_has_metadata
   end
 
   it "should know if it is missing a metadata file" do
     FileTest.expects(:exist?).with(@module.metadata_file).returns false
 
     @module.should_not be_has_metadata
   end
 
   it "should be able to parse its metadata file" do
     @module.should respond_to(:load_metadata)
   end
 
   it "should parse its metadata file on initialization if it is present" do
     Puppet::Module.any_instance.expects(:has_metadata?).returns true
     Puppet::Module.any_instance.expects(:load_metadata)
 
     Puppet::Module.new("yay")
   end
 
   describe "when loading the medatada file", :if => Puppet.features.json? do
     before do
       @data = {
         :license => "GPL2",
         :author => "luke",
         :version => "1.0",
         :source => "http://foo/",
         :puppetversion => "0.25"
       }
       @text = @data.to_json
 
       @module = Puppet::Module.new("foo")
       @module.stubs(:metadata_file).returns "/my/file"
       File.stubs(:read).with("/my/file").returns @text
     end
 
     %w{source author version license}.each do |attr|
       it "should set #{attr} if present in the metadata file" do
         @module.load_metadata
         @module.send(attr).should == @data[attr.to_sym]
       end
 
       it "should fail if #{attr} is not present in the metadata file" do
         @data.delete(attr.to_sym)
         @text = @data.to_json
         File.stubs(:read).with("/my/file").returns @text
         lambda { @module.load_metadata }.should raise_error(Puppet::Module::MissingMetadata)
       end
     end
 
     it "should set puppetversion if present in the metadata file" do
       @module.load_metadata
       @module.puppetversion.should == @data[:puppetversion]
     end
 
 
     it "should fail if the discovered name is different than the metadata name"
   end
 end
diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index bd41adfb6..12bc1ccd6 100644
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -1,134 +1,231 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/parser/type_loader'
 require 'puppet_spec/files'
 
 describe Puppet::Parser::TypeLoader do
   include PuppetSpec::Files
 
   before do
     @loader = Puppet::Parser::TypeLoader.new(:myenv)
   end
 
   it "should support an environment" do
     loader = Puppet::Parser::TypeLoader.new(:myenv)
     loader.environment.name.should == :myenv
   end
 
   it "should include the Environment Helper" do
     @loader.class.ancestors.should be_include(Puppet::Node::Environment::Helper)
   end
 
   it "should delegate its known resource types to its environment" do
     @loader.known_resource_types.should be_instance_of(Puppet::Resource::TypeCollection)
   end
 
   describe "when loading names from namespaces" do
     it "should do nothing if the name to import is an empty string" do
       @loader.expects(:name2files).never
       @loader.try_load_fqname(:hostclass, "") { |filename, modname| raise :should_not_occur }.should be_nil
     end
 
     it "should attempt to import each generated name" do
       @loader.expects(:import).with("foo/bar",nil).returns([])
       @loader.expects(:import).with("foo",nil).returns([])
       @loader.try_load_fqname(:hostclass, "foo::bar") { |f| false }
     end
   end
 
   describe "when importing" do
     before do
       Puppet::Parser::Files.stubs(:find_manifests).returns ["modname", %w{file}]
       Puppet::Parser::Parser.any_instance.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       Puppet::Parser::Parser.any_instance.stubs(:file=)
     end
 
     it "should return immediately when imports are being ignored" do
       Puppet::Parser::Files.expects(:find_manifests).never
       Puppet[:ignoreimport] = true
       @loader.import("foo").should be_nil
     end
 
     it "should find all manifests matching the file or pattern" do
       Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| pat == "myfile" }.returns ["modname", %w{one}]
       @loader.import("myfile")
     end
 
     it "should use the directory of the current file if one is set" do
       Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:cwd] == "/current" }.returns ["modname", %w{one}]
       @loader.import("myfile", "/current/file")
     end
 
     it "should pass the environment when looking for files" do
       Puppet::Parser::Files.expects(:find_manifests).with { |pat, opts| opts[:environment] == @loader.environment }.returns ["modname", %w{one}]
       @loader.import("myfile")
     end
 
     it "should fail if no files are found" do
       Puppet::Parser::Files.expects(:find_manifests).returns [nil, []]
       lambda { @loader.import("myfile") }.should raise_error(Puppet::ImportError)
     end
 
     it "should parse each found file" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
       @loader.expects(:parse_file).with("/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
     end
 
     it "should make each file qualified before attempting to parse it" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{one}]
       @loader.expects(:parse_file).with("/current/one").returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile", "/current/file")
     end
 
     it "should not attempt to import files that have already been imported" do
       Puppet::Parser::Files.expects(:find_manifests).returns ["modname", %w{/one}]
       Puppet::Parser::Parser.any_instance.expects(:parse).once.returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile")
 
       # This will fail if it tries to reimport the file.
       @loader.import("myfile")
     end
   end
 
+  describe "when importing all" do
+    before do
+      @base = tmpdir("base")
+
+      # Create two module path directories
+      @modulebase1 = File.join(@base, "first")
+      FileUtils.mkdir_p(@modulebase1)
+      @modulebase2 = File.join(@base, "second")
+      FileUtils.mkdir_p(@modulebase2)
+
+      Puppet[:modulepath] = "#{@modulebase1}:#{@modulebase2}"
+    end
+
+    def mk_module(basedir, name)
+      module_dir = File.join(basedir, name)
+
+      # Go ahead and make our manifest directory
+      FileUtils.mkdir_p(File.join(module_dir, "manifests"))
+
+      return Puppet::Module.new(name)
+    end
+
+    # We have to pass the base path so that we can
+    # write to modules that are in the second search path
+    def mk_manifests(base, mod, type, files)
+      exts = {"ruby" => ".rb", "puppet" => ".pp"}
+      files.collect do |file|
+        name = mod.name + "::" + file.gsub("/", "::")
+        path = File.join(base, mod.name, "manifests", file + exts[type])
+        FileUtils.mkdir_p(File.split(path)[0])
+
+        # write out the class
+        if type == "ruby"
+          File.open(path, "w") { |f| f.print "hostclass '#{name}' do\nend" }
+        else
+          File.open(path, "w") { |f| f.print "class #{name} {}" }
+        end
+        name
+      end
+    end
+
+    it "should load all puppet manifests from all modules in the specified environment" do
+      @module1 = mk_module(@modulebase1, "one")
+      @module2 = mk_module(@modulebase2, "two")
+
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a b})
+      mk_manifests(@modulebase2, @module2, "puppet", %w{c d})
+
+      @loader.import_all
+
+      @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+    end
+
+    it "should load all ruby manifests from all modules in the specified environment" do
+      @module1 = mk_module(@modulebase1, "one")
+      @module2 = mk_module(@modulebase2, "two")
+
+      mk_manifests(@modulebase1, @module1, "ruby", %w{a b})
+      mk_manifests(@modulebase2, @module2, "ruby", %w{c d})
+
+      @loader.import_all
+
+      @loader.environment.known_resource_types.hostclass("one::a").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("one::b").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("two::c").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("two::d").should be_instance_of(Puppet::Resource::Type)
+    end
+
+    it "should not load manifests from duplicate modules later in the module path" do
+      @module1 = mk_module(@modulebase1, "one")
+
+      # duplicate
+      @module2 = mk_module(@modulebase2, "one")
+
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a})
+      mk_manifests(@modulebase2, @module2, "puppet", %w{c})
+
+      @loader.import_all
+
+      @loader.environment.known_resource_types.hostclass("one::c").should be_nil
+    end
+
+    it "should load manifests from subdirectories" do
+      @module1 = mk_module(@modulebase1, "one")
+
+      mk_manifests(@modulebase1, @module1, "puppet", %w{a a/b a/b/c})
+
+      @loader.import_all
+
+      @loader.environment.known_resource_types.hostclass("one::a::b").should be_instance_of(Puppet::Resource::Type)
+      @loader.environment.known_resource_types.hostclass("one::a::b::c").should be_instance_of(Puppet::Resource::Type)
+    end
+  end
+
   describe "when parsing a file" do
     before do
       @parser = Puppet::Parser::Parser.new(@loader.environment)
       @parser.stubs(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @parser.stubs(:file=)
       Puppet::Parser::Parser.stubs(:new).with(@loader.environment).returns @parser
     end
 
     it "should create a new parser instance for each file using the current environment" do
       Puppet::Parser::Parser.expects(:new).with(@loader.environment).returns @parser
       @loader.parse_file("/my/file")
     end
 
     it "should assign the parser its file and parse" do
       @parser.expects(:file=).with("/my/file")
       @parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.parse_file("/my/file")
     end
   end
 
   it "should be able to add classes to the current resource type collection" do
     file = tmpfile("simple_file.pp")
     File.open(file, "w") { |f| f.puts "class foo {}" }
     @loader.import(file)
 
     @loader.known_resource_types.hostclass("foo").should be_instance_of(Puppet::Resource::Type)
   end
 
   describe "when deciding where to look for files" do
     { 'foo' => ['foo'],
       'foo::bar' => ['foo/bar', 'foo'],
       'foo::bar::baz' => ['foo/bar/baz', 'foo/bar', 'foo']
     }.each do |fqname, expected_paths|
       it "should look for #{fqname.inspect} in #{expected_paths.inspect}" do
         @loader.instance_eval { name2files(fqname) }.should == expected_paths
       end
     end
   end
 end
diff --git a/spec/unit/resource/type_spec.rb b/spec/unit/resource/type_spec.rb
index e9c203526..41b5554d9 100755
--- a/spec/unit/resource/type_spec.rb
+++ b/spec/unit/resource/type_spec.rb
@@ -1,785 +1,797 @@
 #!/usr/bin/env ruby
 
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
 require 'puppet/resource/type'
 
 describe Puppet::Resource::Type do
   it "should have a 'name' attribute" do
     Puppet::Resource::Type.new(:hostclass, "foo").name.should == "foo"
   end
 
   [:code, :doc, :line, :file, :resource_type_collection, :ruby_code].each do |attr|
     it "should have a '#{attr}' attribute" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       type.send(attr.to_s + "=", "yay")
       type.send(attr).should == "yay"
     end
   end
 
   [:hostclass, :node, :definition].each do |type|
     it "should know when it is a #{type}" do
       Puppet::Resource::Type.new(type, "foo").send("#{type}?").should be_true
     end
   end
 
   it "should indirect 'resource_type'" do
     Puppet::Resource::Type.indirection.name.should == :resource_type
   end
 
   it "should default to 'parser' for its terminus class" do
     Puppet::Resource::Type.indirection.terminus_class.should == :parser
   end
 
   describe "when converting to json" do
     before do
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     def from_json(json)
       Puppet::Resource::Type.from_pson(json)
     end
 
     def double_convert
       Puppet::Resource::Type.from_pson(PSON.parse(@type.to_pson))
     end
 
     it "should include the name and type" do
       double_convert.name.should == @type.name
       double_convert.type.should == @type.type
     end
 
     it "should include any arguments" do
       @type.set_arguments("one" => nil, "two" => "foo")
 
       double_convert.arguments.should == {"one" => nil, "two" => "foo"}
     end
 
-    it "should include any extra attributes" do
-      @type.file = "/my/file"
-      @type.line = 50
+    it "should not include arguments if none are present" do
+      @type.to_pson["arguments"].should be_nil
+    end
+
+    [:line, :doc, :file, :parent].each do |attr|
+      it "should include #{attr} when set" do
+        @type.send(attr.to_s + "=", "value")
+        double_convert.send(attr).should == "value"
+      end
+
+      it "should not include #{attr} when not set" do
+        @type.to_pson[attr.to_s].should be_nil
+      end
+    end
 
-      double_convert.file.should == "/my/file"
-      double_convert.line.should == 50
+    it "should not include docs if they are empty" do
+      @type.doc = ""
+      @type.to_pson["doc"].should be_nil
     end
   end
 
   describe "when a node"  do
     it "should allow a regex as its name" do
       lambda { Puppet::Resource::Type.new(:node, /foo/) }.should_not raise_error
     end
 
     it "should allow a AST::HostName instance as its name" do
       regex = Puppet::Parser::AST::Regex.new(:value => /foo/)
       name = Puppet::Parser::AST::HostName.new(:value => regex)
       lambda { Puppet::Resource::Type.new(:node, name) }.should_not raise_error
     end
 
     it "should match against the regexp in the AST::HostName when a HostName instance is provided" do
       regex = Puppet::Parser::AST::Regex.new(:value => /\w/)
       name = Puppet::Parser::AST::HostName.new(:value => regex)
       node = Puppet::Resource::Type.new(:node, name)
 
       node.match("foo").should be_true
     end
 
     it "should return the value of the hostname if provided a string-form AST::HostName instance as the name" do
       name = Puppet::Parser::AST::HostName.new(:value => "foo")
       node = Puppet::Resource::Type.new(:node, name)
 
       node.name.should == "foo"
     end
 
     describe "and the name is a regex" do
       it "should have a method that indicates that this is the case" do
         Puppet::Resource::Type.new(:node, /w/).should be_name_is_regex
       end
 
       it "should set its namespace to ''" do
         Puppet::Resource::Type.new(:node, /w/).namespace.should == ""
       end
 
       it "should return the regex converted to a string when asked for its name" do
         Puppet::Resource::Type.new(:node, /ww/).name.should == "ww"
       end
 
       it "should downcase the regex when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /W/).name.should == "w"
       end
 
       it "should remove non-alpha characters when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /w*w/).name.should_not include("*")
       end
 
       it "should remove leading dots when returning the name as a string" do
         Puppet::Resource::Type.new(:node, /.ww/).name.should_not =~ /^\./
       end
 
       it "should have a method for matching its regex name against a provided name" do
         Puppet::Resource::Type.new(:node, /.ww/).should respond_to(:match)
       end
 
       it "should return true when its regex matches the provided name" do
         Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
       end
 
       it "should return false when its regex does not match the provided name" do
         (!!Puppet::Resource::Type.new(:node, /\d/).match("foo")).should be_false
       end
 
       it "should return true when its name, as a string, is matched against an equal string" do
         Puppet::Resource::Type.new(:node, "foo").match("foo").should be_true
       end
 
       it "should return false when its name is matched against an unequal string" do
         Puppet::Resource::Type.new(:node, "foo").match("bar").should be_false
       end
 
       it "should match names insensitive to case" do
         Puppet::Resource::Type.new(:node, "fOo").match("foO").should be_true
       end
     end
 
     it "should return the name converted to a string when the name is not a regex" do
       pending "Need to define LoadedCode behaviour first"
       name = Puppet::Parser::AST::HostName.new(:value => "foo")
       Puppet::Resource::Type.new(:node, name).name.should == "foo"
     end
 
     it "should return the name converted to a string when the name is a regex" do
       pending "Need to define LoadedCode behaviour first"
       name = Puppet::Parser::AST::HostName.new(:value => /regex/)
       Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
     end
 
     it "should mark any created scopes as a node scope" do
       pending "Need to define LoadedCode behaviour first"
       name = Puppet::Parser::AST::HostName.new(:value => /regex/)
       Puppet::Resource::Type.new(:node, name).name.should == /regex/.to_s
     end
   end
 
   describe "when initializing" do
     it "should require a resource super type" do
       Puppet::Resource::Type.new(:hostclass, "foo").type.should == :hostclass
     end
 
     it "should fail if provided an invalid resource super type" do
       lambda { Puppet::Resource::Type.new(:nope, "foo") }.should raise_error(ArgumentError)
     end
 
     it "should set its name to the downcased, stringified provided name" do
       Puppet::Resource::Type.new(:hostclass, "Foo::Bar".intern).name.should == "foo::bar"
     end
 
     it "should set its namespace to the downcased, stringified qualified name for classes" do
       Puppet::Resource::Type.new(:hostclass, "Foo::Bar::Baz".intern).namespace.should == "foo::bar::baz"
     end
 
     [:definition, :node].each do |type|
       it "should set its namespace to the downcased, stringified qualified portion of the name for #{type}s" do
         Puppet::Resource::Type.new(type, "Foo::Bar::Baz".intern).namespace.should == "foo::bar"
       end
     end
 
     %w{code line file doc}.each do |arg|
       it "should set #{arg} if provided" do
         type = Puppet::Resource::Type.new(:hostclass, "foo", arg.to_sym => "something")
         type.send(arg).should == "something"
       end
     end
 
     it "should set any provided arguments with the keys as symbols" do
       type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {:foo => "bar", :baz => "biz"})
       type.should be_valid_parameter("foo")
       type.should be_valid_parameter("baz")
     end
 
     it "should set any provided arguments with they keys as strings" do
       type = Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar", "baz" => "biz"})
       type.should be_valid_parameter(:foo)
       type.should be_valid_parameter(:baz)
     end
 
     it "should function if provided no arguments" do
       type = Puppet::Resource::Type.new(:hostclass, "foo")
       type.should_not be_valid_parameter(:foo)
     end
   end
 
   describe "when testing the validity of an attribute" do
     it "should return true if the parameter was typed at initialization" do
       Puppet::Resource::Type.new(:hostclass, "foo", :arguments => {"foo" => "bar"}).should be_valid_parameter("foo")
     end
 
     it "should return true if it is a metaparam" do
       Puppet::Resource::Type.new(:hostclass, "foo").should be_valid_parameter("require")
     end
 
     it "should return true if the parameter is named 'name'" do
       Puppet::Resource::Type.new(:hostclass, "foo").should be_valid_parameter("name")
     end
 
     it "should return false if it is not a metaparam and was not provided at initialization" do
       Puppet::Resource::Type.new(:hostclass, "foo").should_not be_valid_parameter("yayness")
     end
   end
 
   describe "when creating a subscope" do
     before do
       @scope = stub 'scope', :newscope => nil
       @resource = stub 'resource'
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     it "should return a new scope created with the provided scope as the parent" do
       @scope.expects(:newscope).returns "foo"
       @type.subscope(@scope, @resource).should == "foo"
     end
 
     it "should set the source as itself" do
       @scope.expects(:newscope).with { |args| args[:source] == @type }
       @type.subscope(@scope, @resource)
     end
 
     it "should set the scope's namespace to its namespace" do
       @type.expects(:namespace).returns "yayness"
       @scope.expects(:newscope).with { |args| args[:namespace] == "yayness" }
       @type.subscope(@scope, @resource)
     end
 
     it "should set the scope's resource to the provided resource" do
       @scope.expects(:newscope).with { |args| args[:resource] == @resource }
       @type.subscope(@scope, @resource)
     end
   end
 
   describe "when setting its parameters in the scope" do
     before do
       @scope = Puppet::Parser::Scope.new(:compiler => stub("compiler", :environment => Puppet::Node::Environment.new), :source => stub("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     ['module_name', 'name', 'title'].each do |variable|
       it "should allow #{variable} to be evaluated as param default" do
         @type.instance_eval { @module_name = "bar" }
         var = Puppet::Parser::AST::Variable.new({'value' => variable})
         @type.set_arguments :foo => var
         @type.set_resource_parameters(@resource, @scope)
         @scope.lookupvar('foo').should == 'bar'
       end
     end
 
     # this test is to clarify a crazy edge case
     # if you specify these special names as params, the resource
     # will override the special variables
     it "resource should override defaults" do
       @type.set_arguments :name => nil
       @resource[:name] = 'foobar'
       var = Puppet::Parser::AST::Variable.new({'value' => 'name'})
       @type.set_arguments :foo => var
       @type.set_resource_parameters(@resource, @scope)
       @scope.lookupvar('foo').should == 'foobar'
     end
 
     it "should set each of the resource's parameters as variables in the scope" do
       @type.set_arguments :foo => nil, :boo => nil
       @resource[:foo] = "bar"
       @resource[:boo] = "baz"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("foo").should == "bar"
       @scope.lookupvar("boo").should == "baz"
     end
 
     it "should set the variables as strings" do
       @type.set_arguments :foo => nil
       @resource[:foo] = "bar"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("foo").should == "bar"
     end
 
     it "should fail if any of the resource's parameters are not valid attributes" do
       @type.set_arguments :foo => nil
       @resource[:boo] = "baz"
 
       lambda { @type.set_resource_parameters(@resource, @scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should evaluate and set its default values as variables for parameters not provided by the resource" do
       @type.set_arguments :foo => stub("value", :safeevaluate => "something")
       @type.set_resource_parameters(@resource, @scope)
       @scope.lookupvar("foo").should == "something"
     end
 
     it "should set all default values as parameters in the resource" do
       @type.set_arguments :foo => stub("value", :safeevaluate => "something")
 
       @type.set_resource_parameters(@resource, @scope)
 
       @resource[:foo].should == "something"
     end
 
     it "should fail if the resource does not provide a value for a required argument" do
       @type.set_arguments :foo => nil
       @resource.expects(:to_hash).returns({})
 
       lambda { @type.set_resource_parameters(@resource, @scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should set the resource's title as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("title").should == "bar"
     end
 
     it "should set the resource's name as a variable if not otherwise provided" do
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("name").should == "bar"
     end
 
     it "should set its module name in the scope if available" do
       @type.instance_eval { @module_name = "mymod" }
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("module_name").should == "mymod"
     end
 
     it "should set its caller module name in the scope if available" do
       @scope.expects(:parent_module_name).returns "mycaller"
 
       @type.set_resource_parameters(@resource, @scope)
 
       @scope.lookupvar("caller_module_name").should == "mycaller"
     end
   end
 
   describe "when describing and managing parent classes" do
     before do
       @code = Puppet::Resource::TypeCollection.new("env")
       @parent = Puppet::Resource::Type.new(:hostclass, "bar")
       @code.add @parent
 
       @child = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
       @code.add @child
 
       @env   = stub "environment", :known_resource_types => @code
       @scope = stub "scope", :environment => @env, :namespaces => [""]
     end
 
     it "should be able to define a parent" do
       Puppet::Resource::Type.new(:hostclass, "foo", :parent => "bar")
     end
 
     it "should use the code collection to find the parent resource type" do
       @child.parent_type(@scope).should equal(@parent)
     end
 
     it "should be able to find parent nodes" do
       parent = Puppet::Resource::Type.new(:node, "bar")
       @code.add parent
       child = Puppet::Resource::Type.new(:node, "foo", :parent => "bar")
       @code.add child
 
       child.parent_type(@scope).should equal(parent)
     end
 
     it "should cache a reference to the parent type" do
       @code.stubs(:hostclass).with("foo::bar").returns nil
       @code.expects(:hostclass).with("bar").once.returns @parent
       @child.parent_type(@scope)
       @child.parent_type
     end
 
     it "should correctly state when it is another type's child" do
       @child.parent_type(@scope)
       @child.should be_child_of(@parent)
     end
 
     it "should be considered the child of a parent's parent" do
       @grandchild = Puppet::Resource::Type.new(:hostclass, "baz", :parent => "foo")
       @code.add @grandchild
 
       @child.parent_type(@scope)
       @grandchild.parent_type(@scope)
 
       @grandchild.should be_child_of(@parent)
     end
 
     it "should correctly state when it is not another type's child" do
       @notchild = Puppet::Resource::Type.new(:hostclass, "baz")
       @code.add @notchild
 
       @notchild.should_not be_child_of(@parent)
     end
   end
 
   describe "when evaluating its code" do
     before do
       @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
       @scope = Puppet::Parser::Scope.new :compiler => @compiler
       @resource = Puppet::Parser::Resource.new(:foo, "yay", :scope => @scope)
 
       # This is so the internal resource lookup works, yo.
       @compiler.catalog.add_resource @resource
 
       @known_resource_types = stub 'known_resource_types'
       @resource.stubs(:known_resource_types).returns @known_resource_types
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
 
     it "should add hostclass names to the classes list" do
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should be_include("foo")
     end
 
     it "should add node names to the classes list" do
       @type = Puppet::Resource::Type.new(:node, "foo")
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should be_include("foo")
     end
 
     it "should not add defined resource names to the classes list" do
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should_not be_include("foo")
     end
 
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
       @type.expects(:subscope).with(@scope, @resource).returns subscope
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should not create a subscope for the :main class" do
       @resource.stubs(:title).returns(:main)
       @type.expects(:subscope).never
       @type.expects(:set_resource_parameters).with(@resource, @scope)
 
       @type.evaluate_code(@resource)
     end
 
     it "should store the class scope" do
       @type.evaluate_code(@resource)
       @scope.class_scope(@type).should be_instance_of(@scope.class)
     end
 
     it "should still create a scope but not store it if the type is a definition" do
       @type = Puppet::Resource::Type.new(:definition, "foo")
       @type.evaluate_code(@resource)
       @scope.class_scope(@type).should be_nil
     end
 
     it "should evaluate the AST code if any is provided" do
       code = stub 'code'
       @type.stubs(:code).returns code
       @type.stubs(:subscope).returns stub_everything("subscope", :compiler => @compiler)
       code.expects(:safeevaluate).with @type.subscope
 
       @type.evaluate_code(@resource)
     end
 
     describe "and ruby code is provided" do
       it "should create a DSL Resource API and evaluate it" do
         @type.stubs(:ruby_code).returns(proc { "foo" })
         @api = stub 'api'
         Puppet::DSL::ResourceAPI.expects(:new).with { |res, scope, code| code == @type.ruby_code }.returns @api
         @api.expects(:evaluate)
 
         @type.evaluate_code(@resource)
       end
     end
 
     it "should noop if there is no code" do
       @type.expects(:code).returns nil
 
       @type.evaluate_code(@resource)
     end
 
     describe "and it has a parent class" do
       before do
         @parent_type = Puppet::Resource::Type.new(:hostclass, "parent")
         @type.parent = "parent"
         @parent_resource = Puppet::Parser::Resource.new(:class, "parent", :scope => @scope)
 
         @compiler.add_resource @scope, @parent_resource
 
         @type.resource_type_collection = @scope.known_resource_types
         @type.resource_type_collection.add @parent_type
       end
 
       it "should evaluate the parent's resource" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@parent_type).should_not be_nil
       end
 
       it "should not evaluate the parent's resource if it has already been evaluated" do
         @parent_resource.evaluate
 
         @type.parent_type(@scope)
 
         @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
 
       it "should use the parent's scope as its base scope" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@type).parent.object_id.should == @scope.class_scope(@parent_type).object_id
       end
     end
 
     describe "and it has a parent node" do
       before do
         @type = Puppet::Resource::Type.new(:node, "foo")
         @parent_type = Puppet::Resource::Type.new(:node, "parent")
         @type.parent = "parent"
         @parent_resource = Puppet::Parser::Resource.new(:node, "parent", :scope => @scope)
 
         @compiler.add_resource @scope, @parent_resource
 
         @type.resource_type_collection = @scope.known_resource_types
         @type.resource_type_collection.add(@parent_type)
       end
 
       it "should evaluate the parent's resource" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@parent_type).should_not be_nil
       end
 
       it "should not evaluate the parent's resource if it has already been evaluated" do
         @parent_resource.evaluate
 
         @type.parent_type(@scope)
 
         @parent_resource.expects(:evaluate).never
 
         @type.evaluate_code(@resource)
       end
 
       it "should use the parent's scope as its base scope" do
         @type.parent_type(@scope)
 
         @type.evaluate_code(@resource)
 
         @scope.class_scope(@type).parent.object_id.should == @scope.class_scope(@parent_type).object_id
       end
     end
   end
 
   describe "when creating a resource" do
     before do
       @node = Puppet::Node.new("foo", :environment => 'env')
       @compiler = Puppet::Parser::Compiler.new(@node)
       @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
 
       @top = Puppet::Resource::Type.new :hostclass, "top"
       @middle = Puppet::Resource::Type.new :hostclass, "middle", :parent => "top"
 
       @code = Puppet::Resource::TypeCollection.new("env")
       @code.add @top
       @code.add @middle
 
       @node.environment.stubs(:known_resource_types).returns(@code)
     end
 
     it "should create a resource instance" do
       @top.ensure_in_catalog(@scope).should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should set its resource type to 'class' when it is a hostclass" do
       Puppet::Resource::Type.new(:hostclass, "top").ensure_in_catalog(@scope).type.should == "Class"
     end
 
     it "should set its resource type to 'node' when it is a node" do
       Puppet::Resource::Type.new(:node, "top").ensure_in_catalog(@scope).type.should == "Node"
     end
 
     it "should fail when it is a definition" do
       lambda { Puppet::Resource::Type.new(:definition, "top").ensure_in_catalog(@scope) }.should raise_error(ArgumentError)
     end
 
     it "should add the created resource to the scope's catalog" do
       @top.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should add specified parameters to the resource" do
       @top.ensure_in_catalog(@scope, {'one'=>'1', 'two'=>'2'})
       @compiler.catalog.resource(:class, "top")['one'].should == '1'
       @compiler.catalog.resource(:class, "top")['two'].should == '2'
     end
 
     it "should not require params for a param class" do
       @top.ensure_in_catalog(@scope, {})
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
       @middle.ensure_in_catalog(@scope, {})
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should fail if you try to create duplicate class resources" do
       othertop = Puppet::Parser::Resource.new(:class, 'top',:source => @source, :scope => @scope )
       # add the same class resource to the catalog
       @compiler.catalog.add_resource(othertop)
       lambda { @top.ensure_in_catalog(@scope, {}) }.should raise_error(Puppet::Resource::Catalog::DuplicateResourceError)
     end
 
     it "should fail to evaluate if a parent class is defined but cannot be found" do
       othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
       @code.add othertop
       lambda { othertop.ensure_in_catalog(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should not create a new resource if one already exists" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
       @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
       @top.ensure_in_catalog(@scope).should == "something"
     end
 
     it "should not create a new parent resource if one already exists and it has a parent class" do
       @top.ensure_in_catalog(@scope)
 
       top_resource = @compiler.catalog.resource(:class, "top")
 
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should equal(top_resource)
     end
 
     # #795 - tag before evaluation.
     it "should tag the catalog with the resource tags when it is evaluated" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("middle")
     end
 
     it "should tag the catalog with the parent class tags when it is evaluated" do
       @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("top")
     end
   end
 
   describe "when merging code from another instance" do
     def code(str)
       Puppet::Parser::AST::Leaf.new :value => str
     end
 
     it "should fail unless it is a class" do
       lambda { Puppet::Resource::Type.new(:node, "bar").merge("foo") }.should raise_error(Puppet::Error)
     end
 
     it "should fail unless the source instance is a class" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:node, "foo")
       lambda { dest.merge(source) }.should raise_error(Puppet::Error)
     end
 
     it "should fail if both classes have different parent classes" do
       code = Puppet::Resource::TypeCollection.new("env")
       {"a" => "b", "c" => "d"}.each do |parent, child|
         code.add Puppet::Resource::Type.new(:hostclass, parent)
         code.add Puppet::Resource::Type.new(:hostclass, child, :parent => parent)
       end
       lambda { code.hostclass("b").merge(code.hostclass("d")) }.should raise_error(Puppet::Error)
     end
 
     it "should fail if it's named 'main' and 'freeze_main' is enabled" do
       Puppet.settings[:freeze_main] = true
       code = Puppet::Resource::TypeCollection.new("env")
       code.add Puppet::Resource::Type.new(:hostclass, "")
       other = Puppet::Resource::Type.new(:hostclass, "")
       lambda { code.hostclass("").merge(other) }.should raise_error(Puppet::Error)
     end
 
     it "should copy the other class's parent if it has not parent" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
 
       parent = Puppet::Resource::Type.new(:hostclass, "parent")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :parent => "parent")
       dest.merge(source)
 
       dest.parent.should == "parent"
     end
 
     it "should copy the other class's documentation as its docs if it has no docs" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
       dest.merge(source)
 
       dest.doc.should == "yayness"
     end
 
     it "should append the other class's docs to its docs if it has any" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :doc => "fooness")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :doc => "yayness")
       dest.merge(source)
 
       dest.doc.should == "foonessyayness"
     end
 
     it "should turn its code into an ASTArray if necessary" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => code("foo"))
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
 
       dest.merge(source)
 
       dest.code.should be_instance_of(Puppet::Parser::AST::ASTArray)
     end
 
     it "should set the other class's code as its code if it has none" do
       dest = Puppet::Resource::Type.new(:hostclass, "bar")
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => code("bar"))
 
       dest.merge(source)
 
       dest.code.value.should == "bar"
     end
 
     it "should append the other class's code to its code if it has any" do
       dcode = Puppet::Parser::AST::ASTArray.new :children => [code("dest")]
       dest = Puppet::Resource::Type.new(:hostclass, "bar", :code => dcode)
 
       scode = Puppet::Parser::AST::ASTArray.new :children => [code("source")]
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
 
       dest.code.children.collect { |l| l.value }.should == %w{dest source}
     end
   end
 end