facter 1.6.18 → 1.7.0.rc1

data/spec/unit/operatingsystem_spec.rb

@@ -29,9 +29,21 @@ describe "Operating System fact" do
       Facter.fact(:operatingsystem).value.should == "Nexenta"
     end
 
-    it "should be Solaris for SunOS if no other variants match" do
+    it "should be Solaris if /etc/debian_version is missing and uname -v failed to match" do
+      FileTest.expects(:exists?).with("/etc/debian_version").returns false
       Facter.fact(:operatingsystem).value.should == "Solaris"
     end
+
+    {
+      "SmartOS"     => "joyent_20120629T002039Z",
+      "OmniOS"      => "omnios-dda4bb3",
+      "OpenIndiana" => "oi_151a",
+    }.each_pair do |distribution, string|
+      it "should be #{distribution} if uname -v is '#{string}'" do
+        Facter::Util::Resolution.stubs(:exec).with('uname -v').returns(string)
+        Facter.fact(:operatingsystem).value.should == distribution
+      end
+    end
   end
 
   describe "on Linux" do
@@ -51,6 +63,7 @@ describe "Operating System fact" do
       "MeeGo"       => "/etc/meego-release",
       "Archlinux"   => "/etc/arch-release",
       "OracleLinux" => "/etc/oracle-release",
+      "OpenWrt"     => "/etc/openwrt_release",
       "Alpine"      => "/etc/alpine-release",
       "VMWareESX"   => "/etc/vmware-release",
       "Bluewhite64" => "/etc/bluewhite64-version",
@@ -66,7 +79,7 @@ describe "Operating System fact" do
 
     describe "depending on LSB release information" do
       before :each do
-        Facter.collection.loader.load(:lsb)
+        Facter.collection.internal_loader.load(:lsb)
       end
 
       it "on Ubuntu should use the lsbdistid fact" do
@@ -87,6 +100,7 @@ describe "Operating System fact" do
       "SLC"        => "Scientific Linux CERN SLC release 5.7 (Boron)",
       "Ascendos"   => "Ascendos release 6.0 (Nameless)",
       "CloudLinux" => "CloudLinux Server release 5.5",
+      "XenServer"  => "XenServer release 5.6.0-31188p (xenenterprise)",
     }.each_pair do |operatingsystem, string|
       it "should be #{operatingsystem} based on /etc/redhat-release contents #{string}" do
         FileTest.expects(:exists?).with("/etc/redhat-release").returns true

data/spec/unit/operatingsystemmajrelease_spec.rb

@@ -0,0 +1,16 @@
+#! /usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'facter'
+
+describe "OS Major Release fact" do
+  ['Amazon','CentOS','CloudLinux','Debian','Fedora','OEL','OracleLinux','OVS','RedHat','Scientific','SLC'].each do |operatingsystem|
+    context "on #{operatingsystem} operatingsystems" do
+      it "should be derived from operatingsystemrelease" do
+        Facter.fact(:kernel).stubs(:value).returns("Linux")
+        Facter.fact(:operatingsystem).stubs(:value).returns(operatingsystem)
+        Facter.fact(:operatingsystemrelease).stubs(:value).returns("6.3")
+        Facter.fact(:operatingsystemmajrelease).value.should == "6"
+      end
+    end
+  end
+end

data/spec/unit/operatingsystemrelease_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 
+require 'facter/util/file_read'
 require 'spec_helper'
 
 describe "Operating System Release fact" do
@@ -13,6 +14,7 @@ describe "Operating System Release fact" do
   end
 
   test_cases = {
+    "OpenWrt"    => "/etc/openwrt_version",
     "CentOS"    => "/etc/redhat-release",
     "RedHat"    => "/etc/redhat-release",
     "Scientific"  => "/etc/redhat-release",
@@ -31,13 +33,19 @@ describe "Operating System Release fact" do
       it "should read the #{file.inspect} file" do
         Facter.fact(:operatingsystem).stubs(:value).returns(system)
 
-        File.expects(:open).with(file, "r").at_least(1)
+        Facter::Util::FileRead.expects(:read).with(file).at_least(1)
 
         Facter.fact(:operatingsystemrelease).value
       end
     end
   end
 
+  it "does not include trailing whitespace on Debian" do
+    Facter.fact(:operatingsystem).stubs(:value).returns("Debian")
+    Facter::Util::FileRead.stubs(:read).returns("6.0.6\n")
+    Facter.fact(:operatingsystemrelease).value.should == "6.0.6"
+  end
+
   it "for VMWareESX it should run the vmware -v command" do
     Facter.fact(:kernel).stubs(:value).returns("VMkernel")
     Facter.fact(:kernelrelease).stubs(:value).returns("4.1.0")
@@ -56,4 +64,105 @@ describe "Operating System Release fact" do
 
     Facter.fact(:operatingsystemrelease).value.should == "foo"
   end
+
+  describe "with operatingsystem reported as Solaris" do
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns('SunOS')
+      Facter.fact(:osfamily).stubs(:value).returns('Solaris')
+    end
+
+    {
+      'Solaris 8 s28_38shwp2 SPARC'                  => '28',
+      'Solaris 8 6/00 s28s_u1wos_08 SPARC'           => '28_u1',
+      'Solaris 8 10/00 s28s_u2wos_11b SPARC'         => '28_u2',
+      'Solaris 8 1/01 s28s_u3wos_08 SPARC'           => '28_u3',
+      'Solaris 8 4/01 s28s_u4wos_08 SPARC'           => '28_u4',
+      'Solaris 8 7/01 s28s_u5wos_08 SPARC'           => '28_u5',
+      'Solaris 8 10/01 s28s_u6wos_08a SPARC'         => '28_u6',
+      'Solaris 8 2/02 s28s_u7wos_08a SPARC'          => '28_u7',
+      'Solaris 8 HW 12/02 s28s_hw1wos_06a SPARC'     => '28',
+      'Solaris 8 HW 5/03 s28s_hw2wos_06a SPARC'      => '28',
+      'Solaris 8 HW 7/03 s28s_hw3wos_05a SPARC'      => '28',
+      'Solaris 8 2/04 s28s_hw4wos_05a SPARC'         => '28',
+      'Solaris 9 s9_58shwpl3 SPARC'                  => '9',
+      'Solaris 9 9/02 s9s_u1wos_08b SPARC'           => '9_u1',
+      'Solaris 9 12/02 s9s_u2wos_10 SPARC'           => '9_u2',
+      'Solaris 9 4/03 s9s_u3wos_08 SPARC'            => '9_u3',
+      'Solaris 9 8/03 s9s_u4wos_08a SPARC'           => '9_u4',
+      'Solaris 9 12/03 s9s_u5wos_08b SPARC'          => '9_u5',
+      'Solaris 9 4/04 s9s_u6wos_08a SPARC'           => '9_u6',
+      'Solaris 9 9/04 s9s_u7wos_09 SPARC'            => '9_u7',
+      'Solaris 9 9/05 s9s_u8wos_05 SPARC'            => '9_u8',
+      'Solaris 9 9/05 HW s9s_u9wos_06b SPARC'        => '9_u9',
+      'Solaris 10 3/05 s10_74L2a SPARC'              => '10',
+      'Solaris 10 3/05 HW1 s10s_wos_74L2a SPARC'     => '10',
+      'Solaris 10 3/05 HW2 s10s_hw2wos_05 SPARC'     => '10',
+      'Solaris 10 1/06 s10s_u1wos_19a SPARC'         => '10_u1',
+      'Solaris 10 6/06 s10s_u2wos_09a SPARC'         => '10_u2',
+      'Solaris 10 11/06 s10s_u3wos_10 SPARC'         => '10_u3',
+      'Solaris 10 8/07 s10s_u4wos_12b SPARC'         => '10_u4',
+      'Solaris 10 5/08 s10s_u5wos_10 SPARC'          => '10_u5',
+      'Solaris 10 10/08 s10s_u6wos_07b SPARC'        => '10_u6',
+      'Solaris 10 5/09 s10s_u7wos_08 SPARC'          => '10_u7',
+      'Solaris 10 10/09 s10s_u8wos_08a SPARC'        => '10_u8',
+      'Oracle Solaris 10 9/10 s10s_u9wos_14a SPARC'  => '10_u9',
+      'Oracle Solaris 10 8/11 s10s_u10wos_17b SPARC' => '10_u10',
+      'Solaris 10 3/05 HW1 s10x_wos_74L2a X86'       => '10',
+      'Solaris 10 1/06 s10x_u1wos_19a X86'           => '10_u1',
+      'Solaris 10 6/06 s10x_u2wos_09a X86'           => '10_u2',
+      'Solaris 10 11/06 s10x_u3wos_10 X86'           => '10_u3',
+      'Solaris 10 8/07 s10x_u4wos_12b X86'           => '10_u4',
+      'Solaris 10 5/08 s10x_u5wos_10 X86'            => '10_u5',
+      'Solaris 10 10/08 s10x_u6wos_07b X86'          => '10_u6',
+      'Solaris 10 5/09 s10x_u7wos_08 X86'            => '10_u7',
+      'Solaris 10 10/09 s10x_u8wos_08a X86'          => '10_u8',
+      'Oracle Solaris 10 9/10 s10x_u9wos_14a X86'    => '10_u9',
+      'Oracle Solaris 10 8/11 s10x_u10wos_17b X86'   => '10_u10',
+    }.each do |fakeinput,expected_output|
+      it "should be able to parse a release of #{fakeinput}" do
+        Facter::Util::FileRead.stubs(:read).with('/etc/release').returns fakeinput
+        Facter.fact(:operatingsystemrelease).value.should == expected_output
+      end
+    end
+
+    context "malformed /etc/release files" do
+      before :each do
+        Facter::Util::Resolution.any_instance.stubs(:warn)
+      end
+      it "should fallback to the kernelrelease fact if /etc/release is empty" do
+        Facter::Util::FileRead.stubs(:read).with('/etc/release').
+          raises EOFError
+        Facter.fact(:operatingsystemrelease).value.
+          should == Facter.fact(:kernelrelease).value
+      end
+
+      it "should fallback to the kernelrelease fact if /etc/release is not present" do
+        Facter::Util::FileRead.stubs(:read).with('/etc/release').
+          raises Errno::ENOENT
+        Facter.fact(:operatingsystemrelease).value.
+          should == Facter.fact(:kernelrelease).value
+      end
+
+      it "should fallback to the kernelrelease fact if /etc/release cannot be parsed" do
+        Facter::Util::FileRead.stubs(:read).with('/etc/release').
+          returns 'some future release string'
+        Facter.fact(:operatingsystemrelease).value.
+          should == Facter.fact(:kernelrelease).value
+      end
+    end
+  end
+
+  context "Ubuntu" do
+    let(:issue) { "Ubuntu 10.04.4 LTS \\n \\l\n\n" }
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+      Facter.fact(:operatingsystem).stubs(:value).returns("Ubuntu")
+    end
+
+    it "Returns only the major and minor version (not patch version)" do
+      Facter::Util::FileRead.stubs(:read).with("/etc/issue").returns(issue)
+      Facter.fact(:operatingsystemrelease).value.should == "10.04"
+    end
+  end
 end

data/spec/unit/processor_spec.rb

@@ -23,7 +23,7 @@ describe "Processor facts" do
       # processor facts belong to a file with a different name,
       # so load the file explicitly (after stubbing kernel),
       # but we have to stub execquery first
-      Facter.collection.loader.load(:processor)
+      Facter.collection.internal_loader.load(:processor)
     end
 
     describe "2003" do
@@ -69,7 +69,7 @@ describe "Processor facts" do
 
   describe "on Solaris" do
     before :each do
-      Facter.collection.loader.load(:processor)
+      Facter.collection.internal_loader.load(:processor)
       Facter.fact(:kernel).stubs(:value).returns(:sunos)
       Facter.stubs(:value).with(:kernelrelease).returns("5.10")
     end
@@ -89,7 +89,7 @@ describe "Processor facts" do
 
   describe "on Unixes" do
     before :each do
-      Facter.collection.loader.load(:processor)
+      Facter.collection.internal_loader.load(:processor)
     end
 
     it "should be 1 in SPARC fixture" do
@@ -188,6 +188,21 @@ describe "Processor facts" do
       Facter.fact(:processorcount).value.should == "2"
     end
 
+    it "should be 2 on dual-processor FreeBSD box" do
+      Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+      Facter::Util::Resolution.stubs(:exec).with("sysctl -n hw.ncpu").returns('2')
+
+      Facter.fact(:processorcount).value.should == "2"
+    end
+
+    it "should print the correct CPU Model on FreeBSD" do
+      Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+      Facter::Util::Resolution.stubs(:exec).with("sysctl -n hw.model").returns('SomeVendor CPU 3GHz')
+
+      Facter.fact(:processor).value.should == "SomeVendor CPU 3GHz"
+    end
+
+
     it "should be 2 on dual-processor DragonFly box" do
       Facter.fact(:kernel).stubs(:value).returns("DragonFly")
       Facter::Util::Resolution.stubs(:exec).with("sysctl -n hw.ncpu").returns('2')
@@ -297,7 +312,7 @@ describe "processorX facts" do
           Facter.fact(:kernel).stubs(:value).returns("AIX")
           Facter::Util::Processor.stubs(:lsdev).returns(lsdev_example)
           Facter::Util::Processor.stubs(:lsattr).returns(lsattr)
-          Facter.collection.loader.load(:processor)
+          Facter.collection.internal_loader.load(:processor)
         end
 
         lsdev_example.split("\n").each_with_index do |line, idx|
@@ -335,7 +350,7 @@ describe "processorX facts" do
             Facter.fact(:kernel).stubs(:value).returns("HP-UX")
             Facter::Util::Processor.stubs(:ioscan).returns(ioscan)
             Facter::Util::Processor.stubs(:machinfo).returns(machinfo_example)
-            Facter.collection.loader.load(:processor)
+            Facter.collection.internal_loader.load(:processor)
           end
 
           %w{ 0 1 }.each do |j|
@@ -387,12 +402,12 @@ describe "processorX facts" do
           if sm == "sched.models_present" then
             before :each do
               Facter::Util::Processor.stubs(:read_sched_models).returns(sched_models)
-              Facter.collection.loader.load(:processor)
+              Facter.collection.internal_loader.load(:processor)
             end
           else
             before :each do
               Facter::Util::Processor.stubs(:read_sched_models).returns(nil)
-              Facter.collection.loader.load(:processor)
+              Facter.collection.internal_loader.load(:processor)
             end
           end
 

data/spec/unit/ps_spec.rb

@@ -0,0 +1,42 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+
+describe "ps facts" do
+
+  it "should return busybox style ps www on OpenWrt" do
+    Facter.fact(:operatingsystem).stubs(:value).returns 'OpenWrt'
+    Facter.fact(:ps).value.should == 'ps www'
+  end
+
+  [
+    'FreeBSD',
+    'NetBSD',
+    'OpenBSD',
+    'Darwin',
+    'DragonFly'
+  ].each do |os|
+    it "should return unix style ps on operatingsystem #{os}" do
+      Facter.fact(:operatingsystem).stubs(:value).returns os
+      Facter.fact(:ps).value.should == 'ps auxwww'
+    end
+  end
+
+  # Other Linux Distros should return a ps -ef
+  [
+    'RedHat',
+    'Debian',
+  ].each do |os|
+    it "should return gnu/linux style ps -ef on operatingsystem #{os}" do
+      Facter.fact(:operatingsystem).stubs(:value).returns os
+      Facter.fact(:ps).value.should == 'ps -ef'
+    end
+  end
+
+  it "should return tasklist.exe on Windows" do
+    Facter.fact(:operatingsystem).stubs(:value).returns 'windows'
+    Facter.fact(:ps).value.should == 'tasklist.exe'
+  end
+
+end
+

data/spec/unit/ssh_spec.rb

@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby -S rspec
+
+require 'spec_helper'
+require 'facter/ssh'
+require 'pathname'
+
+describe "SSH fact" do
+
+  dirs = [  '/etc/ssh',
+    '/usr/local/etc/ssh',
+    '/etc',
+    '/usr/local/etc',
+    '/etc/opt/ssh',
+  ]
+
+  before :each do
+    # We need these facts loaded, but they belong to a file with a
+    # different name, so load the file explicitly.
+    Facter.collection.internal_loader.load(:ssh)
+  end
+
+  # fingerprints extracted from ssh-keygen -r '' -f /etc/ssh/ssh_host_dsa_key.pub
+  { 'SSHRSAKey' => [ 'ssh_host_rsa_key.pub' , "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDrs+KtR8hjasELsyCiiBplUeIi77hEHzTSQt1ALG7N4IgtMg27ZAcq0tl2/O9ZarQuClc903pgionbM9Q98CtAIoqgJwdtsor7ETRmzwrcY/mvI7ne51UzQy4Eh9WrplfpNyg+EVO0FUC7mBcay6JY30QKasePp+g4MkwK5cuTzOCzd9up9KELonlH7tTm2L0YI4HhZugwVoTFulCAZvPICxSk1B/fEKyGSZVfY/UxZNqg9g2Wyvq5u40xQ5eO882UwhB3w4IbmRnPKcyotAcqOJxA7hToMKtEmFct+vjHE8T37w8axE/1X9mdvy8IZbkEBL1cupqqb8a8vU1QTg1z", "SSHFP 1 1 1e4f163a1747d0d1a08a29972c9b5d94ee5705d0\nSSHFP 1 2 4e834c91e423d6085ed6dfb880a59e2f1b04f17c1dc17da07708af67c5ab6045" ],
+    'SSHDSAKey' => [ 'ssh_host_dsa_key.pub' , "ssh-dss AAAAB3NzaC1kc3MAAACBAKjmRez14aZT6OKhHrsw19s7u30AdghwHFQbtC+L781YjJ3UV0/WQoZ8NaDL4ovuvW23RuO49tsqSNcVHg+PtRiN2iTVAS2h55TFhaPKhTs+i0NH3p3Ze8LNSYuz8uK7a+nTxysz47GYTHiE1ke8KXe5wGKDO1TO/MUgpDbwx72LAAAAFQD9yMJCnZMiKzA7J1RNkwvgCyBKSQAAAIAtWBAsuRM0F2fdCe+F/JmgyryQmRIT5vP8E1ww3t3ywdLHklN7UMkaEKBW/TN/jj1JOGXtZ2v5XI+0VNoNKD/7dnCGzNViRT/jjfyVi6l5UMg4Q52Gv0RXJoBJpxNqFOU2niSsy8hioyE39W6LJYWJtQozGpH/KKgkCSvxBn5hlAAAAIB1yo/YD0kQICOO0KE+UMMaKtV7FwyedFJsxsWYwZfHXGwWskf0d2+lPhd9qwdbmSvySE8Qrlvu+W+X8AipwGkItSnj16ORF8kO3lfABa+7L4BLDtumt7ybjBPcHOy3n28dd07TmMtyWvLjOb0mcxPo+TwDLtHd3L/3C1Dh41jRPg==\n", "SSHFP 2 1 f63dfe8da99f50ffbcfa40a61161cee29d109f70\nSSHFP 2 2 5f57aa6be9baddd71b6049ed5d8639664a7ddf92ce293e3887f16ad0f2d459d9"  ],
+    'SSHECDSAKey' => [ 'ssh_host_ecdsa_key.pub' , 'ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBIuKHtgXQUIrXSVNKC7uY+ZOF7jjfqYNU7Cb/IncDOZ7jW44dxsfBzRJwS5sTHERjBinJskY87mmwY07NFF5GoE=', "SSHFP 3 1 091a088fd3500ad9e35ce201c5101646cbf6ff98\nSSHFP 3 2 1dd2aa8f29b539337316e2862b28c196c68ffe0af78fccf9e50625635677e50f"]
+  }.each_pair do |fact, data|
+    describe "#{fact}" do
+      let(:filename) { data[0] }
+      let(:contents) { data[1] }
+      let(:fingerprint) { data[2] }
+      let(:fingerprint_fact) { "SSHFP_#{fact[3..-4]}" }
+      let(:private_key) { /AAAA\S+/.match(contents).to_s }
+
+      # Before we start testing, we'll say that the file
+      # doesn't exist in any of our search locations.
+      # Then, when we test a specific directory, we'll
+      # toggle just that one on.
+      # This doesn't test the search order, but it does
+      # make testing each of the individual cases *way*
+      # easier.  --jeffweiss 24 May 2012
+      before(:each) do
+        dirs.each do |dir|
+          full_path = File.join(dir, filename)
+          FileTest.stubs(:file?).with(full_path).returns false
+        end
+      end
+
+      # Now, let's go through each and individually flip then
+      # on for that test.
+      dirs.each do |dir|
+        describe "when data is in #{dir}" do
+          let(:full_path) { File.join(dir, filename) }
+          before(:each) do
+            full_path = File.join(dir, filename)
+            FileTest.stubs(:file?).with(full_path).returns true
+          end
+
+          it "should find in #{dir}" do
+            FileTest.expects(:file?).with(full_path)
+            Facter.fact(fact).value
+          end
+
+          it "should match the contents" do
+            File.expects(:read).with(full_path).at_least_once.returns contents
+            Facter.fact(fact).value.should == private_key
+          end
+
+          it "should have matching fingerprint" do
+            File.expects(:read).with(full_path).at_least_once.returns contents
+            Facter.fact(fingerprint_fact).value.should == fingerprint
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/collection_spec.rb

@@ -2,58 +2,40 @@
 
 require 'spec_helper'
 require 'facter/util/collection'
+require 'facter/util/nothing_loader'
 
 describe Facter::Util::Collection do
-  it "should have a method for adding facts" do
-    Facter::Util::Collection.new.should respond_to(:add)
-  end
-
-  it "should have a method for returning a loader" do
-    Facter::Util::Collection.new.should respond_to(:loader)
-  end
-
-  it "should use an instance of the Loader class as its loader" do
-    Facter::Util::Collection.new.loader.should be_instance_of(Facter::Util::Loader)
-  end
-
-  it "should cache its loader" do
-    coll = Facter::Util::Collection.new
-    coll.loader.should equal(coll.loader)
-  end
-
-  it "should have a method for loading all facts" do
-    Facter::Util::Collection.new.should respond_to(:load_all)
+  let(:external_loader) { Facter::Util::NothingLoader.new }
+  let(:internal_loader) do
+    load = Facter::Util::Loader.new
+    load.stubs(:load).returns nil
+    load.stubs(:load_all).returns nil
+    load
   end
+  let(:collection) { Facter::Util::Collection.new(internal_loader, external_loader) }
 
   it "should delegate its load_all method to its loader" do
-    coll = Facter::Util::Collection.new
-    coll.loader.expects(:load_all)
-    coll.load_all
+    internal_loader.expects(:load_all)
+
+    collection.load_all
   end
 
   describe "when adding facts" do
-    before do
-      @coll = Facter::Util::Collection.new
-    end
-
     it "should create a new fact if no fact with the same name already exists" do
-      fact = mock 'fact'
-      Facter::Util::Fact.expects(:new).with { |name, *args| name == :myname }.returns fact
-
-      @coll.add(:myname)
+      collection.add(:myname)
+      collection.fact(:myname).name.should == :myname
     end
 
     it "should accept options" do
-      @coll.add(:myname, :ldapname => "whatever") { }
+      collection.add(:myname, :ldapname => "whatever") { }
     end
 
     it "should set any appropriate options on the fact instances" do
       # Use a real fact instance, because we're using respond_to?
       fact = Facter::Util::Fact.new(:myname)
-      fact.expects(:ldapname=).with("testing")
-      Facter::Util::Fact.expects(:new).with(:myname).returns fact
 
-      @coll.add(:myname, :ldapname => "testing")
+      collection.add(:myname, :ldapname => "testing")
+      collection.fact(:myname).ldapname.should == "testing"
     end
 
     it "should set appropriate options on the resolution instance" do
@@ -63,7 +45,7 @@ describe Facter::Util::Collection do
       resolve = Facter::Util::Resolution.new(:myname) {}
       fact.expects(:add).returns resolve
 
-      @coll.add(:myname, :timeout => "myval") {}
+      collection.add(:myname, :timeout => "myval") {}
     end
 
     it "should not pass fact-specific options to resolutions" do
@@ -76,11 +58,11 @@ describe Facter::Util::Collection do
       fact.expects(:ldapname=).with("foo")
       resolve.expects(:timeout=).with("myval")
 
-      @coll.add(:myname, :timeout => "myval", :ldapname => "foo") {}
+      collection.add(:myname, :timeout => "myval", :ldapname => "foo") {}
     end
 
     it "should fail if invalid options are provided" do
-      lambda { @coll.add(:myname, :foo => :bar) }.should raise_error(ArgumentError)
+      lambda { collection.add(:myname, :foo => :bar) }.should raise_error(ArgumentError)
     end
 
     describe "and a block is provided" do
@@ -90,175 +72,169 @@ describe Facter::Util::Collection do
 
         fact.expects(:add)
 
-        @coll.add(:myname) {}
+        collection.add(:myname) {}
       end
 
       it "should discard resolutions that throw an exception when added" do
         lambda {
-          @coll.add('yay') do
+          collection.add('yay') do
             raise
             setcode { 'yay' }
           end
         }.should_not raise_error
-        @coll.value('yay').should be_nil
+        collection.value('yay').should be_nil
       end
     end
   end
 
-  it "should have a method for retrieving facts by name" do
-    Facter::Util::Collection.new.should respond_to(:fact)
-  end
-
   describe "when retrieving facts" do
     before do
-      @coll = Facter::Util::Collection.new
-
-      @fact = @coll.add("YayNess")
+      @fact = collection.add("YayNess")
     end
 
     it "should return the fact instance specified by the name" do
-      @coll.fact("YayNess").should equal(@fact)
+      collection.fact("YayNess").should equal(@fact)
     end
 
     it "should be case-insensitive" do
-      @coll.fact("yayness").should equal(@fact)
+      collection.fact("yayness").should equal(@fact)
     end
 
     it "should treat strings and symbols equivalently" do
-      @coll.fact(:yayness).should equal(@fact)
+      collection.fact(:yayness).should equal(@fact)
     end
 
     it "should use its loader to try to load the fact if no fact can be found" do
-      @coll.loader.expects(:load).with(:testing)
-      @coll.fact("testing")
+      collection.internal_loader.expects(:load).with(:testing)
+      collection.fact("testing")
     end
 
     it "should return nil if it cannot find or load the fact" do
-      @coll.loader.expects(:load).with(:testing)
-      @coll.fact("testing").should be_nil
+      collection.internal_loader.expects(:load).with(:testing)
+      collection.fact("testing").should be_nil
     end
   end
 
-  it "should have a method for returning a fact's value" do
-    Facter::Util::Collection.new.should respond_to(:value)
-  end
-
   describe "when returning a fact's value" do
     before do
-      @coll = Facter::Util::Collection.new
-      @fact = @coll.add("YayNess")
-
-      @fact.stubs(:value).returns "result"
-    end
-
-    it "should use the 'fact' method to retrieve the fact" do
-      @coll.expects(:fact).with(:yayness).returns @fact
-      @coll.value(:yayness)
+      @fact = collection.add("YayNess", :value => "result")
     end
 
     it "should return the result of calling :value on the fact" do
-      @fact.expects(:value).returns "result"
-
-      @coll.value("YayNess").should == "result"
+      collection.value("YayNess").should == "result"
     end
 
     it "should be case-insensitive" do
-      @coll.value("yayness").should_not be_nil
+      collection.value("yayness").should == "result"
     end
 
     it "should treat strings and symbols equivalently" do
-      @coll.value(:yayness).should_not be_nil
+      collection.value(:yayness).should == "result"
     end
   end
 
   it "should return the fact's value when the array index method is used" do
-    @coll = Facter::Util::Collection.new
-    @coll.expects(:value).with("myfact").returns "foo"
-    @coll["myfact"].should == "foo"
+    collection.add("myfact", :value => "foo")
+
+    collection["myfact"].should == "foo"
   end
 
   it "should have a method for flushing all facts" do
-    @coll = Facter::Util::Collection.new
-    @fact = @coll.add("YayNess")
+    fact = collection.add("YayNess")
 
-    @fact.expects(:flush)
+    fact.expects(:flush)
 
-    @coll.flush
+    collection.flush
   end
 
   it "should have a method that returns all fact names" do
-    @coll = Facter::Util::Collection.new
-    @coll.add(:one)
-    @coll.add(:two)
+    collection.add(:one)
+    collection.add(:two)
 
-    @coll.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
-  end
-
-  it "should have a method for returning a hash of fact values" do
-    Facter::Util::Collection.new.should respond_to(:to_hash)
+    collection.list.sort { |a,b| a.to_s <=> b.to_s }.should == [:one, :two]
   end
 
   describe "when returning a hash of values" do
-    before do
-      @coll = Facter::Util::Collection.new
-      @fact = @coll.add(:one)
-      @fact.stubs(:value).returns "me"
-    end
-
     it "should return a hash of fact names and values with the fact names as strings" do
-      @coll.to_hash.should == {"one" => "me"}
-    end
+      collection.add(:one, :value => "me")
 
-    it "should not include facts that did not return a value" do
-      f = @coll.add(:two)
-      f.stubs(:value).returns nil
-      @coll.to_hash.should_not be_include(:two)
+      collection.to_hash.should == {"one" => "me"}
     end
-  end
 
-  it "should have a method for iterating over all facts" do
-    Facter::Util::Collection.new.should respond_to(:each)
-  end
+    it "should not include facts that did not return a value" do
+      collection.add(:two, :value => nil)
 
-  it "should include Enumerable" do
-    Facter::Util::Collection.ancestors.should be_include(Enumerable)
+      collection.to_hash.should_not be_include(:two)
+    end
   end
 
   describe "when iterating over facts" do
     before do
-      @coll = Facter::Util::Collection.new
-      @one = @coll.add(:one)
-      @two = @coll.add(:two)
+      collection.add(:one, :value => "ONE")
+      collection.add(:two, :value => "TWO")
     end
 
     it "should yield each fact name and the fact value" do
-      @one.stubs(:value).returns "ONE"
-      @two.stubs(:value).returns "TWO"
       facts = {}
-      @coll.each do |fact, value|
+      collection.each do |fact, value|
         facts[fact] = value
       end
       facts.should == {"one" => "ONE", "two" => "TWO"}
     end
 
     it "should convert the fact name to a string" do
-      @one.stubs(:value).returns "ONE"
-      @two.stubs(:value).returns "TWO"
       facts = {}
-      @coll.each do |fact, value|
+      collection.each do |fact, value|
         fact.should be_instance_of(String)
       end
     end
 
     it "should only yield facts that have values" do
-      @one.stubs(:value).returns "ONE"
-      @two.stubs(:value).returns nil
+      collection.add(:nil_fact, :value => nil)
       facts = {}
-      @coll.each do |fact, value|
+      collection.each do |fact, value|
         facts[fact] = value
       end
 
-      facts.should_not be_include("two")
+      facts.should_not be_include("nil_fact")
+    end
+  end
+
+  describe "when no facts are loaded" do
+    it "should warn when no facts were loaded" do
+      Facter.expects(:warnonce).with("No facts loaded from #{internal_loader.search_path.join(File::PATH_SEPARATOR)}").once
+
+      collection.fact("one")
+    end
+  end
+
+  describe "external facts" do
+    let(:collection) { Facter::Util::Collection.new(internal_loader, SingleFactLoader.new(:test_fact, "fact value")) }
+
+    it "loads when a specific fact is requested" do
+      collection.fact(:test_fact).value.should == "fact value"
+    end
+
+    it "loads when facts are listed" do
+      collection.list.should == [:test_fact]
+    end
+
+    it "loads when all facts are iterated over" do
+      facts = []
+      collection.each { |fact_name, fact_value| facts << [fact_name, fact_value] }
+
+      facts.should == [["test_fact", "fact value"]]
+    end
+  end
+
+  class SingleFactLoader
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def load(collection)
+      collection.add(@name, :value => @value)
     end
   end
 end