diff --git a/spec/unit/parser/type_loader_spec.rb b/spec/unit/parser/type_loader_spec.rb
index fd991ffc4..8b139613a 100755
--- a/spec/unit/parser/type_loader_spec.rb
+++ b/spec/unit/parser/type_loader_spec.rb
@@ -1,230 +1,230 @@
 #!/usr/bin/env rspec
 require '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] == make_absolute("/current") }.returns ["modname", %w{one}]
       @loader.import("myfile", make_absolute("/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", make_absolute("/one")]
+      Puppet::Parser::Files.expects(:find_manifests).returns ["modname", [make_absolute("/one")]]
       @loader.expects(:parse_file).with(make_absolute("/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(make_absolute("/current/one")).returns(Puppet::Parser::AST::Hostclass.new(''))
       @loader.import("myfile", make_absolute("/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}#{File::PATH_SEPARATOR}#{@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