facter 2.1.0-x64-mingw32 → 2.2.0-x64-mingw32

data/spec/unit/rackspace_spec.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "rackspace facts" do
+  describe "on Rackspace Cloud" do
+    before :each do
+      Facter.collection.internal_loader.load(:rackspace)
+    end
+
+    it "should set is_rsc to true" do
+      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/provider").returns("Rackspace")
+      Facter.fact(:is_rsc).value.should == "true"
+    end
+
+    it "should set the region to dfw" do
+      Facter.fact(:is_rsc).stubs(:value).returns("true")
+      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/region").returns("dfw")
+      Facter.fact(:rsc_region).value.should == "dfw"
+    end
+
+    it "should get the instance id" do
+      Facter.fact(:is_rsc).stubs(:value).returns("true")
+      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read name").returns("instance-75a96685-85d6-44c6-aed8-41ef0fb2cfcc")
+      Facter.fact(:rsc_instance_id).value.should == "75a96685-85d6-44c6-aed8-41ef0fb2cfcc"
+    end
+  end
+
+  describe "not on Rackspace Cloud" do
+    before do
+      Facter.collection.internal_loader.load(:rackspace)
+    end
+
+    it "shouldn't set is_rsc" do
+      Facter::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/provider").returns("other")
+      Facter.fact(:is_rsc).value.should == nil
+    end
+  end
+end

data/spec/unit/system_uptime_spec.rb

@@ -0,0 +1,80 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/uptime'
+
+describe "system_uptime:" do
+  before { Facter.clear }
+  after { Facter.clear }
+
+  describe "When uptime information is available" do
+    describe "uptime" do
+      test_cases = [
+        [60 * 60 * 24 * 3,      '3 days'],
+        [60 * 60 * 24 * 3 + 25, '3 days'],
+        [60 * 60 * 24 * 1,      '1 day'],
+        [60 * 60 * 24 * 1 + 25, '1 day'],
+        [60 * (60 * 3 + 45),    '3:45 hours'],
+        [60 * (60 * 3 + 4),     '3:04 hours'],
+        [60 * 60,               '1:00 hours'],
+        [60 * 35,               '0:35 hours']
+      ]
+
+      test_cases.each do |seconds, expected|
+        it "should return #{expected.inspect} for #{seconds} seconds in Linux" do
+          Facter.fact(:kernel).stubs(:value).returns("linux")
+          Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(seconds)
+          Facter.fact(:system_uptime).value['uptime'].should eq expected
+        end
+
+        it "should return #{expected.inspect} for #{seconds} seconds in Windows" do
+          Facter.fact(:kernel).stubs(:value).returns("windows")
+          Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(seconds)
+          Facter.fact(:system_uptime).value['uptime'].should eq expected
+        end
+      end
+    end
+  end
+
+  describe "when uptime information is available" do
+    before do
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(60 * 60 * 24 + 23)
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(60 * 60 * 24 + 23)
+    end
+
+    it "should include a key for seconds" do
+      Facter.fact(:system_uptime).value['seconds'].should eq 60 * 60 * 24 + 23
+    end
+
+     it "should include a key for hours" do
+      Facter.fact(:system_uptime).value['hours'].should eq 24
+    end
+
+    it "should include a key for days" do
+      Facter.fact(:system_uptime).value['days'].should eq 1
+    end
+  end
+
+  describe "when uptime information is not available" do
+    before do
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_unix).returns(nil)
+      Facter::Util::Uptime.stubs(:get_uptime_seconds_win).returns(nil)
+    end
+
+    it "should have an 'uptime' key with value 'unknown'" do
+      Facter.fact(:system_uptime).value['uptime'].should eq "unknown"
+    end
+
+    it "should have a 'seconds' key with value nil" do
+      Facter.fact(:system_uptime).value['seconds'].should eq nil
+    end
+
+    it "should have a 'hours' key with value nil" do
+      Facter.fact(:system_uptime).value['hours'].should eq nil
+    end
+
+    it "should have a 'days' key with value nil" do
+      Facter.fact(:system_uptime).value['days'].should eq nil
+    end
+  end
+end

data/spec/unit/util/formatter_spec.rb

@@ -27,12 +27,17 @@ describe Facter::Util::Formatter do
       expect(described_class.format_plaintext({"foo" => "bar"})).to eq "bar"
     end
 
+    it "can return false:FalseClass as a single fact value" do
+      expect(described_class.format_plaintext({"foo" => false})).to eq "false"
+    end
+
     it "formats a structured value with #inspect" do
       value = ["bar"]
       value.expects(:inspect).returns %Q(["bar"])
       hash = {"foo" => value, "baz" => "quux"}
       expect(described_class.format_plaintext(hash)).to match(%Q([bar]))
     end
+
     it "formats multiple string values as key/value pairs" do
       hash = {"foo" => "bar", "baz" => "quux"}
       expect(described_class.format_plaintext(hash)).to match(/foo => bar/)

data/spec/unit/util/macaddress_spec.rb

@@ -91,6 +91,8 @@ describe "The macaddress fact" do
 
     before :each do
       Facter.fact(:kernel).stubs(:value).returns('windows')
+      Facter.fact(:operatingsystem).stubs(:value).returns('windows')
+      Facter.fact(:osfamily).stubs(:value).returns('windows')
       Facter::Util::Registry.stubs(:hklm_read).returns(nic_bindings)
     end
 

data/spec/unit/util/processor_spec.rb

@@ -89,4 +89,124 @@ describe Facter::Util::Processor do
       Facter::Util::Processor.enum_kstat[7].should == "SPARC64-VII"
     end
   end
+
+  describe "on AIX" do
+    let(:lsattr) do
+      "type PowerPC_POWER5 Processor type False\n"
+    end
+
+    def lsdev_examples
+      examples = "proc0  Available 00-00 Processor\n" +
+        "proc4  Available 00-04 Processor\n" +
+        "proc8  Defined   00-08 Processor\n" +
+        "proc12 Defined   00-12 Processor\n"
+      examples
+    end
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("AIX")
+      Facter::Util::Processor.stubs(:lsdev).returns(lsdev_examples)
+      Facter::Util::Processor.stubs(:lsattr).returns(lsattr)
+    end
+
+    it "should create an array of processors" do
+      Facter::Util::Processor.aix_processor_list[0].should eq "PowerPC_POWER5"
+      Facter::Util::Processor.aix_processor_list[1].should eq "PowerPC_POWER5"
+      Facter::Util::Processor.aix_processor_list[2].should eq "PowerPC_POWER5"
+    end
+  end
+
+  describe "on HP-UX" do
+    let(:ioscan) do
+      "Class       I  H/W Path  Driver    S/W State H/W Type  Description\n" +
+      "===================================================================\n" +
+      "processor   0  0/120     processor CLAIMED   PROCESSOR Processor\n" +
+      "processor   1  0/123     processor CLAIMED   PROCESSOR Processor\n"
+    end
+
+    describe "when machinfo is available" do
+      def self.machinfo_examples
+        examples = []
+        examples << [File.read(fixtures('hpux','machinfo','ia64-rx2620')), "Intel(R) Itanium 2 processor"]
+        examples << [File.read(fixtures('hpux','machinfo','ia64-rx6600')), "Intel(R) Itanium 2 9100 series processor (1.59 GHz, 18 MB)"]
+        examples << [File.read(fixtures('hpux','machinfo','ia64-rx8640')), "Intel(R) Itanium 2 9100 series"]
+        examples << [File.read(fixtures('hpux','machinfo','hppa-rp4440')), "PA-RISC 8800 processor (1000 MHz, 64 MB)"]
+        examples << [File.read(fixtures('hpux','machinfo','superdome-server-SD32B')), "Intel(R) Itanium 2 9000 series"]
+        examples << [File.read(fixtures('hpux','machinfo','superdome2-16s')), "Intel(R)  Itanium(R)  Processor 9340 (1.6 GHz, 15 MB)"]
+        examples
+      end
+
+      machinfo_examples.each_with_index do |example, i|
+        machinfo_example, expected_cpu = example
+        context "machinfo example ##{i}" do
+          before :each do
+            Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+            Facter::Util::Processor.stubs(:ioscan).returns(ioscan)
+            Facter::Util::Processor.stubs(:machinfo).returns(machinfo_example)
+          end
+
+          %w{ 0 1 }.each do |j|
+            it "should find #{expected_cpu}" do
+              Facter::Util::Processor.hpux_processor_list[j.to_i].should eq expected_cpu
+            end
+          end
+        end
+      end
+    end
+
+    describe "when machinfo is not available" do
+      def self.model_and_getconf_examples
+        examples = []
+        examples << ["9000/800/L3000-5x",     "sched.models_present", "unistd.h_present", "532", "616",       "PA-RISC 8600 processor"]
+        examples << ["9000/800/L3000-5x",     "",                     "unistd.h_present", "532", "616",       "HP PA-RISC2.0 CHIP TYPE #616"]
+        examples << ["9000/800/L3000-5x",     "",                     "",                 "532", "616",       "CPU v532 CHIP TYPE #616"]
+        examples << ["ia64 hp server rx2660", "sched.models_present", "unistd.h_present", "768", "536936708", "IA-64 archrev 0 CHIP TYPE #536936708"]
+        examples << ["ia64 hp server rx2660", "",                     "unistd.h_present", "768", "536936708", "IA-64 archrev 0 CHIP TYPE #536936708"]
+        examples << ["ia64 hp server rx2660", "",                     "",                 "768", "536936708", "CPU v768 CHIP TYPE #536936708"]
+        examples
+      end
+
+      sched_models = File.readlines(fixtures('hpux','sched.models'))
+      unistd_h     = File.readlines(fixtures('hpux','unistd.h'))
+      model_and_getconf_examples.each_with_index do |example, i|
+        model_example, sm, unistd, getconf_cpu_ver, getconf_chip_type, expected_cpu = example
+        context "and model and getconf example ##{i}" do
+          before :each do
+            Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+            Facter::Util::Processor.stubs(:ioscan).returns(ioscan)
+            Facter::Util::Processor.stubs(:getconf_cpu_version).returns(getconf_cpu_ver)
+            Facter::Util::Processor.stubs(:getconf_cpu_chip_type).returns(getconf_chip_type)
+            Facter::Util::Processor.stubs(:machinfo).returns(nil)
+            Facter::Util::Processor.stubs(:model).returns(model_example)
+          end
+
+          if unistd == "unistd.h_present" then
+            before :each do
+              Facter::Util::Processor.stubs(:read_unistd_h).returns(unistd_h)
+            end
+          else
+            before :each do
+              Facter::Util::Processor.stubs(:read_unistd_h).returns(nil)
+            end
+          end
+
+          if sm == "sched.models_present" then
+            before :each do
+              Facter::Util::Processor.stubs(:read_sched_models).returns(sched_models)
+            end
+          else
+            before :each do
+              Facter::Util::Processor.stubs(:read_sched_models).returns(nil)
+            end
+          end
+
+          %w{ 0 1 }.each do |j|
+            it "should find #{expected_cpu}" do
+              Facter::Util::Processor.hpux_processor_list[j.to_i].should eq expected_cpu
+            end
+          end
+        end
+      end
+    end
+  end
 end

data/spec/unit/util/uptime_spec.rb

@@ -2,6 +2,7 @@
 
 require 'spec_helper'
 require 'facter/util/uptime'
+require 'facter/util/posix'
 
 describe Facter::Util::Uptime do
 
@@ -26,15 +27,13 @@ describe Facter::Util::Uptime do
       end
 
       it "should use 'sysctl -n kern.boottime' on OpenBSD" do
-        sysctl_output_file = my_fixture('sysctl_kern_boottime_openbsd') # Dec 09 21:11:46 +0000 2011
-        Facter::Util::Uptime.stubs(:uptime_sysctl_cmd).returns("cat \"#{sysctl_output_file}\"")
+        Facter::Util::POSIX.stubs(:sysctl).returns(my_fixture_read("sysctl_kern_boottime_openbsd"))
         Time.stubs(:now).returns Time.parse("Dec 09 22:11:46 +0000 2011") # one hour later
         Facter::Util::Uptime.get_uptime_seconds_unix.should == 60 * 60
       end
 
       it "should use 'sysctl -n kern.boottime' on Darwin, etc." do
-        sysctl_output_file = my_fixture('sysctl_kern_boottime_darwin') # Oct 30 21:52:27 +0000 2011
-        Facter::Util::Uptime.stubs(:uptime_sysctl_cmd).returns("cat \"#{sysctl_output_file}\"")
+        Facter::Util::POSIX.stubs(:sysctl).returns(my_fixture_read("sysctl_kern_boottime_darwin"))
         Time.stubs(:now).returns Time.parse("Oct 30 22:52:27 +0000 2011") # one hour later
         Facter::Util::Uptime.get_uptime_seconds_unix.should == 60 * 60
       end

data/spec/unit/util/virtual_spec.rb

@@ -223,6 +223,14 @@ describe Facter::Util::Virtual do
     Facter::Util::Virtual.should be_kvm
   end
 
+  it "should detect kvm on SunOS" do
+    FileTest.stubs(:exists?).with("/proc/cpuinfo").returns(false)
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    FileTest.stubs(:exists?).with("/usr/sbin/prtconf").returns(true)
+    Facter::Core::Execution.stubs(:exec).with("/usr/sbin/prtconf -v").returns("Qemu virtual machine")
+    Facter::Util::Virtual.should be_kvm
+  end
+
   it "should identify FreeBSD jail when in jail" do
     Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
     Facter::Core::Execution.stubs(:exec).with("/sbin/sysctl -n security.jail.jailed").returns("1")

data/spec/unit/util/xendomains_spec.rb

@@ -4,18 +4,63 @@ require 'spec_helper'
 require 'facter/util/xendomains'
 
 describe Facter::Util::Xendomains do
-  describe ".get_domains" do
-    it "should return a list of running Xen Domains on Xen0" do
-      xen0_domains = my_fixture_read("xendomains")
-      Facter::Core::Execution.stubs(:exec).with('/usr/sbin/xm list 2>/dev/null').returns(xen0_domains)
-      Facter::Util::Xendomains.get_domains.should == %{web01,mailserver}
+
+  let(:xen0_domains) { my_fixture_read("xendomains") }
+
+  describe "when the xl command is present" do
+    before do
+      Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xl').returns('/usr/sbin/xl')
     end
 
-    describe "when xm list isn't executable" do
-      it "should be nil" do
-        Facter::Core::Execution.stubs(:exec).with('/usr/sbin/xm list 2>/dev/null').returns(nil)
-        Facter::Util::Xendomains.get_domains.should == nil
+    describe "and the xm command is not present" do
+
+      before do
+        Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xm').returns(nil)
+        Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xm list 2>/dev/null').never
       end
+
+      it "lists the domains running on Xen0 with the 'xl' command" do
+        Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xl list 2>/dev/null').returns(xen0_domains)
+        Facter::Util::Xendomains.get_domains.should == %{web01,mailserver}
+      end
+    end
+
+    describe "and the xm command is also present" do
+      before do
+        Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xm').returns('/usr/bin/xm')
+        Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xm list 2>/dev/null').never
+      end
+
+      it "prefers xl over xm" do
+        Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xl list 2>/dev/null').returns(xen0_domains)
+        Facter::Util::Xendomains.get_domains.should == %{web01,mailserver}
+      end
+    end
+  end
+
+  describe "when xl is not present" do
+    before do
+      Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xl').returns(nil)
+      Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xl list 2>/dev/null').never
+    end
+
+    describe "and the xm command is present" do
+      before do
+        Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xm').returns('/usr/sbin/xm')
+      end
+
+      it "lists the domains running on Xen0 with the 'xm' command" do
+        Facter::Util::Resolution.expects(:exec).with('/usr/sbin/xm list 2>/dev/null').returns(xen0_domains)
+        Facter::Util::Xendomains.get_domains.should == %{web01,mailserver}
+      end
+    end
+  end
+
+  describe "neither xl or xm are present" do
+    it "returns nil" do
+      Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xl').returns(nil)
+      Facter::Util::Resolution.stubs(:which).with('/usr/sbin/xm').returns(nil)
+      Facter::Util::Xendomains.get_domains.should == nil
     end
   end
 end

data/spec/unit/virtual_spec.rb

@@ -24,6 +24,7 @@ describe "Virtual fact" do
 
   it "should be zone on Solaris when a zone" do
     Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    Facter.fact(:operatingsystem).stubs(:value).returns("Solaris")
     Facter::Util::Virtual.stubs(:zone?).returns(true)
     Facter::Util::Virtual.stubs(:vserver?).returns(false)
     Facter::Util::Virtual.stubs(:xen?).returns(false)
@@ -39,6 +40,7 @@ describe "Virtual fact" do
 
   it "should be hpvm on HP-UX when in HP-VM" do
     Facter.fact(:kernel).stubs(:value).returns("HP-UX")
+    Facter.fact(:operatingsystem).stubs(:value).returns("HP-UX")
     Facter::Util::Virtual.stubs(:hpvm?).returns(true)
     Facter.fact(:virtual).value.should == "hpvm"
   end
@@ -303,6 +305,11 @@ describe "Virtual fact" do
       Facter::Util::POSIX.stubs(:sysctl).with('hw.product').returns("oVirt Node")
       Facter.fact(:virtual).value.should == "ovirt"
     end
+
+    it "should be kvm with KVM product name from sysctl" do
+      Facter::Util::POSIX.stubs(:sysctl).with('hw.product').returns("KVM")
+      Facter.fact(:virtual).value.should == "kvm"
+    end
   end
 
   describe "on Windows" do
@@ -499,7 +506,7 @@ describe "is_virtual fact" do
     Facter.fact(:is_virtual).value.should == "true"
   end
 
-  it "should be true when running on ovirt" do
+  it "should be true when running on gce" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("gce")
     Facter.fact(:is_virtual).value.should == "true"

data/spec/unit/zfs_version_spec.rb

@@ -18,31 +18,47 @@ describe "zfs_version fact" do
     Facter::Core::Execution.stubs(:which).with("zfs").returns("/usr/bin/zfs")
   end
 
+  it "should return nil on old versions of Solaris 10" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_old'))
+    Facter.fact(:zfs_version).value.should == nil
+  end
+
   it "should return correct version on Solaris 10" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('solaris_10'))
     Facter.fact(:zfs_version).value.should == "3"
   end
 
   it "should return correct version on Solaris 11" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('solaris_11'))
     Facter.fact(:zfs_version).value.should == "5"
   end
 
   it "should return correct version on FreeBSD 8.2" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('freebsd_8.2'))
     Facter.fact(:zfs_version).value.should == "4"
   end
 
   it "should return correct version on FreeBSD 9.0" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('freebsd_9.0'))
     Facter.fact(:zfs_version).value.should == "5"
   end
 
   it "should return correct version on Linux with ZFS-fuse" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('linux-fuse_0.6.9'))
     Facter.fact(:zfs_version).value.should == "4"
   end
 
+  it "should return correct version on Linux with zfsonlinux" do
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
+    Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('zfsonlinux_0.6.1'))
+    Facter.fact(:zfs_version).value.should == "5"
+  end
+
   it "should return nil if zfs command is not available" do
     Facter::Core::Execution.stubs(:which).with("zfs").returns(nil)
     Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('linux-fuse_0.6.9'))
@@ -50,20 +66,16 @@ describe "zfs_version fact" do
   end
 
   it "should return nil if zfs fails to run" do
-    Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns('')
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(nil)
     Facter.fact(:zfs_version).value.should == nil
   end
 
   it "handles the zfs command becoming available at a later point in time" do
     # Simulate Puppet configuring the zfs tools from a persistent daemon by
     # simulating three sequential responses to which('zfs').
-    Facter::Core::Execution.stubs(:which).
-      with("zfs").
-      returns(nil,nil,"/usr/bin/zfs")
-    Facter::Core::Execution.stubs(:exec).
-      with("zfs upgrade -v").
-      returns(my_fixture_read('linux-fuse_0.6.9'))
-
+    Facter::Core::Execution.stubs(:which).with("zfs").returns(nil,nil,"/usr/bin/zfs")
+    Facter::Core::Execution.stubs(:exec).with("zfs -? 2> /dev/null").returns(my_fixture_read('zfs_new'))
+    Facter::Core::Execution.stubs(:exec).with("zfs upgrade -v").returns(my_fixture_read('linux-fuse_0.6.9'))
     fact = Facter.fact(:zfs_version)
 
     # zfs is not present the first two times the fact is resolved.