diff --git a/lib/puppet/interface/face_collection.rb b/lib/puppet/interface/face_collection.rb
index 84296582c..e4eb22fa3 100644
--- a/lib/puppet/interface/face_collection.rb
+++ b/lib/puppet/interface/face_collection.rb
@@ -1,123 +1,131 @@
 # -*- coding: utf-8 -*-
 require 'puppet/interface'
 
 module Puppet::Interface::FaceCollection
   SEMVER_VERSION = /^(\d+)\.(\d+)\.(\d+)([A-Za-z][0-9A-Za-z-]*|)$/
 
   @faces = Hash.new { |hash, key| hash[key] = {} }
 
   def self.faces
     unless @loaded
       @loaded = true
       $LOAD_PATH.each do |dir|
         next unless FileTest.directory?(dir)
         Dir.chdir(dir) do
           Dir.glob("puppet/faces/*.rb").collect { |f| f.sub(/\.rb/, '') }.each do |file|
             iname = file.sub(/\.rb/, '')
             begin
               require iname
             rescue Exception => detail
               puts detail.backtrace if Puppet[:trace]
               raise "Could not load #{iname} from #{dir}/#{file}: #{detail}"
             end
           end
         end
       end
     end
     return @faces.keys
   end
 
   def self.validate_version(version)
     !!(SEMVER_VERSION =~ version.to_s)
   end
 
   def self.cmp_semver(a, b)
     a, b = [a, b].map do |x|
       parts = SEMVER_VERSION.match(x).to_a[1..4]
       parts[0..2] = parts[0..2].map { |e| e.to_i }
       parts
     end
 
     cmp = a[0..2] <=> b[0..2]
     if cmp == 0
       cmp = a[3] <=> b[3]
       cmp = +1 if a[3].empty? && !b[3].empty?
       cmp = -1 if b[3].empty? && !a[3].empty?
     end
     cmp
   end
 
   def self.[](name, version)
     @faces[underscorize(name)][version] if face?(name, version)
   end
 
   def self.face?(name, version)
     name = underscorize(name)
-    return true if @faces[name].has_key?(version)
+
+    # Note: be careful not to accidentally create the top level key, either,
+    # because it will result in confusion when people try to enumerate the
+    # list of valid faces later. --daniel 2011-04-11
+    return true if @faces.has_key?(name) and @faces[name].has_key?(version)
 
     # We always load the current version file; the common case is that we have
     # the expected version and any compatibility versions in the same file,
     # the default.  Which means that this is almost always the case.
     #
     # We use require to avoid executing the code multiple times, like any
     # other Ruby library that we might want to use.  --daniel 2011-04-06
     begin
       require "puppet/faces/#{name}"
 
       # If we wanted :current, we need to index to find that; direct version
       # requests just work™ as they go. --daniel 2011-04-06
       if version == :current then
         # We need to find current out of this.  This is the largest version
         # number that doesn't have a dedicated on-disk file present; those
         # represent "experimental" versions of faces, which we don't fully
         # support yet.
         #
         # We walk the versions from highest to lowest and take the first version
         # that is not defined in an explicitly versioned file on disk as the
         # current version.
         #
         # This constrains us to only ship experimental versions with *one*
         # version in the file, not multiple, but given you can't reliably load
         # them except by side-effect when you ignore that rule this seems safe
         # enough...
         #
         # Given those constraints, and that we are not going to ship a versioned
         # interface that is not :current in this release, we are going to leave
         # these thoughts in place, and just punt on the actual versioning.
         #
         # When we upgrade the core to support multiple versions we can solve the
         # problems then; as lazy as possible.
         #
         # We do support multiple versions in the same file, though, so we sort
         # versions here and return the last item in that set.
         #
         # --daniel 2011-04-06
         latest_ver = @faces[name].keys.sort {|a, b| cmp_semver(a, b) }.last
         @faces[name][:current] = @faces[name][latest_ver]
       end
     rescue LoadError => e
       raise unless e.message =~ %r{-- puppet/faces/#{name}$}
       # ...guess we didn't find the file; return a much better problem.
     end
 
     # Now, either we have the version in our set of faces, or we didn't find
     # the version they were looking for.  In the future we will support
     # loading versioned stuff from some look-aside part of the Ruby load path,
     # but we don't need that right now.
     #
     # So, this comment is a place-holder for that.  --daniel 2011-04-06
-    return !! @faces[name].has_key?(version)
+    #
+    # Note: be careful not to accidentally create the top level key, either,
+    # because it will result in confusion when people try to enumerate the
+    # list of valid faces later. --daniel 2011-04-11
+    return !! (@faces.has_key?(name) and @faces[name].has_key?(version))
   end
 
   def self.register(face)
     @faces[underscorize(face.name)][face.version] = face
   end
 
   def self.underscorize(name)
     unless name.to_s =~ /^[-_a-z]+$/i then
       raise ArgumentError, "#{name.inspect} (#{name.class}) is not a valid face name"
     end
 
     name.to_s.downcase.split(/[-_]/).join('_').to_sym
   end
 end
diff --git a/spec/unit/interface/face_collection_spec.rb b/spec/unit/interface/face_collection_spec.rb
index e6e03c3d2..752871035 100755
--- a/spec/unit/interface/face_collection_spec.rb
+++ b/spec/unit/interface/face_collection_spec.rb
@@ -1,176 +1,181 @@
 #!/usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
 require 'puppet/interface/face_collection'
 
 describe Puppet::Interface::FaceCollection do
   # To avoid cross-pollution we have to save and restore both the hash
   # containing all the interface data, and the array used by require.  Restoring
   # both means that we don't leak side-effects across the code. --daniel 2011-04-06
   #
   # Worse luck, we *also* need to flush $" of anything defining a face,
   # because otherwise we can cross-pollute from other test files and end up
   # with no faces loaded, but the require value set true. --daniel 2011-04-10
   before :each do
     @original_faces    = subject.instance_variable_get("@faces").dup
     @original_required = $".dup
     $".delete_if do |path| path =~ %r{/faces/.*\.rb$} end
     subject.instance_variable_get("@faces").clear
   end
 
   after :each do
     subject.instance_variable_set("@faces", @original_faces)
     $".clear ; @original_required.each do |item| $" << item end
   end
 
   describe "::faces" do
     it "REVISIT: should have some tests here, if we describe it"
   end
 
   describe "::validate_version" do
     it 'should permit three number versions' do
       subject.validate_version('10.10.10').should == true
     end
 
     it 'should permit versions with appended descriptions' do
       subject.validate_version('10.10.10beta').should == true
     end
 
     it 'should not permit versions with more than three numbers' do
       subject.validate_version('1.2.3.4').should == false
     end
 
     it 'should not permit versions with only two numbers' do
       subject.validate_version('10.10').should == false
     end
 
     it 'should not permit versions with only one number' do
       subject.validate_version('123').should == false
     end
 
     it 'should not permit versions with text in any position but at the end' do
       subject.validate_version('v1.1.1').should == false
     end
   end
 
   describe "::[]" do
     before :each do
       subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
     end
 
     before :each do
       @dir = Dir.mktmpdir
       @lib = FileUtils.mkdir_p(File.join @dir, 'puppet', 'faces')
       $LOAD_PATH.push(@dir)
     end
 
     after :each do
       FileUtils.remove_entry_secure @dir
       $LOAD_PATH.pop
     end
 
     it "should return the faces with the given name" do
       subject["foo", '0.0.1'].should == 10
     end
 
     it "should attempt to load the faces if it isn't found" do
       subject.expects(:require).with('puppet/faces/bar')
       subject["bar", '0.0.1']
     end
 
     it "should attempt to load the default faces for the specified version :current" do
       subject.expects(:require).with('puppet/faces/fozzie')
       subject['fozzie', :current]
     end
   end
 
   describe "::face?" do
     it "should return true if the faces specified is registered" do
       subject.instance_variable_get("@faces")[:foo]['0.0.1'] = 10
       subject.face?("foo", '0.0.1').should == true
     end
 
     it "should attempt to require the faces if it is not registered" do
       subject.expects(:require).with do |file|
         subject.instance_variable_get("@faces")[:bar]['0.0.1'] = true
         file == 'puppet/faces/bar'
       end
       subject.face?("bar", '0.0.1').should == true
     end
 
     it "should return true if requiring the faces registered it" do
       subject.stubs(:require).with do
         subject.instance_variable_get("@faces")[:bar]['0.0.1'] = 20
       end
     end
 
     it "should return false if the faces is not registered" do
       subject.stubs(:require).returns(true)
       subject.face?("bar", '0.0.1').should be_false
     end
 
     it "should return false if the faces file itself is missing" do
       subject.stubs(:require).
         raises(LoadError, 'no such file to load -- puppet/faces/bar')
       subject.face?("bar", '0.0.1').should be_false
     end
 
     it "should register the version loaded by `:current` as `:current`" do
       subject.expects(:require).with do |file|
         subject.instance_variable_get("@faces")[:huzzah]['2.0.1'] = :huzzah_faces
         file == 'puppet/faces/huzzah'
       end
       subject.face?("huzzah", :current)
       subject.instance_variable_get("@faces")[:huzzah][:current].should == :huzzah_faces
     end
 
     context "with something on disk" do
       it "should register the version loaded from `puppet/faces/{name}` as `:current`" do
         subject.should be_face "huzzah", '2.0.1'
         subject.should be_face "huzzah", :current
         Puppet::Faces[:huzzah, '2.0.1'].should == Puppet::Faces[:huzzah, :current]
       end
 
       it "should index :current when the code was pre-required" do
         subject.instance_variable_get("@faces")[:huzzah].should_not be_key :current
         require 'puppet/faces/huzzah'
         subject.face?(:huzzah, :current).should be_true
       end
     end
+
+    it "should not cause an invalid face to be enumerated later" do
+      subject.face?(:there_is_no_face, :current).should be_false
+      subject.faces.should_not include :there_is_no_face
+    end
   end
 
   describe "::register" do
     it "should store the faces by name" do
       faces = Puppet::Faces.new(:my_faces, '0.0.1')
       subject.register(faces)
       subject.instance_variable_get("@faces").should == {:my_faces => {'0.0.1' => faces}}
     end
   end
 
   describe "::underscorize" do
     faulty = [1, "#foo", "$bar", "sturm und drang", :"sturm und drang"]
     valid  = {
       "Foo"      => :foo,
       :Foo       => :foo,
       "foo_bar"  => :foo_bar,
       :foo_bar   => :foo_bar,
       "foo-bar"  => :foo_bar,
       :"foo-bar" => :foo_bar,
     }
 
     valid.each do |input, expect|
       it "should map #{input.inspect} to #{expect.inspect}" do
         result = subject.underscorize(input)
         result.should == expect
       end
     end
 
     faulty.each do |input|
       it "should fail when presented with #{input.inspect} (#{input.class})" do
         expect { subject.underscorize(input) }.
           should raise_error ArgumentError, /not a valid face name/
       end
     end
   end
 end