facter 2.0.1.rc1-x86-mingw32

data/spec/unit/util/processor_spec.rb

@@ -0,0 +1,92 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/processor'
+require 'facter_spec/cpuinfo'
+
+describe Facter::Util::Processor do
+  describe "on linux" do
+    include FacterSpec::Cpuinfo
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("Linux")
+      File.stubs(:exists?).with("/proc/cpuinfo").returns(true)
+    end
+
+    describe "with architecture amd64" do
+      before :each do
+        Facter.fact(:architecture).stubs(:value).returns("amd64")
+      end
+
+      it "should get the processor description from the amd64solo fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64solo"))
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64dual fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64dual"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64tri fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64tri"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+        Facter::Util::Processor.enum_cpuinfo[2].should == "Intel(R) Core(TM)2 Duo CPU     P8700  @ 2.53GHz"
+      end
+
+      it "should get the processor descriptions from the amd64quad fixture" do
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(cpuinfo_fixture_readlines("amd64quad"))
+
+        Facter::Util::Processor.enum_cpuinfo[0].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[1].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[2].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+        Facter::Util::Processor.enum_cpuinfo[3].should == "Quad-Core AMD Opteron(tm) Processor 2374 HE"
+      end
+    end
+
+    describe "with architecture x86" do
+      before :each do
+        Facter.fact(:architecture).stubs(:value).returns("x86")
+        File.stubs(:readlines).with("/proc/cpuinfo").returns(my_fixture_read("x86-pentium2").lines)
+      end
+
+      subject { Facter::Util::Processor.enum_cpuinfo }
+
+      it "should have the correct processor titles" do
+        subject[0].should == "Pentium II (Deschutes)"
+        subject[1].should == "Pentium II (Deschutes)"
+      end
+    end
+  end
+
+  describe "on Solaris" do
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("SunOS")
+    end
+
+    it "should get the processor description on Solaris (x86)" do
+      Facter.fact(:architecture).stubs(:value).returns("i86pc")
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-i86pc"))
+
+      Facter::Util::Processor.enum_kstat[0].should == "Intel(r) Core(tm) i5 CPU       M 450  @ 2.40GHz"
+    end
+
+    it "should get the processor description on Solaris (SPARC64)" do
+      Facter.fact(:architecture).stubs(:value).returns("sun4u")
+      Facter::Core::Execution.stubs(:exec).with("/usr/bin/kstat cpu_info").returns(my_fixture_read("solaris-sun4u"))
+
+      Facter::Util::Processor.enum_kstat[0].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[1].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[2].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[3].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[4].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[5].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[6].should == "SPARC64-VII"
+      Facter::Util::Processor.enum_kstat[7].should == "SPARC64-VII"
+    end
+  end
+end

data/spec/unit/util/registry_spec.rb

@@ -0,0 +1,76 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'facter/operatingsystem'
+require 'facter/util/registry'
+
+describe Facter::Util::Registry do
+  describe "hklm_read", :if => Facter::Util::Config.is_windows? do
+    before(:all) do
+      require 'win32/registry'
+    end
+    describe "valid params" do
+      [ {:key => "valid_key", :value => "valid_value",  :expected => "valid"},
+        {:key => "valid_key", :value => "",             :expected => "valid"},
+        {:key => "valid_key", :value => nil,            :expected => "invalid"},
+        {:key => "",          :value => "valid_value",  :expected => "valid"},
+        {:key => "",          :value => "",             :expected => "valid"},
+        {:key => "",          :value => nil,            :expected => "invalid"},
+        {:key => nil,         :value => "valid_value",  :expected => "invalid"},
+        {:key => nil,         :value => "",             :expected => "invalid"},
+        {:key => nil,         :value => nil,            :expected => "invalid"}
+      ].each do |scenario|
+        describe "with key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
+          let :fake_registry_key do
+            fake = {}
+            fake[scenario[:value]] = scenario[:expected]
+            fake
+          end
+          it "should return #{scenario[:expected]} value" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
+            fake_registry_key.stubs(:close)
+
+            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should == scenario[:expected]
+          end
+        end
+      end
+    end
+
+    describe "invalid params" do
+      [ {:key => "valid_key",   :value => "invalid_value"},
+        {:key => "valid_key",   :value => ""},
+        {:key => "valid_key",   :value => nil},
+      ].each do |scenario|
+        describe "with valid key and value #{scenario[:value] || "nil"}" do
+          let :fake_registry_key do
+            {}
+          end
+          it "should raise an error" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).returns(fake_registry_key)
+            fake_registry_key.stubs(:close)
+
+            Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value]).should raise_error
+          end
+        end
+      end
+      [ {:key => "invalid_key", :value => "valid_value"},
+        {:key => "invalid_key", :value => ""},
+        {:key => "invalid_key", :value => nil},
+        {:key => "",            :value => "valid_value"},
+        {:key => "",            :value => ""},
+        {:key => "",            :value => nil},
+        {:key => nil,           :value => "valid_value"},
+        {:key => nil,           :value => ""},
+        {:key => nil,           :value => nil}
+      ].each do |scenario|
+        describe "with invalid key #{scenario[:key] || "nil"} and value #{scenario[:value] || "nil"}" do
+          it "should raise an error" do
+            Win32::Registry::HKEY_LOCAL_MACHINE.stubs(:open).with(scenario[:key]).raises(Win32::Registry::Error, 2)
+            expect do
+              Facter::Util::Registry.hklm_read(scenario[:key], scenario[:value])
+            end.to raise_error Win32::Registry::Error
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/resolution_spec.rb

@@ -0,0 +1,129 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/resolution'
+
+describe Facter::Util::Resolution do
+  include FacterSpec::ConfigHelper
+
+  subject(:resolution) { described_class.new(:foo, stub_fact) }
+
+  let(:stub_fact) { stub('fact', :name => :stubfact) }
+
+  it "requires a name" do
+    expect { Facter::Util::Resolution.new }.to raise_error(ArgumentError)
+  end
+
+  it "requires a fact" do
+    expect { Facter::Util::Resolution.new('yay') }.to raise_error(ArgumentError)
+  end
+
+  it "can return its name" do
+    expect(resolution.name).to eq :foo
+  end
+
+  it "can explicitly set a value" do
+    resolution.value = "foo"
+    expect(resolution.value).to eq "foo"
+  end
+
+  it "defaults to nil for code" do
+    expect(resolution.code).to be_nil
+  end
+
+  describe "when setting the code" do
+    before do
+      Facter.stubs(:warnonce)
+    end
+
+    it "creates a block when given a command" do
+      resolution.setcode "foo"
+      expect(resolution.code).to be_a_kind_of Proc
+    end
+
+    it "stores the provided block when given a block" do
+      block = lambda { }
+      resolution.setcode(&block)
+      resolution.code.should equal(block)
+    end
+
+
+    it "prefers a command over a block" do
+      block = lambda { }
+      resolution.setcode("foo", &block)
+      expect(resolution.code).to_not eq block
+    end
+
+    it "fails if neither a string nor block has been provided" do
+      expect { resolution.setcode }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "when returning the value" do
+    it "returns any value that has been provided" do
+      resolution.value = "foo"
+      expect(resolution.value).to eq "foo"
+    end
+
+    describe "and setcode has not been called" do
+      it "returns nil" do
+        expect(resolution.value).to be_nil
+      end
+    end
+
+    describe "and the code is a string" do
+      it "returns the result of executing the code" do
+        resolution.setcode "/bin/foo"
+        Facter::Core::Execution.expects(:exec).once.with("/bin/foo").returns "yup"
+
+        expect(resolution.value).to eq "yup"
+      end
+    end
+
+    describe "and the code is a block" do
+      it "returns the value returned by the block" do
+        resolution.setcode { "yayness" }
+        expect(resolution.value).to eq "yayness"
+      end
+    end
+  end
+
+  describe "setting options" do
+    it "can set the value" do
+      resolution.set_options(:value => 'something')
+      expect(resolution.value).to eq 'something'
+    end
+
+    it "can set the timeout" do
+      resolution.set_options(:timeout => 314)
+      expect(resolution.limit).to eq 314
+    end
+
+    it "can set the weight" do
+      resolution.set_options(:weight => 27)
+      expect(resolution.weight).to eq 27
+    end
+
+    it "fails on unhandled options" do
+      expect do
+        resolution.set_options(:foo => 'bar')
+      end.to raise_error(ArgumentError, /Invalid resolution options.*foo/)
+    end
+  end
+
+  describe "evaluating" do
+    it "evaluates the block in the context of the given resolution" do
+      subject.expects(:has_weight).with(5)
+      subject.evaluate { has_weight(5) }
+    end
+
+    it "raises a warning if the resolution is evaluated twice" do
+      Facter.expects(:warn).with do |msg|
+        expect(msg).to match /Already evaluated foo at.*reevaluating anyways/
+      end
+
+      subject.evaluate { }
+      subject.evaluate { }
+    end
+  end
+end

data/spec/unit/util/solaris_zones_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'facter/util/solaris_zones'
+
+describe Facter::Util::SolarisZones do
+  let :zone_list do
+    zone_list = <<-EOF
+0:global:running:/::native:shared
+-:local:configured:/::native:shared
+-:zoneA:stopped:/::native:shared
+    EOF
+  end
+
+  let :zone_list2 do
+    zone_list = <<-EOF
+0:global:running:/::native:shared
+-:local:configured:/::native:shared
+-:zoneB:stopped:/::native:shared
+-:zoneC:stopped:/::native:shared
+    EOF
+  end
+
+  subject do
+    described_class.new(:zoneadm_output => zone_list)
+  end
+
+  describe '.add_facts' do
+    before :each do
+      zones = described_class.new(:zoneadm_output => zone_list)
+      zones.send(:parse!)
+      zones.stubs(:refresh)
+      described_class.stubs(:new).returns(zones)
+    end
+
+    it 'defines the zones fact' do
+      described_class.add_facts
+      Facter.fact(:zones).value.should == 3
+    end
+
+    it 'defines a fact for each attribute of a zone' do
+      described_class.add_facts
+      [:id, :name, :status, :path, :uuid, :brand, :iptype].each do |attr|
+        Facter.fact("zone_local_#{attr}".intern).
+          should be_a_kind_of Facter::Util::Fact
+      end
+    end
+  end
+
+  describe '#refresh' do
+    it 'executes the zoneadm_cmd' do
+      Facter::Core::Execution.expects(:exec).with(subject.zoneadm_cmd).returns(zone_list)
+      subject.refresh
+    end
+  end
+
+  describe 'multiple facts sharing a single model' do
+    context 'when zones is resolved for the first time' do
+      it 'counts the number of zones' do
+        given_initial_zone_facts
+        Facter.fact(:zones).value.should == 3
+      end
+      it 'defines facts for zoneA' do
+        given_initial_zone_facts
+        Facter.fact(:zone_zoneA_id).value.should == '-'
+      end
+      it 'does not define facts for zoneB' do
+        given_initial_zone_facts
+        Facter.fact(:zone_zoneB_id).should be_nil
+      end
+      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
+        given_initial_zone_facts # <= single read happens here
+
+        Facter::Core::Execution.expects(:exec).never
+        Facter.fact(:zone_zoneA_id).value
+        Facter.fact(:zone_local_id).value
+      end
+    end
+    context 'when all facts have been flushed after zones was resolved once' do
+      it 'updates the number of zones' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zones).value.should == 4
+      end
+      it 'stops resolving a value for a zone that no longer exists' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zone_zoneA_id).value.should be_nil
+        Facter.fact(:zone_zoneA_status).value.should be_nil
+        Facter.fact(:zone_zoneA_path).value.should be_nil
+      end
+      it 'defines facts for new zones' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter.fact(:zone_zoneB_id).should be_nil
+        Facter.fact(:zones).value
+        Facter.fact(:zone_zoneB_id).value.should be_a_kind_of String
+      end
+      it 'uses a single read of the system information for all of the dynamically generated zone facts' do
+        given_initial_zone_facts
+        when_facts_have_been_resolved_then_flushed
+
+        Facter::Core::Execution.expects(:exec).once.returns(zone_list2)
+        Facter.fact(:zones).value
+        Facter.fact(:zone_zoneA_id).value
+        Facter.fact(:zone_local_id).value
+      end
+
+    end
+  end
+
+  def given_initial_zone_facts
+    Facter::Core::Execution.stubs(:exec).
+      with(subject.zoneadm_cmd).
+      returns(zone_list)
+    described_class.add_facts
+  end
+
+  def when_facts_have_been_resolved_then_flushed
+    Facter.fact(:zones).value
+    Facter.fact(:zone_zoneA_id).value
+    Facter.fact(:zone_local_id).value
+    Facter::Core::Execution.stubs(:exec).returns(zone_list2)
+    Facter.flush
+  end
+end

data/spec/unit/util/uptime_spec.rb

@@ -0,0 +1,126 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/uptime'
+
+describe Facter::Util::Uptime do
+
+  describe ".get_uptime_seconds_unix", :unless => Facter::Util::Config.is_windows? do
+    describe "when /proc/uptime is available" do
+      before do
+        uptime_file = my_fixture("ubuntu_proc_uptime")
+        Facter::Util::Uptime.stubs(:uptime_file).returns("\"#{uptime_file}\"")
+      end
+
+      it "should return the uptime in seconds as an integer" do
+        Facter::Util::Uptime.get_uptime_seconds_unix.should == 5097686
+      end
+
+    end
+
+    describe "when /proc/uptime is not available" do
+      before :each do
+        @nonexistent_file = '/non/existent/file'
+        File.exists?(@nonexistent_file).should == false
+        Facter::Util::Uptime.stubs(:uptime_file).returns(@nonexistent_file)
+      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}\"")
+        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}\"")
+        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
+
+      describe "nor is 'sysctl kern.boottime'" do
+        before :each do
+          Facter::Util::Uptime.stubs(:uptime_proc_uptime).returns(false)
+          Facter::Util::Uptime.stubs(:uptime_sysctl).returns(false)
+          Facter.fact(:kernel).stubs(:value).returns('SunOS')
+        end
+
+        describe "should use 'uptime' command" do
+          # Note about uptime variations.
+          # Solaris (I have examined 5.6, 5.7, 5.8, 5.9, 5.10 & 5.11) and HP-UX (11.00, 11.11, 11.23, 11.31) have time
+          #   right justified at at 8 characters, and two spaces before 'up'.
+          # Solaris differs from all other Unices (and Linux) in that the plural/singular case of minutes/hours/days are
+          #   written min(s)/hr(s)/day(s) instead of min/mins/hr/hrs etc., e.g. 1 min(s), 2 min(s) as opposed to
+          #   1 min, 2 mins, etc.
+          # AIX (4.3.3, 5.2, 5.3, 6.1) differs from other SysV Unices in that times are padded with a leading 0 in the
+          #   hour column where necessary, and have AM/PM in uppercase, and there are three spaces before 'up'.
+          # Tru64 (4.0, 5.1) differs from other SysV Unices in that times are in 24 hour format, and there are no
+          #   leading spaces.
+          # Linux (RHEL, uptime version 2.0.7) differs from the SysV Unices in that only minutes before the first hour
+          #   are written as 1 min, 2 min, 3 min etc. and after that full hours are rendered 1:00 or 21:00.  Time of
+          #   day was written 5:37pm and right-justified at 8 characters, with 2 spaces before 'up'.  A figure in
+          #   whole days was written as 3 days, 0 min.
+          # By version 2.0.17 the time of day was rewritten in 24hr time with seconds, right-justified at 9 characters.
+          # By version 3.2.7 one of the spaces before 'up' had been removed.
+          test_cases = [
+            ['  4:42pm  up 1 min(s),  0 users,  load average: 0.95, 0.25, 0.09',                                         1*60],
+            ['13:16  up 58 mins,  2 users,  load average: 0.00, 0.02, 0.05',                                            58*60],
+            ['13:18  up 1 hr,  1 user,  load average: 0.58, 0.23, 0.14',                                      1*60*60        ],
+            [' 10:14pm  up 3 hr(s),  0 users,  load average: 0.00, 0.00, 0.00',                               3*60*60        ],
+            ['14:18  up 2 hrs,  0 users,  load average: 0.33, 0.27, 0.29',                                    2*60*60        ],
+            ['  9:01pm  up  1:47,  0 users,  load average: 0.00, 0.00, 0.00',                                 1*60*60 + 47*60],
+            ['13:19  up  1:01,  1 user,  load average: 0.10, 0.26, 0.21',                                     1*60*60 +  1*60],
+            ['10:49  up 22:31,  0 users,  load average: 0.26, 0.34, 0.27',                                   22*60*60 + 31*60],
+            ['12:18  up 1 day,  0 users,  load average: 0.74, 0.20, 0.10',                      1*24*60*60                   ],
+            ['  2:48pm  up 1 day(s),  0 users,  load average: 0.21, 0.20, 0.17',                1*24*60*60                   ],
+            ['12:18  up 2 days,  0 users,  load average: 0.50, 0.27, 0.16',                     2*24*60*60                   ],
+            ['  1:56pm  up 25 day(s),  2 users,  load average: 0.59, 0.56, 0.50',              25*24*60*60                   ],
+            ['  1:29pm  up 485 days,  0 users,  load average: 0.00, 0.01, 0.01',              485*24*60*60                   ],
+            [' 18:11:24  up 69 days, 0 min,  0 users,  load average: 0.00, 0.00, 0.00',        69*24*60*60                   ],
+            ['12:19  up 1 day, 1 min,  0 users,  load average: 0.07, 0.16, 0.13',               1*24*60*60            +  1*60],
+            ['  3:23pm  up 25 day(s), 27 min(s),  2 users,  load average: 0.49, 0.45, 0.46',   25*24*60*60            + 27*60],
+            ['  02:42PM   up 1 day, 39 mins,  0 users,  load average: 1.49, 1.74, 1.80',        1*24*60*60            + 39*60],
+            [' 18:13:13  up 245 days, 44 min,  1 user,  load average: 0.00, 0.00, 0.00',      245*24*60*60            + 44*60],
+            ['  6:09pm  up 350 days, 2 min,  1 user,  load average: 0.02, 0.03, 0.00',        350*24*60*60            +  2*60],
+            ['  1:07pm  up 174 day(s), 16 hr(s),  0 users,  load average: 0.05, 0.04, 0.03',  174*24*60*60 + 16*60*60        ],
+            ['  02:34PM   up 621 days, 18 hrs,  0 users,  load average: 2.67, 2.52, 2.56',    621*24*60*60 + 18*60*60        ],
+            ['  3:30am  up 108 days, 1 hr,  31 users,  load average: 0.39, 0.40, 0.41',       108*24*60*60 +  1*60*60        ],
+            ['13:18  up 1 day, 1 hr,  0 users,  load average: 0.78, 0.33, 0.18',                1*24*60*60 +  1*60*60        ],
+            ['14:18  up 1 day, 2 hrs,  0 users,  load average: 1.17, 0.48, 0.41',               1*24*60*60 +  2*60*60        ],
+            ['15:56  up 152 days, 17 hrs,  0 users,  load average: 0.01, 0.06, 0.07',         152*24*60*60 + 17*60*60        ],
+            ['  5:37pm  up 25 days, 21:00,  0 users,  load average: 0.01, 0.02, 0.00',         25*24*60*60 + 21*60*60        ],
+            ['  8:59pm  up 94 day(s),  3:17,  46 users,  load average: 0.66, 0.67, 0.70',      94*24*60*60 +  3*60*60 + 17*60],
+            ['  3:01pm  up 4496 day(s), 21:19,  32 users,  load average: 0.61, 0.62, 0.62',  4496*24*60*60 + 21*60*60 + 19*60],
+            ['  02:42PM   up 41 days,   2:38,  0 users,  load average: 0.38, 0.70, 0.55',      41*24*60*60 +  2*60*60 + 38*60],
+            [' 18:13:29  up 25 days, 21:36,  0 users,  load average: 0.00, 0.00, 0.00',        25*24*60*60 + 21*60*60 + 36*60],
+            [' 13:36:05 up 118 days,  1:15,  1 user,  load average: 0.00, 0.00, 0.00',        118*24*60*60 +  1*60*60 + 15*60]
+          ]
+
+          test_cases.each do |uptime, expected|
+            it "should return #{expected} for #{uptime}" do
+              Facter::Core::Execution.stubs(:exec).with('uptime 2>/dev/null').returns(uptime)
+              Facter.fact(:uptime_seconds).value.should == expected
+            end
+          end
+
+          describe "nor is 'uptime' command" do
+            before :each do
+              Facter::Util::Uptime.stubs(:uptime_executable_cmd).returns("cat \"#{@nonexistent_file}\"")
+            end
+
+            it "should return nil" do
+              Facter::Util::Uptime.get_uptime_seconds_unix.should == nil
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe ".get_uptime_seconds_win", :if => Facter::Util::Config.is_windows? do
+    it "should return a postive value" do
+      Facter::Util::Uptime.get_uptime_seconds_win.should > 0
+    end
+  end
+end