facter 1.6.2 → 1.6.3

data/spec/unit/id_spec.rb

@@ -4,25 +4,25 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "id fact" do
 
-    kernel = [ 'Linux', 'Darwin', 'windows', 'FreeBSD', 'OpenBSD', 'NetBSD', 'AIX', 'HP-UX' ]
+  kernel = [ 'Linux', 'Darwin', 'windows', 'FreeBSD', 'OpenBSD', 'NetBSD', 'AIX', 'HP-UX' ]
 
-    kernel.each do |k|
-        describe "with kernel reported as #{k}" do
-            it "should return the current user" do
-                Facter.fact(:kernel).stubs(:value).returns(k)
-                Facter::Util::Config.stubs(:is_windows?).returns(k == 'windows')
-                Facter::Util::Resolution.expects(:exec).once.with('whoami').returns 'bar'
+  kernel.each do |k|
+    describe "with kernel reported as #{k}" do
+      it "should return the current user" do
+        Facter.fact(:kernel).stubs(:value).returns(k)
+        Facter::Util::Config.stubs(:is_windows?).returns(k == 'windows')
+        Facter::Util::Resolution.expects(:exec).once.with('whoami').returns 'bar'
 
-                Facter.fact(:id).value.should == 'bar'
-            end
-        end
+        Facter.fact(:id).value.should == 'bar'
+      end
     end
+  end
 
-    it "should return the current user on Solaris" do
-       Facter::Util::Config.stubs(:is_windows?).returns(false)
-       Facter::Util::Resolution.stubs(:exec).with('uname -s').returns('SunOS')
-       Facter::Util::Resolution.expects(:exec).once.with('/usr/xpg4/bin/id -un').returns 'bar'
+  it "should return the current user on Solaris" do
+     Facter::Util::Config.stubs(:is_windows?).returns(false)
+     Facter::Util::Resolution.stubs(:exec).with('uname -s').returns('SunOS')
+     Facter::Util::Resolution.expects(:exec).once.with('/usr/xpg4/bin/id -un').returns 'bar'
 
-       Facter.fact(:id).value.should == 'bar'
-    end
+     Facter.fact(:id).value.should == 'bar'
+  end
 end

data/spec/unit/interfaces_spec.rb

@@ -6,13 +6,13 @@ require 'facter'
 require 'facter/util/ip'
 
 describe "Per Interface IP facts" do
-    it "should replace the ':' in an interface list with '_'" do
-        # So we look supported
-        Facter.fact(:kernel).stubs(:value).returns("SunOS")
+  it "should replace the ':' in an interface list with '_'" do
+    # So we look supported
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
 
-        Facter::Util::IP.stubs(:get_interfaces).returns %w{eth0:1 eth1:2}
-        Facter.fact(:interfaces).value.should == %{eth0_1,eth1_2}
-    end
+    Facter::Util::IP.stubs(:get_interfaces).returns %w{eth0:1 eth1:2}
+    Facter.fact(:interfaces).value.should == %{eth0_1,eth1_2}
+  end
 
   it "should replace non-alphanumerics in an interface list with '_'" do
     Facter.fact(:kernel).stubs(:value).returns("windows")

data/spec/unit/memory_spec.rb

@@ -5,146 +5,146 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require 'facter'
 
 describe "Memory facts" do
-    before do
-        # We need these facts loaded, but they belong to a file with a
-        # different name, so load the file explicitly.
-        Facter.collection.loader.load(:memory)
-    end
+  before do
+    # We need these facts loaded, but they belong to a file with a
+    # different name, so load the file explicitly.
+    Facter.collection.loader.load(:memory)
+  end
 
-    after do
-        Facter.clear
-    end
+  after do
+    Facter.clear
+  end
 
-    it "should return the current swap size" do
+  it "should return the current swap size" do
 
-        Facter.fact(:kernel).stubs(:value).returns("Darwin")
-        Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
-        swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
+    swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
 
-        if swapusage =~ /total = (\S+).*/
-            Facter.fact(:swapfree).value.should == $1
-        end
+    if swapusage =~ /total = (\S+).*/
+      Facter.fact(:swapfree).value.should == $1
     end
+  end
 
-    it "should return the current swap free" do
-        Facter.fact(:kernel).stubs(:value).returns("Darwin")
-        Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
-        swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
+  it "should return the current swap free" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
+    swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
 
-        if swapusage =~ /free = (\S+).*/
-            Facter.fact(:swapfree).value.should == $1
-        end
+    if swapusage =~ /free = (\S+).*/
+      Facter.fact(:swapfree).value.should == $1
     end
+  end
 
-    it "should return whether swap is encrypted" do
-        Facter.fact(:kernel).stubs(:value).returns("Darwin")
-        Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
-        swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
+  it "should return whether swap is encrypted" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Util::Resolution.stubs(:exec).with('sysctl vm.swapusage').returns("vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)")
+    swapusage = "vm.swapusage: total = 64.00M  used = 0.00M  free = 64.00M  (encrypted)"
 
-        swapusage =~ /\(encrypted\)/
-        Facter.fact(:swapencrypted).value.should == true
-    end
+    swapusage =~ /\(encrypted\)/
+    Facter.fact(:swapencrypted).value.should == true
+  end
 
-    describe "on OpenBSD" do
-        before :each do
-            Facter.clear
-            Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
+  describe "on OpenBSD" do
+    before :each do
+      Facter.clear
+      Facter.fact(:kernel).stubs(:value).returns("OpenBSD")
 
-            swapusage = "total: 148342k bytes allocated = 0k used, 148342k available"
-            Facter::Util::Resolution.stubs(:exec).with('swapctl -s').returns(swapusage)
+      swapusage = "total: 148342k bytes allocated = 0k used, 148342k available"
+      Facter::Util::Resolution.stubs(:exec).with('swapctl -s').returns(swapusage)
 
-            vmstat = <<EOS
- procs    memory       page                    disks    traps          cpu
- r b w    avm     fre  flt  re  pi  po  fr  sr cd0 sd0  int   sys   cs us sy id
- 0 0 0  11048  181028   39   0   0   0   0   0   0   1    3    90   17  0  0 100
+      vmstat = <<EOS
+ procs  memory     page          disks  traps      cpu
+ r b w  avm   fre  flt  re  pi  po  fr  sr cd0 sd0  int   sys   cs us sy id
+ 0 0 0  11048  181028   39   0   0   0   0   0   0   1  3  90   17  0  0 100
 EOS
-            Facter::Util::Resolution.stubs(:exec).with('vmstat').returns(vmstat)
-
-            Facter::Util::Resolution.stubs(:exec).with("sysctl hw.physmem | cut -d'=' -f2").returns('267321344')
+      Facter::Util::Resolution.stubs(:exec).with('vmstat').returns(vmstat)
 
-            Facter.collection.loader.load(:memory)
-        end
+      Facter::Util::Resolution.stubs(:exec).with("sysctl hw.physmem | cut -d'=' -f2").returns('267321344')
 
-        after :each do
-            Facter.clear
-        end
-
-        it "should return the current swap free" do
-            Facter.fact(:swapfree).value.should == "144.87 MB"
-        end
-
-        it "should return the current swap size" do
-            Facter.fact(:swapsize).value.should == "144.87 MB"
-        end
+      Facter.collection.loader.load(:memory)
+    end
 
-        it "should return the current memorysize" do
-            Facter.fact(:memorytotal).value.should == "254.94 MB"
-        end
+    after :each do
+      Facter.clear
     end
 
-    describe "on DragonFly BSD" do
-        before :each do
-            Facter.clear
-            Facter.fact(:kernel).stubs(:value).returns("dragonfly")
+    it "should return the current swap free" do
+      Facter.fact(:swapfree).value.should == "144.87 MB"
+    end
 
-            swapusage = "total: 148342k bytes allocated = 0k used, 148342k available"
-            Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n hw.pagesize').returns("4096")
-            Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_size').returns("128461")
-            Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_anon_use').returns("2635")
-            Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_cache_use').returns("0")
+    it "should return the current swap size" do
+      Facter.fact(:swapsize).value.should == "144.87 MB"
+    end
 
-            vmstat = <<EOS
- procs      memory      page                    disks     faults      cpu
- r b w     avm    fre  flt  re  pi  po  fr  sr da0 sg1   in   sy  cs us sy id
+    it "should return the current memorysize" do
+      Facter.fact(:memorytotal).value.should == "254.94 MB"
+    end
+  end
+
+  describe "on DragonFly BSD" do
+    before :each do
+      Facter.clear
+      Facter.fact(:kernel).stubs(:value).returns("dragonfly")
+
+      swapusage = "total: 148342k bytes allocated = 0k used, 148342k available"
+      Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n hw.pagesize').returns("4096")
+      Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_size').returns("128461")
+      Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_anon_use').returns("2635")
+      Facter::Util::Resolution.stubs(:exec).with('/sbin/sysctl -n vm.swap_cache_use').returns("0")
+
+      vmstat = <<EOS
+ procs    memory    page          disks   faults    cpu
+ r b w   avm  fre  flt  re  pi  po  fr  sr da0 sg1   in   sy  cs us sy id
  0 0 0   33152  13940 1902120 2198 53119 11642 6544597 5460994   0   0 6148243 7087927 3484264  0  1 9
 EOS
-            Facter::Util::Resolution.stubs(:exec).with('vmstat').returns(vmstat)
+      Facter::Util::Resolution.stubs(:exec).with('vmstat').returns(vmstat)
 
-            Facter::Util::Resolution.stubs(:exec).with("sysctl -n hw.physmem").returns('248512512')
+      Facter::Util::Resolution.stubs(:exec).with("sysctl -n hw.physmem").returns('248512512')
 
-            Facter.collection.loader.load(:memory)
-        end
+      Facter.collection.loader.load(:memory)
+    end
 
-        after :each do
-            Facter.clear
-        end
+    after :each do
+      Facter.clear
+    end
 
-        it "should return the current swap free" do
-            Facter.fact(:swapfree).value.should == "491.51 MB"
-        end
+    it "should return the current swap free" do
+      Facter.fact(:swapfree).value.should == "491.51 MB"
+    end
 
-        it "should return the current swap size" do
-            Facter.fact(:swapsize).value.should == "501.80 MB"
-        end
+    it "should return the current swap size" do
+      Facter.fact(:swapsize).value.should == "501.80 MB"
+    end
 
-        it "should return the current memorysize" do
-            Facter.fact(:memorytotal).value.should == "237.00 MB"
-        end
+    it "should return the current memorysize" do
+      Facter.fact(:memorytotal).value.should == "237.00 MB"
     end
+  end
 
-    describe "on Windows" do
-        before :each do
-             Facter.clear
-             Facter.fact(:kernel).stubs(:value).returns("windows")
-             Facter.collection.loader.load(:memory)
+  describe "on Windows" do
+    before :each do
+      Facter.clear
+      Facter.fact(:kernel).stubs(:value).returns("windows")
+      Facter.collection.loader.load(:memory)
 
-             require 'facter/util/wmi'
-        end
+      require 'facter/util/wmi'
+    end
 
-        it "should return free memory" do
-             os = stubs 'os'
-             os.stubs(:FreePhysicalMemory).returns("3415624")
-             Facter::Util::WMI.stubs(:execquery).returns([os])
+    it "should return free memory" do
+      os = stubs 'os'
+      os.stubs(:FreePhysicalMemory).returns("3415624")
+      Facter::Util::WMI.stubs(:execquery).returns([os])
 
-             Facter.fact(:MemoryFree).value.should == '3.26 GB'
-        end
+      Facter.fact(:MemoryFree).value.should == '3.26 GB'
+    end
 
-        it "should return total memory" do
-             computer = stubs 'computer'
-             computer.stubs(:TotalPhysicalMemory).returns("4193837056")
-             Facter::Util::WMI.stubs(:execquery).returns([computer])
+    it "should return total memory" do
+      computer = stubs 'computer'
+      computer.stubs(:TotalPhysicalMemory).returns("4193837056")
+      Facter::Util::WMI.stubs(:execquery).returns([computer])
 
-             Facter.fact(:MemoryTotal).value.should == '3.91 GB'
-        end
+      Facter.fact(:MemoryTotal).value.should == '3.91 GB'
     end
+  end
 end

data/spec/unit/operatingsystem_spec.rb

@@ -6,78 +6,87 @@ require 'facter'
 
 describe "Operating System fact" do
 
-    before do
-        Facter.clear
-    end
+  before do
+    Facter.clear
+  end
 
-    after do
-        Facter.clear
-    end
+  after do
+    Facter.clear
+  end
 
-    it "should default to the kernel name" do
-        Facter.fact(:kernel).stubs(:value).returns("Nutmeg")
+  it "should default to the kernel name" do
+    Facter.fact(:kernel).stubs(:value).returns("Nutmeg")
 
-        Facter.fact(:operatingsystem).value.should == "Nutmeg"
-    end
+    Facter.fact(:operatingsystem).value.should == "Nutmeg"
+  end
 
-    it "should be Solaris for SunOS" do
-         Facter.fact(:kernel).stubs(:value).returns("SunOS")
+  it "should be Solaris for SunOS" do
+     Facter.fact(:kernel).stubs(:value).returns("SunOS")
 
-         Facter.fact(:operatingsystem).value.should == "Solaris"
-    end
+     Facter.fact(:operatingsystem).value.should == "Solaris"
+  end
 
-    it "should be ESXi for VMkernel" do
-         Facter.fact(:kernel).stubs(:value).returns("VMkernel")
+  it "should be ESXi for VMkernel" do
+     Facter.fact(:kernel).stubs(:value).returns("VMkernel")
 
-         Facter.fact(:operatingsystem).value.should == "ESXi"
-    end
+     Facter.fact(:operatingsystem).value.should == "ESXi"
+  end
 
-    it "should identify Oracle VM as OVS" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        Facter.stubs(:value).with(:lsbdistid).returns(nil)
-        FileTest.stubs(:exists?).returns false
+  it "should identify Oracle VM as OVS" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.stubs(:value).with(:lsbdistid).returns(nil)
+    FileTest.stubs(:exists?).returns false
 
-        FileTest.expects(:exists?).with("/etc/ovs-release").returns true
-        FileTest.expects(:exists?).with("/etc/enterprise-release").returns true
+    FileTest.expects(:exists?).with("/etc/ovs-release").returns true
+    FileTest.expects(:exists?).with("/etc/enterprise-release").returns true
 
-        Facter.fact(:operatingsystem).value.should == "OVS"
-    end
+    Facter.fact(:operatingsystem).value.should == "OVS"
+  end
    
-    it "should identify VMWare ESX" do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        Facter.stubs(:value).with(:lsbdistid).returns(nil)
-        FileTest.stubs(:exists?).returns false
-
-        FileTest.expects(:exists?).with("/etc/vmware-release").returns true
-
-        Facter.fact(:operatingsystem).value.should == "VMWareESX"
-    end
-
-    it "should identify Alpine Linux" do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      
-      FileTest.stubs(:exists?).returns false
-      
-      FileTest.expects(:exists?).with("/etc/alpine-release").returns true
-
-      Facter.fact(:operatingsystem).value.should == "Alpine"
-    end
-
-    it "should identify Scientific Linux" do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      FileTest.stubs(:exists?).returns false
-
-      FileTest.expects(:exists?).with("/etc/redhat-release").returns true
-      File.expects(:read).with("/etc/redhat-release").returns("Scientific Linux SLC 5.7 (Boron)")
-      Facter.fact(:operatingsystem).value.should == "Scientific"
-    end
-
-    it "should differentiate between Scientific Linux CERN and Scientific Linux" do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      FileTest.stubs(:exists?).returns false
-
-      FileTest.expects(:exists?).with("/etc/redhat-release").returns true
-      File.expects(:read).with("/etc/redhat-release").returns("Scientific Linux CERN SLC 5.7 (Boron)")
-      Facter.fact(:operatingsystem).value.should == "SLC"
-    end
+  it "should identify VMWare ESX" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    Facter.stubs(:value).with(:lsbdistid).returns(nil)
+    FileTest.stubs(:exists?).returns false
+
+    FileTest.expects(:exists?).with("/etc/vmware-release").returns true
+
+    Facter.fact(:operatingsystem).value.should == "VMWareESX"
+  end
+
+  it "should identify Alpine Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    
+    FileTest.stubs(:exists?).returns false
+    
+    FileTest.expects(:exists?).with("/etc/alpine-release").returns true
+
+    Facter.fact(:operatingsystem).value.should == "Alpine"
+  end
+
+  it "should identify Scientific Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    FileTest.stubs(:exists?).returns false
+
+    FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+    File.expects(:read).with("/etc/redhat-release").returns("Scientific Linux SLC 5.7 (Boron)")
+    Facter.fact(:operatingsystem).value.should == "Scientific"
+  end
+
+  it "should differentiate between Scientific Linux CERN and Scientific Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    FileTest.stubs(:exists?).returns false
+
+    FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+    File.expects(:read).with("/etc/redhat-release").returns("Scientific Linux CERN SLC 5.7 (Boron)")
+    Facter.fact(:operatingsystem).value.should == "SLC"
+  end
+
+  it "should identify Ascendos Linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    FileTest.stubs(:exists?).returns false
+
+    FileTest.expects(:exists?).with("/etc/redhat-release").returns true
+    File.expects(:read).with("/etc/redhat-release").returns("Ascendos release 6.0 (Nameless)")
+    Facter.fact(:operatingsystem).value.should == "Ascendos"
+  end
 end