facter 2.2.0 → 2.3.0

data/spec/unit/physicalprocessorcount_spec.rb

@@ -7,7 +7,7 @@ describe "Physical processor count fact" do
     it "should return the value of the 'physicalcount' key of the 'processors' fact on #{kernel}" do
       Facter.fact(:kernel).stubs(:value).returns("#{kernel}")
       Facter.fact("processors").stubs(:value).returns({"physicalcount" => 2, "count" => 4})
-      Facter.fact("physicalprocessorcount").value.should eq "2"
+      Facter.fact("physicalprocessorcount").value.should eq 2
     end
   end
 end

data/spec/unit/processor_spec.rb

@@ -23,7 +23,7 @@ describe "Processor facts" do
       Facter.fact(:kernel).stubs(:value).returns("linux")
       Facter.fact("processors").stubs(:value).returns({"count" => 8, "physicalcount" => 4 })
       Facter.collection.internal_loader.load(:processor)
-      Facter.fact(:processorcount).value.should eq "8"
+      Facter.fact(:processorcount).value.should eq 8
     end
   end
 

data/spec/unit/processors/os_spec.rb

@@ -264,7 +264,7 @@ describe Facter::Processors::Darwin, :unless => Facter::Util::Config.is_windows?
   include_context "processor list"
 
   before :each do
-    Facter::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml SPHardwareDataType").returns(my_fixture_read("darwin-system-profiler"))
+    Facter::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml SPHardwareDataType 2>/dev/null").returns(my_fixture_read("darwin-system-profiler"))
     subject.stubs(:query_system_profiler).returns({"number_processors" => 4, "current_processor_speed" => "2.3 GHz"})
     subject.instance_variable_set :@system_hardware_data, {"number_processors" => 4, "current_processor_speed" => "2.3 GHz"}
   end
@@ -368,6 +368,20 @@ describe Facter::Processors::OpenBSD do
       expect(count).to eq 2
     end
   end
+
+  describe "getting the processor speed" do
+    it "should delegate to the sysctl utility (GHz)" do
+      Facter::Util::POSIX.expects(:sysctl).with("hw.cpuspeed").once.returns("2501")
+      speed = subject.get_processor_speed
+      expect(speed).to eq "2.5 GHz"
+    end
+
+    it "should delegate to the sysctl utility (MHz)" do
+      Facter::Util::POSIX.expects(:sysctl).with("hw.cpuspeed").once.returns("123")
+      speed = subject.get_processor_speed
+      expect(speed).to eq "123 MHz"
+    end
+  end
 end
 
 describe Facter::Processors::SunOS do

data/spec/unit/rackspace_spec.rb

@@ -10,13 +10,13 @@ describe "rackspace facts" do
     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::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/provider 2> /dev/null").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::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/region 2> /dev/null").returns("dfw")
       Facter.fact(:rsc_region).value.should == "dfw"
     end
 
@@ -33,7 +33,7 @@ describe "rackspace facts" do
     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::Util::Resolution.stubs(:exec).with("/usr/bin/xenstore-read vm-data/provider_data/provider 2> /dev/null").returns("other")
       Facter.fact(:is_rsc).value.should == nil
     end
   end

data/spec/unit/rubyplatform_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "ruby platform" do
+  it "should return the ruby platform" do
+    expect(Facter.fact(:rubyplatform).value).to eq(RUBY_PLATFORM.to_s)
+  end
+end

data/spec/unit/selinux_spec.rb

@@ -17,7 +17,7 @@ describe "SELinux facts" do
 
       FileTest.expects(:exists?).with("/selinux/enforce").returns true
 
-      Facter.fact(:selinux).value.should == "true"
+      Facter.fact(:selinux).value.should == true
     end
 
     it "and return true with selinuxfs path from /proc" do
@@ -29,7 +29,7 @@ describe "SELinux facts" do
       FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
       File.expects(:read).with("/proc/self/attr/current").returns("kernel")
 
-      Facter.fact(:selinux).value.should == "true"
+      Facter.fact(:selinux).value.should == true
     end
 
     it "and return true with multiple selinuxfs mounts from /proc" do
@@ -44,13 +44,13 @@ describe "SELinux facts" do
       FileTest.expects(:exists?).with("/proc/self/attr/current").returns true
       File.expects(:read).with("/proc/self/attr/current").returns("kernel")
 
-      Facter.fact(:selinux).value.should == "true"
+      Facter.fact(:selinux).value.should == true
     end
   end
 
   describe "when selinux is present" do
     before :each do
-      Facter.fact(:selinux).stubs(:value).returns("true")
+      Facter.fact(:selinux).stubs(:value).returns(true)
     end
 
     it "should return true if SELinux policy enabled" do
@@ -59,7 +59,7 @@ describe "SELinux facts" do
       FileTest.expects(:exists?).with("/selinux/enforce").returns true
       File.expects(:read).with("/selinux/enforce").returns("1")
 
-      Facter.fact(:selinux_enforced).value.should == "true"
+      Facter.fact(:selinux_enforced).value.should == true
     end
 
     it "should return an SELinux policy version" do

data/spec/unit/system32_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe "system32 fact" do
+  let(:systemroot) { 'D:\Windows' }
+  let(:sysnative)  { "#{systemroot}\\sysnative" }
+  let(:system32)   { "#{systemroot}\\system32" }
+
+  before(:each) do
+    Facter.fact(:kernel).stubs(:value).returns("windows")
+    ENV['SYSTEMROOT'] = systemroot
+  end
+
+  describe "when running in 32-bit ruby" do
+    it "resolves to sysnative" do
+      File.expects(:exists?).with(sysnative).returns(true)
+
+      expect(Facter.fact(:system32).value).to eq(sysnative)
+    end
+  end
+
+  describe "when running in 64-bit ruby" do
+    it "resolves to system32" do
+      File.expects(:exists?).with(sysnative).returns(false)
+
+      expect(Facter.fact(:system32).value).to eq(system32)
+    end
+  end
+end

data/spec/unit/util/macosx_spec.rb

@@ -28,7 +28,7 @@ describe "Facter::Util::Macosx", :unless => Facter::Util::Config.is_windows? do
   end
 
   it "should be able to retrieve profiler data as xml for a given data field" do
-    Facter::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
+    Facter::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml foo 2>/dev/null").returns "yay"
     Facter::Util::Macosx.profiler_xml("foo").should == "yay"
   end
 

data/spec/unit/util/parser_spec.rb

@@ -174,9 +174,9 @@ describe Facter::Util::Parser do
     describe "powershell parser" do
       let(:ps1) { "/tmp/foo.ps1" }
 
-      def expects_to_parse_powershell(cmd, content, result)
+      def expects_to_parse_powershell(cmd, result)
         Facter::Util::Config.stubs(:is_windows?).returns(true)
-        Facter::Core::Execution.stubs(:exec).returns(content)
+
         File.stubs(:file?).with(ps1).returns(true)
 
         Facter::Util::Parser.parser_for(cmd).results.should == result
@@ -187,7 +187,40 @@ describe Facter::Util::Parser do
       end
 
       it "should parse output from powershell" do
-        expects_to_parse_powershell(ps1, data_in_txt, data)
+        Facter::Core::Execution.stubs(:exec).returns(data_in_txt)
+        expects_to_parse_powershell(ps1, data)
+      end
+
+      describe "when executing powershell", :if => Facter::Util::Config.is_windows? do
+        let(:sysnative_powershell) { "#{ENV['SYSTEMROOT']}\\sysnative\\WindowsPowershell\\v1.0\\powershell.exe" }
+        let(:system32_powershell)  { "#{ENV['SYSTEMROOT']}\\system32\\WindowsPowershell\\v1.0\\powershell.exe" }
+
+        let(:sysnative_regexp)  { /^\"#{Regexp.escape(sysnative_powershell)}\"/ }
+        let(:system32_regexp)   { /^\"#{Regexp.escape(system32_powershell)}\"/ }
+        let(:powershell_regexp) { /^\"#{Regexp.escape("powershell.exe")}\"/ }
+
+        it "prefers the sysnative alias to resolve 64-bit powershell on 32-bit ruby" do
+          File.expects(:exists?).with(sysnative_powershell).returns(true)
+          Facter::Core::Execution.expects(:exec).with(regexp_matches(sysnative_regexp)).returns(data_in_txt)
+
+          expects_to_parse_powershell(ps1, data)
+        end
+
+        it "uses system32 if sysnative alias doesn't exist on 64-bit ruby" do
+          File.expects(:exists?).with(sysnative_powershell).returns(false)
+          File.expects(:exists?).with(system32_powershell).returns(true)
+          Facter::Core::Execution.expects(:exec).with(regexp_matches(system32_regexp)).returns(data_in_txt)
+
+          expects_to_parse_powershell(ps1, data)
+        end
+
+        it "uses 'powershell' as a last resort" do
+          File.expects(:exists?).with(sysnative_powershell).returns(false)
+          File.expects(:exists?).with(system32_powershell).returns(false)
+          Facter::Core::Execution.expects(:exec).with(regexp_matches(powershell_regexp)).returns(data_in_txt)
+
+          expects_to_parse_powershell(ps1, data)
+        end
       end
     end
   end

data/spec/unit/util/uptime_spec.rb

@@ -98,14 +98,14 @@ describe Facter::Util::Uptime do
 
           test_cases.each do |uptime, expected|
             it "should return #{expected} for #{uptime}" do
-              Facter::Core::Execution.stubs(:execute).with('uptime 2>/dev/null', {:on_fail => nil}).returns(uptime)
+              Facter::Core::Execution.stubs(:execute).with('/usr/bin/uptime 2>/dev/null', {:on_fail => nil}).returns(uptime)
               Facter.fact(:uptime_seconds).value.should == expected
             end
           end
 
           describe "nor is 'uptime' command" do
             before :each do
-              Facter::Core::Execution.stubs(:execute).with('uptime 2>/dev/null', {:on_fail => nil}).returns(nil)
+              Facter::Core::Execution.stubs(:execute).with('/usr/bin/uptime 2>/dev/null', {:on_fail => nil}).returns(nil)
             end
 
             it "should return nil" do

data/spec/unit/virtual_spec.rb

@@ -73,6 +73,26 @@ describe "Virtual fact" do
     end
   end
 
+  describe "on FreeBSD" do
+    before(:each) do
+      Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
+      Facter.fact(:operatingsystem).stubs(:value).returns("FreeBSD")
+    end
+
+    it "should be kvm with virtio device pciconf -lv 2>/dev/null" do
+      Facter::Core::Execution.stubs(:exec).with('/sbin/sysctl -n security.jail.jailed').returns('0')
+      Facter::Util::Virtual.stubs(:lspci).returns("virtio_pci4@pci0:0:8:0:	class=0x020000 card=0x00011af4 chip=0x10001af4 rev=0x00 hdr=0x00")
+      Facter.fact(:virtual).value.should == "kvm"
+    end
+
+    it "should be bochs with Bochs vendor name from dmidecode" do
+      Facter::Core::Execution.stubs(:exec).with('/sbin/sysctl -n security.jail.jailed').returns('0')
+      Facter::Core::Execution.stubs(:exec).with('pciconf -lv 2>/dev/null').returns(nil)
+      Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns("Manufacturer: Bochs")
+      Facter.fact(:virtual).value.should == "bochs"
+    end
+  end
+
   describe "on Linux" do
     before(:each) do
       Facter.fact(:kernel).stubs(:value).returns("Linux")
@@ -251,7 +271,7 @@ describe "Virtual fact" do
       Facter.fact(:hardwaremodel).stubs(:value).returns(nil)
       Facter::Core::Execution.stubs(:exec).with('lspci 2>/dev/null').returns(nil)
       Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns(nil)
-      Facter::Core::Execution.stubs(:exec).with('prtdiag').returns("System Configuration: VMware, Inc. VMware Virtual Platform")
+      Facter::Core::Execution.stubs(:exec).with('prtdiag 2>/dev/null').returns("System Configuration: VMware, Inc. VMware Virtual Platform")
       Facter.fact(:virtual).value.should == "vmware"
     end
 
@@ -259,7 +279,7 @@ describe "Virtual fact" do
       Facter.fact(:hardwaremodel).stubs(:value).returns(nil)
       Facter::Core::Execution.stubs(:exec).with('lspci 2>/dev/null').returns(nil)
       Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns(nil)
-      Facter::Core::Execution.stubs(:exec).with('prtdiag').returns("System Configuration: Parallels Virtual Platform")
+      Facter::Core::Execution.stubs(:exec).with('prtdiag 2>/dev/null').returns("System Configuration: Parallels Virtual Platform")
       Facter.fact(:virtual).value.should == "parallels"
     end
 
@@ -267,7 +287,7 @@ describe "Virtual fact" do
       Facter.fact(:hardwaremodel).stubs(:value).returns(nil)
       Facter::Core::Execution.stubs(:exec).with('lspci 2>/dev/null').returns(nil)
       Facter::Core::Execution.stubs(:exec).with('dmidecode 2> /dev/null').returns(nil)
-      Facter::Core::Execution.stubs(:exec).with('prtdiag').returns("System Configuration: innotek GmbH VirtualBox")
+      Facter::Core::Execution.stubs(:exec).with('prtdiag 2>/dev/null').returns("System Configuration: innotek GmbH VirtualBox")
       Facter.fact(:virtual).value.should == "virtualbox"
     end
   end
@@ -388,139 +408,145 @@ describe "is_virtual fact" do
   it "should be virtual when running on xen" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("xenu")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be false when running on xen0" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("xen0")
-    Facter.fact(:is_virtual).value.should == "false"
+    Facter.fact(:is_virtual).value.should == false
   end
 
   it "should be true when running on xenhvm" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("xenhvm")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be false when running on physical" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("physical")
-    Facter.fact(:is_virtual).value.should == "false"
+    Facter.fact(:is_virtual).value.should == false
   end
 
   it "should be true when running on vmware" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("vmware")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on virtualbox" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("virtualbox")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on openvzve" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("openvzve")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on vserver" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("vserver")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on kvm" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("kvm")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running in jail" do
     Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
     Facter.fact(:virtual).stubs(:value).returns("jail")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running in zone" do
     Facter.fact(:kernel).stubs(:value).returns("SunOS")
     Facter.fact(:virtual).stubs(:value).returns("zone")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on hp-vm" do
     Facter.fact(:kernel).stubs(:value).returns("HP-UX")
     Facter.fact(:virtual).stubs(:value).returns("hpvm")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on S390" do
     Facter.fact(:architecture).stubs(:value).returns("s390x")
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("zlinux")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on parallels" do
     Facter.fact(:kernel).stubs(:value).returns("Darwin")
     Facter.fact(:virtual).stubs(:value).returns("parallels")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be false on vmware_server" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("vmware_server")
-    Facter.fact(:is_virtual).value.should == "false"
+    Facter.fact(:is_virtual).value.should == false
   end
 
   it "should be false on openvz host nodes" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("openvzhn")
-    Facter.fact(:is_virtual).value.should == "false"
+    Facter.fact(:is_virtual).value.should == false
   end
 
   it "should be false on vserver host nodes" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("vserver_host")
-    Facter.fact(:is_virtual).value.should == "false"
+    Facter.fact(:is_virtual).value.should == false
   end
 
   it "should be true when running on hyperv" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("hyperv")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on rhev" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("rhev")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running on ovirt" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("ovirt")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   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"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running in LXC" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("lxc")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
   end
 
   it "should be true when running in docker" do
     Facter.fact(:kernel).stubs(:value).returns("Linux")
     Facter.fact(:virtual).stubs(:value).returns("docker")
-    Facter.fact(:is_virtual).value.should == "true"
+    Facter.fact(:is_virtual).value.should == true
+  end
+
+  it "should be true when running in bochs" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.fact(:virtual).stubs(:value).returns("bochs")
+    Facter.fact(:is_virtual).value.should == true
   end
 end