diff --git a/lib/puppet/util/feature.rb b/lib/puppet/util/feature.rb
index 5a7fbf773..c829c5fda 100644
--- a/lib/puppet/util/feature.rb
+++ b/lib/puppet/util/feature.rb
@@ -1,81 +1,83 @@
 class Puppet::Util::Feature
   attr_reader :path
 
   # Create a new feature test.  You have to pass the feature name,
   # and it must be unique.  You can either provide a block that
   # will get executed immediately to determine if the feature
   # is present, or you can pass an option to determine it.
   # Currently, the only supported option is 'libs' (must be
   # passed as a symbol), which will make sure that each lib loads
   # successfully.
   def add(name, options = {})
     method = name.to_s + "?"
     raise ArgumentError, "Feature #{name} is already defined" if self.class.respond_to?(method)
 
     if block_given?
       begin
         result = yield
       rescue Exception => detail
         warn "Failed to load feature test for #{name}: #{detail}"
         result = false
       end
       @results[name] = result
     end
 
     meta_def(method) do
-      @results[name] = test(name, options) unless @results.include?(name)
+      # Positive cache only, except blocks which are executed just once above
+      final = @results[name] || block_given?
+      @results[name] = test(name, options) unless final
       @results[name]
     end
   end
 
   # Create a new feature collection.
   def initialize(path)
     @path = path
     @results = {}
     @loader = Puppet::Util::Autoload.new(self, @path)
   end
 
   def load
     @loader.loadall
   end
 
   def method_missing(method, *args)
     return super unless method.to_s =~ /\?$/
 
     feature = method.to_s.sub(/\?$/, '')
     @loader.load(feature)
 
     respond_to?(method) && self.send(method)
   end
 
   # Actually test whether the feature is present.  We only want to test when
   # someone asks for the feature, so we don't unnecessarily load
   # files.
   def test(name, options)
     return true unless ary = options[:libs]
     ary = [ary] unless ary.is_a?(Array)
 
     ary.each do |lib|
       return false unless load_library(lib, name)
     end
 
     # We loaded all of the required libraries
     true
   end
 
   private
 
   def load_library(lib, name)
     raise ArgumentError, "Libraries must be passed as strings not #{lib.class}" unless lib.is_a?(String)
 
     begin
       require lib
     rescue SystemExit,NoMemoryError
       raise
     rescue Exception
       Puppet.debug "Failed to load library '#{lib}' for feature '#{name}'"
       return false
     end
     true
   end
 end
diff --git a/spec/unit/util/feature_spec.rb b/spec/unit/util/feature_spec.rb
index 15375e0b1..4490675b0 100755
--- a/spec/unit/util/feature_spec.rb
+++ b/spec/unit/util/feature_spec.rb
@@ -1,71 +1,82 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/util/feature'
 
 describe Puppet::Util::Feature do
   before do
     @features = Puppet::Util::Feature.new("features")
     @features.stubs(:warn)
   end
 
   it "should consider undefined features to be absent" do
     @features.should_not be_defined_feature
   end
 
   it "should be able to add new features" do
     @features.add(:myfeature) {}
     @features.should respond_to(:myfeature?)
   end
 
   it "should call associated code when loading a feature" do
     $loaded_feature = false
     @features.add(:myfeature) { $loaded_feature = true}
     $loaded_feature.should be_true
   end
 
   it "should consider a feature absent when the feature load fails" do
     @features.add(:failer) { raise "foo" }
     @features.should_not be_failer
   end
 
   it "should consider a feature to be absent when the feature load returns false" do
     @features.add(:failer) { false }
     @features.should_not be_failer
   end
 
   it "should consider a feature to be present when the feature load returns true" do
     @features.add(:available) { true }
     @features.should be_available
   end
 
-  it "should cache the results of a feature load" do
+  it "should cache the results of a feature load via code block" do
     $loaded_feature = 0
     @features.add(:myfeature) { $loaded_feature += 1 }
     @features.myfeature?
     @features.myfeature?
     $loaded_feature.should == 1
   end
 
   it "should support features with libraries" do
     lambda { @features.add(:puppet, :libs => %w{puppet}) }.should_not raise_error
   end
 
   it "should consider a feature to be present if all of its libraries are present" do
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo")
     @features.expects(:require).with("bar")
 
     @features.should be_myfeature
   end
 
   it "should log and consider a feature to be absent if any of its libraries are absent" do
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo").raises(LoadError)
     @features.stubs(:require).with("bar")
 
     Puppet.expects(:debug)
 
     @features.should_not be_myfeature
   end
+
+  it "should change the feature to be present when its libraries become available" do
+    @features.add(:myfeature, :libs => %w{foo bar})
+    @features.expects(:require).twice().with("foo").raises(LoadError).then.returns(nil)
+    @features.stubs(:require).with("bar")
+
+    Puppet.expects(:debug)
+
+    @features.should_not be_myfeature
+    @features.should be_myfeature
+  end
 end