diff --git a/lib/puppet/util/autoload.rb b/lib/puppet/util/autoload.rb
index 246ff5fc3..f20f16a79 100644
--- a/lib/puppet/util/autoload.rb
+++ b/lib/puppet/util/autoload.rb
@@ -1,158 +1,158 @@
 require 'puppet/util/warnings'
 
 # Autoload paths, either based on names or all at once.
 class Puppet::Util::Autoload
   require 'puppet/util/autoload/file_cache'
 
   include Puppet::Util
   include Puppet::Util::Warnings
   include Puppet::Util::Autoload::FileCache
 
   @autoloaders = {}
   @loaded = []
 
   class << self
     attr_reader :autoloaders
     private :autoloaders
   end
 
   # Send [], []=, and :clear to the @autloaders hash
   Puppet::Util.classproxy self, :autoloaders, "[]", "[]="
 
   # List all loaded files.
   def self.list_loaded
     @loaded.sort { |a,b| a[0] <=> b[0] }.collect do |path, hash|
       "#{path}: #{hash[:file]}"
     end
   end
 
   # Has a given path been loaded?  This is used for testing whether a
   # changed file should be loaded or just ignored.  This is only
   # used in network/client/master, when downloading plugins, to
   # see if a given plugin is currently loaded and thus should be
   # reloaded.
   def self.loaded?(path)
     path = path.to_s.sub(/\.rb$/, '')
     @loaded.include?(path)
   end
 
   # Save the fact that a given path has been loaded.  This is so
   # we can load downloaded plugins if they've already been loaded
   # into memory.
   def self.loaded(file)
     $" << file + ".rb" unless $".include?(file)
     @loaded << file unless @loaded.include?(file)
   end
 
   attr_accessor :object, :path, :objwarn, :wrap
 
   def initialize(obj, path, options = {})
     @path = path.to_s
     raise ArgumentError, "Autoload paths cannot be fully qualified" if absolute_path?(@path)
     @object = obj
 
     self.class[obj] = self
 
     options.each do |opt, value|
       opt = opt.intern if opt.is_a? String
       begin
         self.send(opt.to_s + "=", value)
       rescue NoMethodError
         raise ArgumentError, "#{opt} is not a valid option"
       end
     end
 
     @wrap = true unless defined?(@wrap)
   end
 
   # Load a single plugin by name.  We use 'load' here so we can reload a
   # given plugin.
   def load(name,env=nil)
     path = name.to_s + ".rb"
 
     searchpath(env).each do |dir|
       file = File.join(dir, path)
       next unless file_exist?(file)
       begin
         Kernel.load file, @wrap
         name = symbolize(name)
         loaded name, file
         return true
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
         puts detail.backtrace if Puppet[:trace]
         raise Puppet::Error, "Could not autoload #{name}: #{detail}"
       end
     end
     false
   end
 
   # Mark the named object as loaded.  Note that this supports unqualified
   # queries, while we store the result as a qualified query in the class.
   def loaded(name, file)
     self.class.loaded(File.join(@path, name.to_s))
   end
 
   # Indicate whether the specfied plugin has been loaded.
   def loaded?(name)
     self.class.loaded?(File.join(@path, name.to_s))
   end
 
   # Load all instances that we can.  This uses require, rather than load,
   # so that already-loaded files don't get reloaded unnecessarily.
   def loadall
     # Load every instance of everything we can find.
     files_to_load.each do |file|
       name = File.basename(file).chomp(".rb").intern
       next if loaded?(name)
       begin
-        Kernel.require file
         loaded(name, file)
+        Kernel.require file
       rescue SystemExit,NoMemoryError
         raise
       rescue Exception => detail
         puts detail.backtrace if Puppet[:trace]
         raise Puppet::Error, "Could not autoload #{file}: #{detail}"
       end
     end
   end
 
   def files_to_load
     searchpath.map { |dir| Dir.glob("#{dir}/*.rb") }.flatten
   end
 
   # The list of directories to search through for loadable plugins.
   def searchpath(env=nil)
     search_directories(env).uniq.collect { |d| File.join(d, @path) }.find_all { |d| FileTest.directory?(d) }
   end
 
   def module_directories(env=nil)
     # We have to require this late in the process because otherwise we might
     # have load order issues. Since require is much slower than defined?, we
     # can skip that - and save some 2,155 invocations of require in my real
     # world testing. --daniel 2012-07-10
     require 'puppet/node/environment' unless defined?(Puppet::Node::Environment)
 
     real_env = Puppet::Node::Environment.new(env)
 
     # We're using a per-thread cache of said module directories, so that
     # we don't scan the filesystem each time we try to load something with
     # this autoload instance. But since we don't want to cache for the eternity
     # this env_module_directories gets reset after the compilation on the master.
     # This is also reset after an agent ran.
     # One of the side effect of this change is that this module directories list will be
     # shared among all autoload that we have running at a time. But that won't be an issue
     # as by definition those directories are shared by all autoload.
     Thread.current[:env_module_directories] ||= {}
     Thread.current[:env_module_directories][real_env] ||= real_env.modulepath.collect do |dir|
         Dir.entries(dir).reject { |f| f =~ /^\./ }.collect { |f| File.join(dir, f) }
       end.flatten.collect { |d| [File.join(d, "plugins"), File.join(d, "lib")] }.flatten.find_all do |d|
         FileTest.directory?(d)
       end
   end
 
   def search_directories(env=nil)
     [module_directories(env), Puppet[:libdir].split(File::PATH_SEPARATOR), $LOAD_PATH].flatten
   end
 end
diff --git a/spec/unit/util/autoload_spec.rb b/spec/unit/util/autoload_spec.rb
index 47ee54e1f..e243b6c18 100755
--- a/spec/unit/util/autoload_spec.rb
+++ b/spec/unit/util/autoload_spec.rb
@@ -1,123 +1,129 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/autoload'
 
 describe Puppet::Util::Autoload do
   include PuppetSpec::Files
 
   before do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
     @autoload.stubs(:eachdir).yields "/my/dir"
   end
 
   describe "when building the search path" do
     before :each do
       @dira = make_absolute('/a')
       @dirb = make_absolute('/b')
       @dirc = make_absolute('/c')
     end
 
     it "should collect all of the plugins and lib directories that exist in the current environment's module path" do
       Puppet.settings.expects(:value).with(:environment).returns "foo"
       Puppet.settings.expects(:value).with(:modulepath, :foo).returns "#{@dira}#{File::PATH_SEPARATOR}#{@dirb}#{File::PATH_SEPARATOR}#{@dirc}"
       Dir.expects(:entries).with(@dira).returns %w{one two}
       Dir.expects(:entries).with(@dirb).returns %w{one two}
 
       FileTest.stubs(:directory?).returns false
       FileTest.expects(:directory?).with(@dira).returns true
       FileTest.expects(:directory?).with(@dirb).returns true
       ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"].each do |d|
         FileTest.expects(:directory?).with(d).returns true
       end
 
       @autoload.module_directories.should == ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"]
     end
 
     it "should not look for lib directories in directories starting with '.'" do
       Puppet.settings.expects(:value).with(:environment).returns "foo"
       Puppet.settings.expects(:value).with(:modulepath, :foo).returns @dira
       Dir.expects(:entries).with(@dira).returns %w{. ..}
 
       FileTest.expects(:directory?).with(@dira).returns true
       FileTest.expects(:directory?).with("#{@dira}/./lib").never
       FileTest.expects(:directory?).with("#{@dira}/./plugins").never
       FileTest.expects(:directory?).with("#{@dira}/../lib").never
       FileTest.expects(:directory?).with("#{@dira}/../plugins").never
 
       @autoload.module_directories
     end
 
     it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do
       Puppet.stubs(:[]).with(:libdir).returns(%w{/libdir1 /lib/dir/two /third/lib/dir}.join(File::PATH_SEPARATOR))
       @autoload.expects(:module_directories).returns %w{/one /two}
       @autoload.search_directories.should == %w{/one /two /libdir1 /lib/dir/two /third/lib/dir} + $LOAD_PATH
     end
 
     it "should include in its search path all of the unique search directories that have a subdirectory matching the autoload path" do
       @autoload = Puppet::Util::Autoload.new("foo", "loaddir")
       @autoload.expects(:search_directories).returns %w{/one /two /three /three}
       FileTest.expects(:directory?).with("/one/loaddir").returns true
       FileTest.expects(:directory?).with("/two/loaddir").returns false
       FileTest.expects(:directory?).with("/three/loaddir").returns true
       @autoload.searchpath.should == ["/one/loaddir", "/three/loaddir"]
     end
   end
 
   it "should include its FileCache module" do
     Puppet::Util::Autoload.ancestors.should be_include(Puppet::Util::Autoload::FileCache)
   end
 
   describe "when loading a file" do
     before do
       @autoload.stubs(:searchpath).returns %w{/a}
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
         @autoload.stubs(:file_exist?).returns true
 
         Kernel.expects(:load).raises error
 
         lambda { @autoload.load("foo") }.should raise_error(Puppet::Error)
       end
     end
 
     it "should not raise an error if the file is missing" do
       @autoload.load("foo").should == false
     end
 
     it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
       @autoload.stubs(:file_exist?).returns true
       Kernel.stubs(:load)
 
       @autoload.load("myfile")
 
       $LOADED_FEATURES.should be_include("tmp/myfile.rb")
     end
   end
 
   describe "when loading all files" do
     before do
       @autoload.stubs(:searchpath).returns %w{/a}
-      Dir.stubs(:glob).returns "/path/to/file.rb"
-
-      @autoload.class.stubs(:loaded?).returns(false)
+      @filename = rand(10000).to_s + ".rb"
+      Dir.stubs(:glob).returns(@filename)
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
-      it "should die an if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
+      it "dies if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
         Kernel.expects(:require).raises error
 
-        lambda { @autoload.loadall }.should raise_error(Puppet::Error)
+        expect { @autoload.loadall }.to raise_error(Puppet::Error)
       end
     end
 
-    it "should require the full path to the file", :'fails_on_ruby_1.9.2' => true do
-      Kernel.expects(:require).with("/path/to/file.rb")
+    it "requires the file", :'fails_on_ruby_1.9.2' => true do
+      Kernel.expects(:require).with(@filename)
 
       @autoload.loadall
     end
+
+    it "marks the file as required even if loading fails", :'fails_on_ruby_1.9.2' => true do
+      Dir.stubs(:glob).returns "/this/file/does/not/exist.rb"
+
+      expect { @autoload.loadall }.to raise_error(Puppet::Error)
+      expect { @autoload.loadall }.not_to raise_error
+    end
   end
 end