diff --git a/lib/puppet/util/feature.rb b/lib/puppet/util/feature.rb
index 5a7fbf773..eb61dabfa 100644
--- a/lib/puppet/util/feature.rb
+++ b/lib/puppet/util/feature.rb
@@ -1,81 +1,81 @@
 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)
+    @results.delete(name)
 
     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)
       @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/integration/network/formats_spec.rb b/spec/integration/network/formats_spec.rb
index 214b2d78f..f6e234de3 100755
--- a/spec/integration/network/formats_spec.rb
+++ b/spec/integration/network/formats_spec.rb
@@ -1,106 +1,104 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
 require 'puppet/network/formats'
 
 class PsonIntTest
   attr_accessor :string
   def ==(other)
     other.class == self.class and string == other.string
   end
 
   def self.from_pson(data)
     new(data[0])
   end
 
   def initialize(string)
     @string = string
   end
 
   def to_pson(*args)
     {
       'type' => self.class.name,
       'data' => [@string]
     }.to_pson(*args)
   end
 
   def self.canonical_order(s)
     s.gsub(/\{"data":\[(.*?)\],"type":"PsonIntTest"\}/,'{"type":"PsonIntTest","data":[\1]}')
   end
 
 end
 
 describe Puppet::Network::FormatHandler.format(:s) do
   before do
     @format = Puppet::Network::FormatHandler.format(:s)
   end
 
   it "should support certificates" do
     @format.should be_supported(Puppet::SSL::Certificate)
   end
 
   it "should not support catalogs" do
     @format.should_not be_supported(Puppet::Resource::Catalog)
   end
 end
 
 describe Puppet::Network::FormatHandler.format(:pson), :'fails_on_ruby_1.9.2' => true do
   describe "when pson is absent", :if => (! Puppet.features.pson?) do
 
     before do
       @pson = Puppet::Network::FormatHandler.format(:pson)
     end
 
     it "should not be suitable" do
       @pson.should_not be_suitable
     end
   end
 
   describe "when pson is available", :if => Puppet.features.pson? do
     before do
       @pson = Puppet::Network::FormatHandler.format(:pson)
     end
 
     it "should be able to render an instance to pson" do
       instance = PsonIntTest.new("foo")
       PsonIntTest.canonical_order(@pson.render(instance)).should == PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' )
     end
 
     it "should be able to render arrays to pson" do
       @pson.render([1,2]).should == '[1,2]'
     end
 
     it "should be able to render arrays containing hashes to pson" do
       @pson.render([{"one"=>1},{"two"=>2}]).should == '[{"one":1},{"two":2}]'
     end
 
     it "should be able to render multiple instances to pson" do
-      Puppet.features.add(:pson, :libs => ["pson"])
-
       one = PsonIntTest.new("one")
       two = PsonIntTest.new("two")
 
       PsonIntTest.canonical_order(@pson.render([one,two])).should == PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]')
     end
 
     it "should be able to intern pson into an instance" do
       @pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}').should == PsonIntTest.new("foo")
     end
 
     it "should be able to intern pson with no class information into an instance" do
       @pson.intern(PsonIntTest, '["foo"]').should == PsonIntTest.new("foo")
     end
 
     it "should be able to intern multiple instances from pson" do
       @pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]').should == [
         PsonIntTest.new("one"), PsonIntTest.new("two")
       ]
     end
 
     it "should be able to intern multiple instances from pson with no class information" do
       @pson.intern_multiple(PsonIntTest, '[["one"],["two"]]').should == [
         PsonIntTest.new("one"), PsonIntTest.new("two")
       ]
     end
   end
 end
diff --git a/spec/unit/util/feature_spec.rb b/spec/unit/util/feature_spec.rb
index 15375e0b1..a0fdc1269 100755
--- a/spec/unit/util/feature_spec.rb
+++ b/spec/unit/util/feature_spec.rb
@@ -1,71 +1,81 @@
 #!/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
     $loaded_feature = 0
     @features.add(:myfeature) { $loaded_feature += 1 }
     @features.myfeature?
     @features.myfeature?
     $loaded_feature.should == 1
   end
 
+  it "should invalidate the cache for the feature when loading" do
+    # block defined features are evaluated at load time
+    @features.add(:myfeature) { false }
+    @features.should_not be_myfeature
+    # features with no block have deferred evaluation so an existing cached
+    # value would take precedence
+    @features.add(:myfeature)
+    @features.should be_myfeature
+  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
 end