facter 1.7.6 → 2.0.1.rc1

data/spec/unit/util/confine_spec.rb

@@ -123,5 +123,26 @@ describe Facter::Util::Confine do
     it "should return false if none of the provided ranges matches the fact's value" do
       confined(8, (5..7)).should be_false
     end
+
+    it "should accept and evaluate a block argument against the fact" do
+      @fact.expects(:value).returns 'foo'
+      confine = Facter::Util::Confine.new :yay do |f| f === 'foo' end
+      confine.true?.should be_true
+    end
+
+    it "should return false if the block raises a StandardError when checking a fact" do
+      @fact.stubs(:value).returns 'foo'
+      confine = Facter::Util::Confine.new :yay do |f| raise StandardError end
+      confine.true?.should be_false
+    end
+
+    it "should accept and evaluate only a block argument" do
+      Facter::Util::Confine.new { true }.true?.should be_true
+      Facter::Util::Confine.new { false }.true?.should be_false
+    end
+
+    it "should return false if the block raises a StandardError" do
+      Facter::Util::Confine.new { raise StandardError }.true?.should be_false
+    end
   end
 end

data/spec/unit/util/directory_loader_spec.rb

@@ -55,6 +55,7 @@ describe Facter::Util::DirectoryLoader do
 
     %w{bak orig}.each do |ext|
       it "should ignore files with an extension of '#{ext}'" do
+        Facter.expects(:warn).with(regexp_matches(/#{ext}/))
         write_to_file("data" + ".#{ext}", "foo=bar")
 
         subject.load(collection)

data/spec/unit/util/ec2_spec.rb

@@ -17,21 +17,21 @@ describe Facter::Util::EC2 do
 
       it "should succeed if arp table contains fe:ff:ff:ff:ff:ff" do
         ec2arp = my_fixture_read("linux-arp-ec2.out")
-        Facter::Util::Resolution.expects(:exec).with("arp -an").\
+        Facter::Core::Execution.expects(:exec).with("arp -an").\
           at_least_once.returns(ec2arp)
         Facter::Util::EC2.has_ec2_arp?.should == true
       end
 
       it "should succeed if arp table contains FE:FF:FF:FF:FF:FF" do
         ec2arp = my_fixture_read("centos-arp-ec2.out")
-        Facter::Util::Resolution.expects(:exec).with("arp -an").\
+        Facter::Core::Execution.expects(:exec).with("arp -an").\
           at_least_once.returns(ec2arp)
         Facter::Util::EC2.has_ec2_arp?.should == true
       end
 
       it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
         ec2arp = my_fixture_read("linux-arp-not-ec2.out")
-        Facter::Util::Resolution.expects(:exec).with("arp -an").
+        Facter::Core::Execution.expects(:exec).with("arp -an").
           at_least_once.returns(ec2arp)
         Facter::Util::EC2.has_ec2_arp?.should == false
       end
@@ -45,14 +45,14 @@ describe Facter::Util::EC2 do
 
       it "should succeed if arp table contains fe-ff-ff-ff-ff-ff" do
         ec2arp = my_fixture_read("windows-2008-arp-a.out")
-        Facter::Util::Resolution.expects(:exec).with("arp -a").\
+        Facter::Core::Execution.expects(:exec).with("arp -a").\
           at_least_once.returns(ec2arp)
         Facter::Util::EC2.has_ec2_arp?.should == true
       end
 
       it "should fail if arp table does not contain fe-ff-ff-ff-ff-ff" do
         ec2arp = my_fixture_read("windows-2008-arp-a-not-ec2.out")
-        Facter::Util::Resolution.expects(:exec).with("arp -a").
+        Facter::Core::Execution.expects(:exec).with("arp -a").
           at_least_once.returns(ec2arp)
         Facter::Util::EC2.has_ec2_arp?.should == false
       end
@@ -66,7 +66,7 @@ describe Facter::Util::EC2 do
       it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
         ec2arp = my_fixture_read("solaris8_arp_a_not_ec2.out")
 
-        Facter::Util::Resolution.expects(:exec).with("arp -a").
+        Facter::Core::Execution.expects(:exec).with("arp -a").
           at_least_once.returns(ec2arp)
 
         Facter::Util::EC2.has_ec2_arp?.should == false

data/spec/unit/util/fact_spec.rb

@@ -4,108 +4,123 @@ require 'spec_helper'
 require 'facter/util/fact'
 
 describe Facter::Util::Fact do
-  it "should require a name" do
-    lambda { Facter::Util::Fact.new }.should raise_error(ArgumentError)
-  end
 
-  it "should always downcase the name and convert it to a symbol" do
-    Facter::Util::Fact.new("YayNess").name.should == :yayness
-  end
+  subject(:fact) { Facter::Util::Fact.new("yay") }
 
-  it "should default to its name converted to a string as its ldapname" do
-    Facter::Util::Fact.new("YayNess").ldapname.should == "yayness"
+  let(:resolution) { Facter::Util::Resolution.new("yay", fact) }
+
+  it "requires a name" do
+    expect { Facter::Util::Fact.new }.to raise_error(ArgumentError)
   end
 
-  it "should allow specifying the ldap name at initialization" do
-    Facter::Util::Fact.new("YayNess", :ldapname => "fooness").ldapname.should == "fooness"
+  it "downcases and converts the name to a symbol" do
+    expect(Facter::Util::Fact.new("YayNess").name).to eq :yayness
   end
 
-  it "should fail if an unknown option is provided" do
-    lambda { Facter::Util::Fact.new('yay', :foo => :bar) }.should raise_error(ArgumentError)
+  it "issues a deprecation warning for use of ldapname" do
+    Facter.expects(:warnonce).with("ldapname is deprecated and will be removed in a future version")
+    Facter::Util::Fact.new("YayNess", :ldapname => "fooness")
   end
 
-  it "should have a method for adding resolution mechanisms" do
-    Facter::Util::Fact.new("yay").should respond_to(:add)
+  describe "when adding resolution mechanisms using #add" do
+    it "delegates to #define_resolution with an anonymous resolution" do
+      subject.expects(:define_resolution).with(nil, {})
+      subject.add
+    end
   end
 
-  describe "when adding resolution mechanisms" do
-    before do
-      @fact = Facter::Util::Fact.new("yay")
+  describe "looking up resolutions by name" do
+    subject(:fact) { described_class.new('yay') }
 
-      @resolution = Facter::Util::Resolution.new("yay")
+    it "returns nil if no such resolution exists" do
+      expect(fact.resolution('nope')).to be_nil
     end
 
-    it "should be to create a new resolution instance with a block" do
-      Facter::Util::Resolution.expects(:new).returns @resolution
+    it "never returns anonymous resolutions" do
+      fact.add() { setcode { 'anonymous' } }
 
-      @fact.add { }
-    end
-    it "should instance_eval the passed block on the new resolution" do
-      @fact.add {
-        setcode { "foo" }
-      }
-      @fact.value.should == "foo"
+      expect(fact.resolution(nil)).to be_nil
     end
+  end
+
+  describe "adding resolution mechanisms by name" do
 
-    it "should re-sort the resolutions by weight, so the most restricted resolutions are first" do
-      @fact.add { self.value = "1"; self.weight = 1 }
-      @fact.add { self.value = "2"; self.weight = 2 }
-      @fact.add { self.value = "0"; self.weight = 0 }
-      @fact.value.should == "2"
+    let(:res) do
+      stub 'resolution',
+        :name => 'named',
+        :set_options => nil,
+        :resolution_type => :simple
     end
-  end
 
-  it "should be able to return a value" do
-    Facter::Util::Fact.new("yay").should respond_to(:value)
-  end
+    it "creates a new resolution if no such resolution exists" do
+      Facter::Util::Resolution.expects(:new).once.with('named', fact).returns(res)
 
-  describe "when returning a value" do
-    before do
-      @fact = Facter::Util::Fact.new("yay")
+      fact.define_resolution('named')
+
+      expect(fact.resolution('named')).to eq res
     end
 
-    it "should return nil if there are no resolutions" do
-      Facter::Util::Fact.new("yay").value.should be_nil
+    it "creates a simple resolution when the type is nil" do
+      fact.define_resolution('named')
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Util::Resolution
+    end
+
+    it "creates a simple resolution when the type is :simple" do
+      fact.define_resolution('named', :type => :simple)
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Util::Resolution
     end
 
-    it "should return the first value returned by a resolution" do
-      r1 = stub 'r1', :weight => 2, :value => nil, :suitable? => true
-      r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
-      r3 = stub 'r3', :weight => 0, :value => "foo", :suitable? => true
-      Facter::Util::Resolution.expects(:new).times(3).returns(r1).returns(r2).returns(r3)
-      @fact.add { }
-      @fact.add { }
-      @fact.add { }
+    it "creates an aggregate resolution when the type is :aggregate" do
+      fact.define_resolution('named', :type => :aggregate)
+      expect(fact.resolution('named')).to be_a_kind_of Facter::Core::Aggregate
+    end
 
-      @fact.value.should == "yay"
+    it "raises an error if there is an existing resolution with a different type" do
+      pending "We need to stop rescuing all errors when instantiating resolutions"
+      fact.define_resolution('named')
+      expect {
+        fact.define_resolution('named', :type => :aggregate)
+      }.to raise_error(ArgumentError, /Cannot return resolution.*already defined as simple/)
     end
 
-    it "should short-cut returning the value once one is found" do
-      r1 = stub 'r1', :weight => 2, :value => "foo", :suitable? => true
-      r2 = stub 'r2', :weight => 1, :suitable? => true # would fail if 'value' were asked for
-      Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
-      @fact.add { }
-      @fact.add { }
+    it "returns existing resolutions by name" do
+      Facter::Util::Resolution.expects(:new).once.with('named', fact).returns(res)
+
+      fact.define_resolution('named')
+      fact.define_resolution('named')
 
-      @fact.value
+      expect(fact.resolution('named')).to eq res
+    end
+  end
+
+  describe "when returning a value" do
+    it "returns nil if there are no resolutions" do
+      Facter::Util::Fact.new("yay").value.should be_nil
     end
 
-    it "should skip unsuitable resolutions" do
-      r1 = stub 'r1', :weight => 2, :suitable? => false # would fail if 'value' were asked for'
-      r2 = stub 'r2', :weight => 1, :value => "yay", :suitable? => true
-      Facter::Util::Resolution.expects(:new).times(2).returns(r1).returns(r2)
-      @fact.add { }
-      @fact.add { }
+    it "prefers the highest weight resolution" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add { has_weight 2; setcode { "2" } }
+      fact.add { has_weight 0; setcode { "0" } }
+      expect(fact.value).to eq "2"
+    end
 
-      @fact.value.should == "yay"
+    it "returns the first value returned by a resolution" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add { has_weight 2; setcode { nil } }
+      fact.add { has_weight 0; setcode { "0" } }
+      expect(fact.value).to eq "1"
     end
 
-    it "should return nil if the value is the empty string" do
-      r1 = stub 'r1', :suitable? => true, :value => ""
-      Facter::Util::Resolution.expects(:new).returns r1
-      @fact.add { }
+    it "skips unsuitable resolutions" do
+      fact.add { has_weight 1; setcode { "1" } }
+      fact.add do
+        def suitable?; false; end
+        has_weight 2
+        setcode { 2 }
+      end
 
-      @fact.value.should be_nil
+      expect(fact.value).to eq "1"
     end
   end
 
@@ -113,28 +128,15 @@ describe Facter::Util::Fact do
     subject do
       Facter::Util::Fact.new(:foo)
     end
-    context 'basic facts using setcode' do
-      it "flushes the cached value when invoked" do
-        system = mock('some_system_call')
-        system.expects(:data).twice.returns(100,200)
 
-        subject.add { setcode { system.data } }
-        5.times { subject.value.should == 100 }
-        subject.flush
-        subject.value.should == 200
-      end
-    end
-    context 'facts using setcode and on_flush' do
-      it 'invokes the block passed to on_flush' do
-        model = { :data => "Hello World" }
-        subject.add do
-          on_flush { model[:data] = "FLUSHED!" }
-          setcode { model[:data] }
-        end
-        subject.value.should == "Hello World"
-        subject.flush
-        subject.value.should == "FLUSHED!"
-      end
+    it "invokes #flush on all resolutions" do
+      simple = subject.add(:type => :simple)
+      simple.expects(:flush)
+
+      aggregate = subject.add(:type => :aggregate)
+      aggregate.expects(:flush)
+
+      subject.flush
     end
   end
 end

data/spec/unit/util/ip_spec.rb

@@ -408,14 +408,14 @@ describe Facter::Util::IP do
     it "support additional arguments" do
       Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
 
-      Facter::Util::Resolution.stubs(:exec).with("/sbin/ifconfig -a")
+      Facter::Core::Execution.stubs(:exec).with("/sbin/ifconfig -a")
 
       Facter::Util::IP.exec_ifconfig(["-a"])
     end
     it "joins multiple arguments correctly" do
       Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
 
-      Facter::Util::Resolution.stubs(:exec).with("/sbin/ifconfig -a -e -i -j")
+      Facter::Core::Execution.stubs(:exec).with("/sbin/ifconfig -a -e -i -j")
 
       Facter::Util::IP.exec_ifconfig(["-a","-e","-i","-j"])
     end

data/spec/unit/util/loader_spec.rb

@@ -3,24 +3,19 @@
 require 'spec_helper'
 require 'facter/util/loader'
 
-# loader subclass for making assertions about file/directory ordering
-class TestLoader < Facter::Util::Loader
-  def loaded_files
-    @loaded_files ||= []
-  end
-
-  def load_file(file)
-    loaded_files << file
-    super
-  end
-end
-
-
 describe Facter::Util::Loader do
   before :each do
     Facter::Util::Loader.any_instance.unstub(:load_all)
   end
 
+  def loader_from(places)
+    env = places[:env] || {}
+    search_path = places[:search_path] || []
+    loader = Facter::Util::Loader.new(env)
+    loader.stubs(:search_path).returns search_path
+    loader
+  end
+
   it "should have a method for loading individual facts by name" do
     Facter::Util::Loader.new.should respond_to(:load)
   end
@@ -34,20 +29,7 @@ describe Facter::Util::Loader do
   end
 
   describe "#valid_seach_path?" do
-    before :each do
-      @loader = Facter::Util::Loader.new
-      @settings = mock 'settings'
-      @settings.stubs(:value).returns "/eh"
-    end
-
-    it "should cache the result of a previous check" do
-      Pathname.any_instance.expects(:absolute?).returns(true).once
-
-      # we explicitly want two calls here to check that we get
-      # the second from the cache
-      @loader.should be_valid_search_path "/foo"
-      @loader.should be_valid_search_path "/foo"
-    end
+    let(:loader) { Facter::Util::Loader.new }
 
     # Used to have test for " " as a directory since that should
     # be a relative directory, but on Windows in both 1.8.7 and
@@ -68,7 +50,7 @@ describe Facter::Util::Loader do
       ' \/',
     ].each do |dir|
       it "should be false for relative path #{dir}" do
-        @loader.should_not be_valid_search_path dir
+        loader.should_not be_valid_search_path dir
       end
     end
     [
@@ -84,41 +66,30 @@ describe Facter::Util::Loader do
       '/ /..',
     ].each do |dir|
       it "should be true for absolute path #{dir}" do
-        @loader.should be_valid_search_path dir
+        loader.should be_valid_search_path dir
       end
     end
   end
 
   describe "when determining the search path" do
-    before do
-      @loader = Facter::Util::Loader.new
-      @settings = mock 'settings'
-      @settings.stubs(:value).returns "/eh"
-    end
+    let(:loader) { Facter::Util::Loader.new }
 
     it "should include the facter subdirectory of all paths in ruby LOAD_PATH" do
-      dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
-      @loader.stubs(:valid_search_path?).returns(true)
-      paths = @loader.search_path
+      dirs = $LOAD_PATH.collect { |d| File.expand_path('facter', d) }
+      loader.stubs(:valid_search_path?).returns(true)
+      File.stubs(:directory?).returns true
 
-      dirs.each do |dir|
-        paths.should be_include(dir)
-      end
-    end
+      paths = loader.search_path
 
-    it "should warn the user when an invalid search path has been excluded" do
-      dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
-      @loader.stubs(:valid_search_path?).returns(false)
       dirs.each do |dir|
-        Facter.expects(:debugonce).with("Relative directory #{dir} removed from search path.").once
+        paths.should be_include(dir)
       end
-      paths = @loader.search_path
     end
 
     it "should exclude invalid search paths" do
       dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
-      @loader.stubs(:valid_search_path?).returns(false)
-      paths = @loader.search_path
+      loader.stubs(:valid_search_path?).returns(false)
+      paths = loader.search_path
       dirs.each do |dir|
         paths.should_not be_include(dir)
       end
@@ -126,56 +97,93 @@ describe Facter::Util::Loader do
 
     it "should include all search paths registered with Facter" do
       Facter.expects(:search_path).returns %w{/one /two}
-      paths = @loader.search_path
+      loader.stubs(:valid_search_path?).returns true
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+      File.stubs(:directory?).with('/two').returns true
+
+      paths = loader.search_path
       paths.should be_include("/one")
       paths.should be_include("/two")
     end
 
+    it "should warn on invalid search paths registered with Facter" do
+      Facter.expects(:search_path).returns %w{/one two/three}
+      loader.stubs(:valid_search_path?).returns false
+      loader.stubs(:valid_search_path?).with('/one').returns true
+      loader.stubs(:valid_search_path?).with('two/three').returns false
+      Facter.expects(:warn).with('Excluding two/three from search path. Fact file paths must be an absolute directory').once
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+
+      paths = loader.search_path
+      paths.should be_include("/one")
+      paths.should_not be_include("two/three")
+    end
+
+    it "should strip paths that are valid paths but not are not present" do
+      Facter.expects(:search_path).returns %w{/one /two}
+      loader.stubs(:valid_search_path?).returns false
+      loader.stubs(:valid_search_path?).with('/one').returns true
+      loader.stubs(:valid_search_path?).with('/two').returns true
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+      File.stubs(:directory?).with('/two').returns false
+
+      paths = loader.search_path
+      paths.should be_include("/one")
+      paths.should_not be_include('/two')
+    end
+
     describe "and the FACTERLIB environment variable is set" do
       it "should include all paths in FACTERLIB" do
-        Facter::Util::Resolution.with_env "FACTERLIB" => "/one/path#{File::PATH_SEPARATOR}/two/path" do
-          paths = @loader.search_path
-          %w{/one/path /two/path}.each do |dir|
-            paths.should be_include(dir)
-          end
+        loader = Facter::Util::Loader.new("FACTERLIB" => "/one/path#{File::PATH_SEPARATOR}/two/path")
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one/path').returns true
+      File.stubs(:directory?).with('/two/path').returns true
+
+        loader.stubs(:valid_search_path?).returns true
+        paths = loader.search_path
+        %w{/one/path /two/path}.each do |dir|
+          paths.should be_include(dir)
         end
       end
     end
   end
 
   describe "when loading facts" do
-    before do
-      @loader = Facter::Util::Loader.new
-      @loader.stubs(:search_path).returns []
-    end
-
     it "should load values from the matching environment variable if one is present" do
+      loader = loader_from(:env => { "facter_testing" => "yayness" })
+
       Facter.expects(:add).with("testing")
 
-      Facter::Util::Resolution.with_env "facter_testing" => "yayness" do
-        @loader.load(:testing)
-      end
+      loader.load(:testing)
     end
 
     it "should load any files in the search path with names matching the fact name" do
-      @loader.expects(:search_path).returns %w{/one/dir /two/dir}
-      FileTest.stubs(:exist?).returns false
-      FileTest.expects(:exist?).with("/one/dir/testing.rb").returns true
-      FileTest.expects(:exist?).with("/two/dir/testing.rb").returns true
+      loader = loader_from(:search_path => %w{/one/dir /two/dir})
+
+      loader.expects(:search_path).returns %w{/one/dir /two/dir}
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns true
 
       Kernel.expects(:load).with("/one/dir/testing.rb")
-      Kernel.expects(:load).with("/two/dir/testing.rb")
 
-      @loader.load(:testing)
+      loader.load(:testing)
     end
 
-    it 'should load any ruby files in directories matching the fact name in the search path in sorted order regardless of the order returned by Dir.entries' do
-      @loader = TestLoader.new
+    it 'should not load any ruby files from subdirectories matching the fact name in the search path' do
+      loader = Facter::Util::Loader.new
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns true
+      Kernel.expects(:load).with("/one/dir/testing.rb")
 
-      @loader.stubs(:search_path).returns %w{/one/dir}
-      FileTest.stubs(:exist?).returns false
-      FileTest.stubs(:directory?).with("/one/dir/testing").returns true
-      @loader.stubs(:search_path).returns %w{/one/dir}
+      File.stubs(:directory?).with("/one/dir/testing").returns true
+      loader.stubs(:search_path).returns %w{/one/dir}
 
       Dir.stubs(:entries).with("/one/dir/testing").returns %w{foo.rb bar.rb}
       %w{/one/dir/testing/foo.rb /one/dir/testing/bar.rb}.each do |f|
@@ -183,163 +191,96 @@ describe Facter::Util::Loader do
         Kernel.stubs(:load).with(f)
       end
 
-      @loader.load(:testing)
-      @loader.loaded_files.should == %w{/one/dir/testing/bar.rb /one/dir/testing/foo.rb}
-    end
-
-    it "should load any ruby files in directories matching the fact name in the search path" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-      FileTest.stubs(:exist?).returns false
-      FileTest.expects(:directory?).with("/one/dir/testing").returns true
-
-      Dir.expects(:entries).with("/one/dir/testing").returns %w{two.rb}
-
-      Kernel.expects(:load).with("/one/dir/testing/two.rb")
-
-      @loader.load(:testing)
+      loader.load(:testing)
     end
 
     it "should not load files that don't end in '.rb'" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-      FileTest.stubs(:exist?).returns false
-      FileTest.expects(:directory?).with("/one/dir/testing").returns true
-
-      Dir.expects(:entries).with("/one/dir/testing").returns %w{one}
-
+      loader = Facter::Util::Loader.new
+      loader.expects(:search_path).returns %w{/one/dir}
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns false
+      File.expects(:exist?).with("/one/dir/testing").never
       Kernel.expects(:load).never
 
-      @loader.load(:testing)
+      loader.load(:testing)
     end
   end
 
   describe "when loading all facts" do
-    before :each do
-      @loader = Facter::Util::Loader.new
-      @loader.stubs(:search_path).returns []
+    let(:loader) { Facter::Util::Loader.new }
 
-      FileTest.stubs(:directory?).returns true
-    end
-
-    it "should skip directories that do not exist" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-
-      FileTest.expects(:directory?).with("/one/dir").returns false
-
-      Dir.expects(:entries).with("/one/dir").never
+    before :each do
+      loader.stubs(:search_path).returns []
 
-      @loader.load_all
+      File.stubs(:directory?).returns true
     end
 
     it "should load all files in all search paths" do
-      @loader.expects(:search_path).returns %w{/one/dir /two/dir}
-
-      Dir.expects(:entries).with("/one/dir").returns %w{a.rb b.rb}
-      Dir.expects(:entries).with("/two/dir").returns %w{c.rb d.rb}
-
-      %w{/one/dir/a.rb /one/dir/b.rb /two/dir/c.rb /two/dir/d.rb}.each { |f| Kernel.expects(:load).with(f) }
-
-      @loader.load_all
-    end
-
-    it "should load all files in all subdirectories in all search paths" do
-      @loader.expects(:search_path).returns %w{/one/dir /two/dir}
-
-      Dir.expects(:entries).with("/one/dir").returns %w{a}
-      Dir.expects(:entries).with("/two/dir").returns %w{b}
-
-      %w{/one/dir/a /two/dir/b}.each { |f| File.expects(:directory?).with(f).returns true }
-
-      Dir.expects(:entries).with("/one/dir/a").returns %w{c.rb}
-      Dir.expects(:entries).with("/two/dir/b").returns %w{d.rb}
-
-      %w{/one/dir/a/c.rb /two/dir/b/d.rb}.each { |f| Kernel.expects(:load).with(f) }
-
-      @loader.load_all
-    end
+      loader = loader_from(:search_path => %w{/one/dir /two/dir})
 
-    it 'should load all files in sorted order for any given directory regardless of the order returned by Dir.entries' do
-      @loader = TestLoader.new
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb /one/dir/b.rb}
+      Dir.expects(:glob).with('/two/dir/*.rb').returns %w{/two/dir/c.rb /two/dir/d.rb}
 
-      @loader.stubs(:search_path).returns %w{/one/dir}
-      Dir.stubs(:entries).with("/one/dir").returns %w{foo.rb bar.rb}
-
-      %w{/one/dir}.each { |f| File.stubs(:directory?).with(f).returns true }
-
-      %w{/one/dir/foo.rb /one/dir/bar.rb}.each do |f|
-        File.stubs(:directory?).with(f).returns false
+      %w{/one/dir/a.rb /one/dir/b.rb /two/dir/c.rb /two/dir/d.rb}.each do |f|
+        File.expects(:file?).with(f).returns true
         Kernel.expects(:load).with(f)
       end
 
-      @loader.load_all
-
-      @loader.loaded_files.should == %w{/one/dir/bar.rb /one/dir/foo.rb}
+      loader.load_all
     end
 
-    it "should not load files in the util subdirectory" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-
-      Dir.expects(:entries).with("/one/dir").returns %w{util}
-
-      File.expects(:directory?).with("/one/dir/util").returns true
-
-      Dir.expects(:entries).with("/one/dir/util").never
-
-      @loader.load_all
-    end
-
-    it "should not load files in a lib subdirectory" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-
-      Dir.expects(:entries).with("/one/dir").returns %w{lib}
+    it "should not try to load subdirectories of search paths" do
+      loader.expects(:search_path).returns %w{/one/dir /two/dir}
 
-      File.expects(:directory?).with("/one/dir/lib").returns true
+      # a.rb is a directory
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb /one/dir/b.rb}
+      File.expects(:file?).with('/one/dir/a.rb').returns false
+      File.expects(:file?).with('/one/dir/b.rb').returns true
+      Kernel.expects(:load).with('/one/dir/b.rb')
 
-      Dir.expects(:entries).with("/one/dir/lib").never
+      # c.rb is a directory
+      Dir.expects(:glob).with('/two/dir/*.rb').returns %w{/two/dir/c.rb /two/dir/d.rb}
+      File.expects(:file?).with('/two/dir/c.rb').returns false
+      File.expects(:file?).with('/two/dir/d.rb').returns true
+      Kernel.expects(:load).with('/two/dir/d.rb')
 
-      @loader.load_all
-    end
-
-    it "should not load files in '.' or '..'" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-
-      Dir.expects(:entries).with("/one/dir").returns %w{. ..}
-
-      File.expects(:entries).with("/one/dir/.").never
-      File.expects(:entries).with("/one/dir/..").never
-
-      @loader.load_all
+      loader.load_all
     end
 
     it "should not raise an exception when a file is unloadable" do
-      @loader.expects(:search_path).returns %w{/one/dir}
-      Dir.expects(:entries).with("/one/dir").returns %w{a.rb}
+      loader.expects(:search_path).returns %w{/one/dir}
+
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb}
+      File.expects(:file?).with('/one/dir/a.rb').returns true
 
       Kernel.expects(:load).with("/one/dir/a.rb").raises(LoadError)
       Facter.expects(:warn)
 
-      lambda { @loader.load_all }.should_not raise_error
+      expect { loader.load_all }.to_not raise_error
     end
 
     it "should load all facts from the environment" do
       Facter::Util::Resolution.with_env "facter_one" => "yayness", "facter_two" => "boo" do
-        @loader.load_all
+        loader.load_all
       end
       Facter.value(:one).should == 'yayness'
       Facter.value(:two).should == 'boo'
     end
 
     it "should only load all facts one time" do
-      @loader.expects(:load_env).once
-      @loader.load_all
-      @loader.load_all
+      loader = loader_from(:env => {})
+      loader.expects(:load_env).once
+
+      loader.load_all
+      loader.load_all
     end
   end
 
   it "should load facts on the facter search path only once" do
     facterlibdir = File.expand_path(File.dirname(__FILE__) + '../../../fixtures/unit/util/loader')
-    Facter::Util::Resolution.with_env 'FACTERLIB' => facterlibdir do
-      Facter::Util::Loader.new.load_all
-      Facter.value(:nosuchfact).should be_nil
-    end
+
+    Facter::Util::Loader.new('FACTERLIB' => facterlibdir).load_all
+
+    Facter.value(:nosuchfact).should be_nil
   end
 end