facter 1.6.2 → 1.6.3

data/spec/unit/util/macosx_spec.rb

@@ -5,77 +5,77 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/macosx'
 
 describe Facter::Util::Macosx do
-    it "should be able to retrieve profiler data as xml for a given data field" do
-        Facter::Util::Resolution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
-        Facter::Util::Macosx.profiler_xml("foo").should == "yay"
-    end
-
-    it "should use PList to convert xml to data structures" do
-        Plist.expects(:parse_xml).with("foo").returns "bar"
+  it "should be able to retrieve profiler data as xml for a given data field" do
+    Facter::Util::Resolution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
+    Facter::Util::Macosx.profiler_xml("foo").should == "yay"
+  end
 
-        Facter::Util::Macosx.intern_xml("foo").should == "bar"
-    end
+  it "should use PList to convert xml to data structures" do
+    Plist.expects(:parse_xml).with("foo").returns "bar"
 
-    describe "when collecting profiler data" do
-        it "should return the first value in the '_items' hash in the first value of the results of the system_profiler data, with the '_name' field removed, if the profiler returns data" do
-            @result = [
-                '_items' => [
-                    {'_name' => "foo", "yay" => "bar"}
-                ]
-            ]
-            Facter::Util::Macosx.expects(:profiler_xml).with("foo").returns "eh"
-            Facter::Util::Macosx.expects(:intern_xml).with("eh").returns @result
-            Facter::Util::Macosx.profiler_data("foo").should == {"yay" => "bar"}
-        end
+    Facter::Util::Macosx.intern_xml("foo").should == "bar"
+  end
 
-        it "should return nil if an exception is thrown during parsing of xml" do
-            Facter::Util::Macosx.expects(:profiler_xml).with("foo").returns "eh"
-            Facter::Util::Macosx.expects(:intern_xml).with("eh").raises "boo!"
-            Facter::Util::Macosx.profiler_data("foo").should be_nil
-        end
+  describe "when collecting profiler data" do
+    it "should return the first value in the '_items' hash in the first value of the results of the system_profiler data, with the '_name' field removed, if the profiler returns data" do
+      @result = [
+        '_items' => [
+          {'_name' => "foo", "yay" => "bar"}
+        ]
+      ]
+      Facter::Util::Macosx.expects(:profiler_xml).with("foo").returns "eh"
+      Facter::Util::Macosx.expects(:intern_xml).with("eh").returns @result
+      Facter::Util::Macosx.profiler_data("foo").should == {"yay" => "bar"}
     end
 
-    it "should return the profiler data for 'SPHardwareDataType' as the hardware information" do
-        Facter::Util::Macosx.expects(:profiler_data).with("SPHardwareDataType").returns "eh"
-        Facter::Util::Macosx.hardware_overview.should == "eh"
+    it "should return nil if an exception is thrown during parsing of xml" do
+      Facter::Util::Macosx.expects(:profiler_xml).with("foo").returns "eh"
+      Facter::Util::Macosx.expects(:intern_xml).with("eh").raises "boo!"
+      Facter::Util::Macosx.profiler_data("foo").should be_nil
     end
+  end
 
-    it "should return the profiler data for 'SPSoftwareDataType' as the os information" do
-        Facter::Util::Macosx.expects(:profiler_data).with("SPSoftwareDataType").returns "eh"
-        Facter::Util::Macosx.os_overview.should == "eh"
-    end
-    
-    describe "when working out software version" do
-        
-        before do
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productName").returns "Mac OS X"
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -buildVersion").returns "9J62"
-        end
-        
-        it "should have called sw_vers three times when determining software version" do
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
-            Facter::Util::Macosx.sw_vers
-        end
-    
-        it "should return a hash with the correct keys when determining software version" do
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
-            Facter::Util::Macosx.sw_vers.keys.sort.should == ["macosx_productName",
-                                                              "macosx_buildVersion",
-                                                              "macosx_productversion_minor",
-                                                              "macosx_productversion_major",
-                                                              "macosx_productVersion"].sort
-        end
+  it "should return the profiler data for 'SPHardwareDataType' as the hardware information" do
+    Facter::Util::Macosx.expects(:profiler_data).with("SPHardwareDataType").returns "eh"
+    Facter::Util::Macosx.hardware_overview.should == "eh"
+  end
+
+  it "should return the profiler data for 'SPSoftwareDataType' as the os information" do
+    Facter::Util::Macosx.expects(:profiler_data).with("SPSoftwareDataType").returns "eh"
+    Facter::Util::Macosx.os_overview.should == "eh"
+  end
+  
+  describe "when working out software version" do
     
-        it "should split a product version of 'x.y.z' into separate hash entries correctly" do
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "1.2.3"
-            sw_vers = Facter::Util::Macosx.sw_vers
-            sw_vers["macosx_productversion_major"].should == "1.2"
-            sw_vers["macosx_productversion_minor"].should == "3"
-        end
+    before do
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productName").returns "Mac OS X"
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -buildVersion").returns "9J62"
+    end
     
-        it "should treat a product version of 'x.y' as 'x.y.0" do
-            Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "2.3"
-            Facter::Util::Macosx.sw_vers["macosx_productversion_minor"].should == "0"
-        end
+    it "should have called sw_vers three times when determining software version" do
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
+      Facter::Util::Macosx.sw_vers
+    end
+  
+    it "should return a hash with the correct keys when determining software version" do
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "10.5.7"
+      Facter::Util::Macosx.sw_vers.keys.sort.should == ["macosx_productName",
+                                                        "macosx_buildVersion",
+                                                        "macosx_productversion_minor",
+                                                        "macosx_productversion_major",
+                                                        "macosx_productVersion"].sort
+    end
+  
+    it "should split a product version of 'x.y.z' into separate hash entries correctly" do
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "1.2.3"
+      sw_vers = Facter::Util::Macosx.sw_vers
+      sw_vers["macosx_productversion_major"].should == "1.2"
+      sw_vers["macosx_productversion_minor"].should == "3"
+    end
+  
+    it "should treat a product version of 'x.y' as 'x.y.0" do
+      Facter::Util::Resolution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "2.3"
+      Facter::Util::Macosx.sw_vers["macosx_productversion_minor"].should == "0"
     end
+  end
 end

data/spec/unit/util/manufacturer_spec.rb

@@ -3,52 +3,69 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/manufacturer'
 
 describe Facter::Manufacturer do
-    before :each do
-        Facter.clear
-    end
-
-    it "should return the system DMI table" do
-        Facter::Manufacturer.should respond_to(:get_dmi_table)
-    end
-
-    it "should return nil on non-supported operating systems" do
-        Facter.stubs(:value).with(:kernel).returns("SomeThing")
-        Facter::Manufacturer.get_dmi_table().should be_nil
-    end
-
-    it "should parse prtdiag output" do
-        Facter::Util::Resolution.stubs(:exec).returns("System Configuration:  Sun Microsystems  sun4u Sun SPARC Enterprise M3000 Server")
-        Facter::Manufacturer.prtdiag_sparc_find_system_info()
-        Facter.value(:manufacturer).should == "Sun Microsystems"
-        Facter.value(:productname).should == "Sun SPARC Enterprise M3000 Server"
-    end
-
-    it "should strip white space on dmi output with spaces" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/linux_dmidecode_with_spaces"
-        dmidecode_output = File.new(sample_output_file).read()
-        Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-
-        query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => 'productname' } ] }
-
-        Facter::Manufacturer.dmi_find_system_info(query)
-        Facter.value(:productname).should == "MS-6754"
-    end
-
-    it "should handle output from smbios when run under sunos" do
-        sample_output_file = File.dirname(__FILE__) + "/../data/opensolaris_smbios"
-        smbios_output = File.new(sample_output_file).read()
-        Facter::Manufacturer.expects(:get_dmi_table).returns(smbios_output)
-        Facter.fact(:kernel).stubs(:value).returns("SunOS")
-
-        query = { 'BIOS information' => [ { 'Release Date:' => 'reldate' } ] }
-
-        Facter::Manufacturer.dmi_find_system_info(query)
-        Facter.value(:reldate).should == "12/01/2006"
-    end
-
-    it "should not split on dmi keys containing the string Handle" do
-        dmidecode_output = <<-eos
+  before :each do
+    Facter.clear
+  end
+
+  it "should return the system DMI table" do
+    Facter::Manufacturer.should respond_to(:get_dmi_table)
+  end
+
+  it "should return nil on non-supported operating systems" do
+    Facter.stubs(:value).with(:kernel).returns("SomeThing")
+    Facter::Manufacturer.get_dmi_table().should be_nil
+  end
+
+  it "should parse prtdiag output on a sunfire v120" do
+    Facter::Util::Resolution.stubs(:exec).returns(fixture_data(File.join("unit", "util", "manufacturer", "solaris_sunfire_v120_prtdiag")))
+    Facter::Manufacturer.prtdiag_sparc_find_system_info()
+    Facter.value(:manufacturer).should == "Sun Microsystems"
+    Facter.value(:productname).should == "Sun Fire V120 (UltraSPARC-IIe 648MHz)"
+  end
+
+  it "should parse prtdiag output on a t5220" do
+    Facter::Util::Resolution.stubs(:exec).returns(fixture_data(File.join("unit", "util", "manufacturer", "solaris_t5220_prtdiag")))
+    Facter::Manufacturer.prtdiag_sparc_find_system_info()
+    Facter.value(:manufacturer).should == "Sun Microsystems"
+    Facter.value(:productname).should == "SPARC Enterprise T5220"
+  end
+
+  it "should not set manufacturer or productname if prtdiag output is nil" do
+    # Stub kernel so we don't have windows fall through to its own mechanism
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+
+    Facter::Util::Resolution.stubs(:exec).returns(nil)
+    Facter::Manufacturer.prtdiag_sparc_find_system_info()
+    Facter.value(:manufacturer).should be_nil
+    Facter.value(:productname).should be_nil
+  end
+
+  it "should strip white space on dmi output with spaces" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/linux_dmidecode_with_spaces"
+    dmidecode_output = File.new(sample_output_file).read()
+    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+
+    query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => 'productname' } ] }
+
+    Facter::Manufacturer.dmi_find_system_info(query)
+    Facter.value(:productname).should == "MS-6754"
+  end
+
+  it "should handle output from smbios when run under sunos" do
+    sample_output_file = File.dirname(__FILE__) + "/../data/opensolaris_smbios"
+    smbios_output = File.new(sample_output_file).read()
+    Facter::Manufacturer.expects(:get_dmi_table).returns(smbios_output)
+    Facter.fact(:kernel).stubs(:value).returns("SunOS")
+
+    query = { 'BIOS information' => [ { 'Release Date:' => 'reldate' } ] }
+
+    Facter::Manufacturer.dmi_find_system_info(query)
+    Facter.value(:reldate).should == "12/01/2006"
+  end
+
+  it "should not split on dmi keys containing the string Handle" do
+    dmidecode_output = <<-eos
 Handle 0x1000, DMI type 16, 15 bytes
 Physical Memory Array
         Location: System Board Or Motherboard
@@ -61,16 +78,16 @@ Physical Memory Array
 Handle 0x001F
         DMI type 127, 4 bytes.
         End Of Table
-        eos
-        Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        query = { 'Physical Memory Array' => [ { 'Number Of Devices:' => 'ramslots'}]}
-        Facter::Manufacturer.dmi_find_system_info(query)
-        Facter.value(:ramslots).should == "123"
-    end
-
-    it "should match the key in the defined section and not the first one found" do
-        dmidecode_output = <<-eos
+    eos
+    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    query = { 'Physical Memory Array' => [ { 'Number Of Devices:' => 'ramslots'}]}
+    Facter::Manufacturer.dmi_find_system_info(query)
+    Facter.value(:ramslots).should == "123"
+  end
+
+  it "should match the key in the defined section and not the first one found" do
+    dmidecode_output = <<-eos
 Handle 0x000C, DMI type 7, 19 bytes
 Cache Information
         Socket Designation: Internal L2 Cache
@@ -99,55 +116,55 @@ Physical Memory Array
 Handle 0x001F
         DMI type 127, 4 bytes.
         End Of Table
-        eos
-        Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        query = { 'Physical Memory Array' => [ { 'Location:' => 'ramlocation'}]}
-        Facter::Manufacturer.dmi_find_system_info(query)
-        Facter.value(:ramlocation).should == "System Board Or Motherboard"
-    end
-
-    def find_product_name(os)
-        output_file = case os
-            when "FreeBSD" then File.dirname(__FILE__) + "/../data/freebsd_dmidecode"
-            when "SunOS" then File.dirname(__FILE__) + "/../data/opensolaris_smbios"
-            end
-
-        output = File.new(output_file).read()
-        query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => "product_name_#{os}" } ] }
-
-        Facter.fact(:kernel).stubs(:value).returns(os)
-        Facter::Manufacturer.expects(:get_dmi_table).returns(output)
-
-        Facter::Manufacturer.dmi_find_system_info(query)
-
-        return Facter.value("product_name_#{os}")
-    end
-
-    it "should return the same result with smbios than with dmidecode" do
-        find_product_name("FreeBSD").should_not == nil
-        find_product_name("FreeBSD").should == find_product_name("SunOS")
-    end
-
-    it "should find information on Windows" do
-        Facter.fact(:kernel).stubs(:value).returns("windows")
-        require 'facter/util/wmi'
-
-        bios = stubs 'bios'
-        bios.stubs(:Manufacturer).returns("Phoenix Technologies LTD")
-        bios.stubs(:Serialnumber).returns("56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f")
-
-        product = stubs 'product'
-        product.stubs(:Name).returns("VMware Virtual Platform")
-
-        wmi = stubs 'wmi'
-        wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
-        wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
-        wmi.stubs(:ExecQuery).with("select * from Win32_ComputerSystemProduct").returns([product])
-
-        Facter::Util::WMI.stubs(:connect).returns(wmi)
-        Facter.value(:manufacturer).should == "Phoenix Technologies LTD"
-        Facter.value(:serialnumber).should == "56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f"
-        Facter.value(:productname).should == "VMware Virtual Platform"
-    end
+    eos
+    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode_output)
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    query = { 'Physical Memory Array' => [ { 'Location:' => 'ramlocation'}]}
+    Facter::Manufacturer.dmi_find_system_info(query)
+    Facter.value(:ramlocation).should == "System Board Or Motherboard"
+  end
+
+  def find_product_name(os)
+    output_file = case os
+      when "FreeBSD" then File.dirname(__FILE__) + "/../data/freebsd_dmidecode"
+      when "SunOS" then File.dirname(__FILE__) + "/../data/opensolaris_smbios"
+      end
+
+    output = File.new(output_file).read()
+    query = { '[Ss]ystem [Ii]nformation' => [ { 'Product(?: Name)?:' => "product_name_#{os}" } ] }
+
+    Facter.fact(:kernel).stubs(:value).returns(os)
+    Facter::Manufacturer.expects(:get_dmi_table).returns(output)
+
+    Facter::Manufacturer.dmi_find_system_info(query)
+
+    return Facter.value("product_name_#{os}")
+  end
+
+  it "should return the same result with smbios than with dmidecode" do
+    find_product_name("FreeBSD").should_not == nil
+    find_product_name("FreeBSD").should == find_product_name("SunOS")
+  end
+
+  it "should find information on Windows" do
+    Facter.fact(:kernel).stubs(:value).returns("windows")
+    require 'facter/util/wmi'
+
+    bios = stubs 'bios'
+    bios.stubs(:Manufacturer).returns("Phoenix Technologies LTD")
+    bios.stubs(:Serialnumber).returns("56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f")
+
+    product = stubs 'product'
+    product.stubs(:Name).returns("VMware Virtual Platform")
+
+    wmi = stubs 'wmi'
+    wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
+    wmi.stubs(:ExecQuery).with("select * from Win32_Bios").returns([bios])
+    wmi.stubs(:ExecQuery).with("select * from Win32_ComputerSystemProduct").returns([product])
+
+    Facter::Util::WMI.stubs(:connect).returns(wmi)
+    Facter.value(:manufacturer).should == "Phoenix Technologies LTD"
+    Facter.value(:serialnumber).should == "56 4d 40 2b 4d 81 94 d6-e6 c5 56 a4 56 0c 9e 9f"
+    Facter.value(:productname).should == "VMware Virtual Platform"
+  end
 end

data/spec/unit/util/resolution_spec.rb

@@ -5,295 +5,295 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 require 'facter/util/resolution'
 
 describe Facter::Util::Resolution do
-    it "should require a name" do
-        lambda { Facter::Util::Resolution.new }.should raise_error(ArgumentError)
+  it "should require a name" do
+    lambda { Facter::Util::Resolution.new }.should raise_error(ArgumentError)
+  end
+
+  it "should have a name" do
+    Facter::Util::Resolution.new("yay").name.should == "yay"
+  end
+
+  it "should have a method for setting the weight" do
+    Facter::Util::Resolution.new("yay").should respond_to(:has_weight)
+  end
+
+  it "should have a method for setting the code" do
+    Facter::Util::Resolution.new("yay").should respond_to(:setcode)
+  end
+
+  it "should support a timeout value" do
+    Facter::Util::Resolution.new("yay").should respond_to(:timeout=)
+  end
+
+  it "should default to a timeout of 0 seconds" do
+    Facter::Util::Resolution.new("yay").limit.should == 0
+  end
+
+  it "should default to nil for code" do
+    Facter::Util::Resolution.new("yay").code.should be_nil
+  end
+
+  it "should default to nil for interpreter" do
+    Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
+    Facter::Util::Resolution.new("yay").interpreter.should be_nil
+  end
+
+  it "should provide a 'limit' method that returns the timeout" do
+    res = Facter::Util::Resolution.new("yay")
+    res.timeout = "testing"
+    res.limit.should == "testing"
+  end
+
+  describe "when setting the code" do
+    before do
+      Facter.stubs(:warnonce)
+      @resolve = Facter::Util::Resolution.new("yay")
     end
 
-    it "should have a name" do
-        Facter::Util::Resolution.new("yay").name.should == "yay"
+    it "should deprecate the interpreter argument to 'setcode'" do
+      Facter.expects(:warnonce).with("The interpreter parameter to 'setcode' is deprecated and will be removed in a future version.")
+      @resolve.setcode "foo", "bar"
+      @resolve.interpreter.should == "bar"
     end
 
-    it "should have a method for setting the weight" do
-      Facter::Util::Resolution.new("yay").should respond_to(:has_weight)
+    it "should deprecate the interpreter= method" do
+      Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version.")
+      @resolve.interpreter = "baz"
+      @resolve.interpreter.should == "baz"
     end
 
-    it "should have a method for setting the code" do
-        Facter::Util::Resolution.new("yay").should respond_to(:setcode)
+    it "should deprecate the interpreter method" do
+      Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
+      @resolve.interpreter
     end
 
-    it "should support a timeout value" do
-        Facter::Util::Resolution.new("yay").should respond_to(:timeout=)
+    it "should set the code to any provided string" do
+      @resolve.setcode "foo"
+      @resolve.code.should == "foo"
     end
 
-    it "should default to a timeout of 0 seconds" do
-        Facter::Util::Resolution.new("yay").limit.should == 0
+    it "should set the code to any provided block" do
+      block = lambda { }
+      @resolve.setcode(&block)
+      @resolve.code.should equal(block)
     end
 
-    it "should default to nil for code" do
-        Facter::Util::Resolution.new("yay").code.should be_nil
+    it "should prefer the string over a block" do
+      @resolve.setcode("foo") { }
+      @resolve.code.should == "foo"
     end
 
-    it "should default to nil for interpreter" do
-        Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
-        Facter::Util::Resolution.new("yay").interpreter.should be_nil
+    it "should fail if neither a string nor block has been provided" do
+      lambda { @resolve.setcode }.should raise_error(ArgumentError)
     end
+  end
 
-    it "should provide a 'limit' method that returns the timeout" do
-        res = Facter::Util::Resolution.new("yay")
-        res.timeout = "testing"
-        res.limit.should == "testing"
-    end
-
-    describe "when setting the code" do
-        before do
-            Facter.stubs(:warnonce)
-            @resolve = Facter::Util::Resolution.new("yay")
-        end
-
-        it "should deprecate the interpreter argument to 'setcode'" do
-            Facter.expects(:warnonce).with("The interpreter parameter to 'setcode' is deprecated and will be removed in a future version.")
-            @resolve.setcode "foo", "bar"
-            @resolve.interpreter.should == "bar"
-        end
+  it "should be able to return a value" do
+    Facter::Util::Resolution.new("yay").should respond_to(:value)
+  end
 
-        it "should deprecate the interpreter= method" do
-            Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter=' method is deprecated and will be removed in a future version.")
-            @resolve.interpreter = "baz"
-            @resolve.interpreter.should == "baz"
-        end
+  describe "when returning the value" do
+    before do
+      @resolve = Facter::Util::Resolution.new("yay")
+    end
 
-        it "should deprecate the interpreter method" do
-            Facter.expects(:warnonce).with("The 'Facter::Util::Resolution.interpreter' method is deprecated and will be removed in a future version.")
-            @resolve.interpreter
-        end
+    describe "and setcode has not been called" do
+      it "should return nil" do
+        Facter::Util::Resolution.expects(:exec).with(nil, nil).never
+        @resolve.value.should be_nil
+      end
+    end
 
-        it "should set the code to any provided string" do
-            @resolve.setcode "foo"
-            @resolve.code.should == "foo"
+    describe "and the code is a string" do
+      describe "on windows" do
+        before do
+          Facter::Util::Config.stubs(:is_windows?).returns(true)
         end
 
-        it "should set the code to any provided block" do
-            block = lambda { }
-            @resolve.setcode(&block)
-            @resolve.code.should equal(block)
-        end
+        it "should return the result of executing the code" do
+          @resolve.setcode "/bin/foo"
+          Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
 
-        it "should prefer the string over a block" do
-            @resolve.setcode("foo") { }
-            @resolve.code.should == "foo"
+          @resolve.value.should == "yup"
         end
 
-        it "should fail if neither a string nor block has been provided" do
-            lambda { @resolve.setcode }.should raise_error(ArgumentError)
+        it "should return nil if the value is an empty string" do
+          @resolve.setcode "/bin/foo"
+          Facter::Util::Resolution.expects(:exec).once.returns ""
+          @resolve.value.should be_nil
         end
-    end
-
-    it "should be able to return a value" do
-        Facter::Util::Resolution.new("yay").should respond_to(:value)
-    end
+      end
 
-    describe "when returning the value" do
+      describe "on non-windows systems" do
         before do
-            @resolve = Facter::Util::Resolution.new("yay")
+          Facter::Util::Config.stubs(:is_windows?).returns(false)
         end
 
-        describe "and setcode has not been called" do
-            it "should return nil" do
-                Facter::Util::Resolution.expects(:exec).with(nil, nil).never
-                @resolve.value.should be_nil
-            end
-        end
+        it "should return the result of executing the code" do
+          @resolve.setcode "/bin/foo"
+          Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
 
-        describe "and the code is a string" do
-            describe "on windows" do
-                before do
-                    Facter::Util::Resolution::WINDOWS = true
-                end
-
-                it "should return the result of executing the code" do
-                    @resolve.setcode "/bin/foo"
-                    Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
-
-                    @resolve.value.should == "yup"
-                end
-
-                it "should return nil if the value is an empty string" do
-                    @resolve.setcode "/bin/foo"
-                    Facter::Util::Resolution.expects(:exec).once.returns ""
-                    @resolve.value.should be_nil
-                end
-            end
-
-            describe "on non-windows systems" do
-                before do
-                    Facter::Util::Resolution::WINDOWS = false
-                end
-
-                it "should return the result of executing the code" do
-                    @resolve.setcode "/bin/foo"
-                    Facter::Util::Resolution.expects(:exec).once.with("/bin/foo").returns "yup"
-
-                    @resolve.value.should == "yup"
-                end
-
-                it "should return nil if the value is an empty string" do
-                    @resolve.setcode "/bin/foo"
-                    Facter::Util::Resolution.expects(:exec).once.returns ""
-                    @resolve.value.should be_nil
-                end
-            end
+          @resolve.value.should == "yup"
         end
 
-        describe "and the code is a block" do
-            it "should warn but not fail if the code fails" do
-                @resolve.setcode { raise "feh" }
-                @resolve.expects(:warn)
-                @resolve.value.should be_nil
-            end
-
-            it "should return the value returned by the block" do
-                @resolve.setcode { "yayness" }
-                @resolve.value.should == "yayness"
-            end
-
-            it "should return nil if the value is an empty string" do
-                @resolve.setcode { "" }
-                @resolve.value.should be_nil
-            end
-
-            it "should return nil if the value is an empty block" do
-                @resolve.setcode { "" }
-                @resolve.value.should be_nil
-            end
-
-            it "should use its limit method to determine the timeout, to avoid conflict when a 'timeout' method exists for some other reason" do
-                @resolve.expects(:timeout).never
-                @resolve.expects(:limit).returns "foo"
-                Timeout.expects(:timeout).with("foo")
-
-                @resolve.setcode { sleep 2; "raise This is a test"}
-                @resolve.value
-            end
-
-            it "should timeout after the provided timeout" do
-                @resolve.expects(:warn)
-                @resolve.timeout = 0.1
-                @resolve.setcode { sleep 2; raise "This is a test" }
-                Thread.expects(:new).yields
-
-                @resolve.value.should be_nil
-            end
-
-            it "should waitall to avoid zombies if the timeout is exceeded" do
-                @resolve.stubs(:warn)
-                @resolve.timeout = 0.1
-                @resolve.setcode { sleep 2; raise "This is a test" }
-
-                Thread.expects(:new).yields
-                Process.expects(:waitall)
-
-                @resolve.value
-            end
+        it "should return nil if the value is an empty string" do
+          @resolve.setcode "/bin/foo"
+          Facter::Util::Resolution.expects(:exec).once.returns ""
+          @resolve.value.should be_nil
         end
+      end
     end
 
-    it "should return its value when converted to a string" do
-        @resolve = Facter::Util::Resolution.new("yay")
-        @resolve.expects(:value).returns "myval"
-        @resolve.to_s.should == "myval"
+    describe "and the code is a block" do
+      it "should warn but not fail if the code fails" do
+        @resolve.setcode { raise "feh" }
+        @resolve.expects(:warn)
+        @resolve.value.should be_nil
+      end
+
+      it "should return the value returned by the block" do
+        @resolve.setcode { "yayness" }
+        @resolve.value.should == "yayness"
+      end
+
+      it "should return nil if the value is an empty string" do
+        @resolve.setcode { "" }
+        @resolve.value.should be_nil
+      end
+
+      it "should return nil if the value is an empty block" do
+        @resolve.setcode { "" }
+        @resolve.value.should be_nil
+      end
+
+      it "should use its limit method to determine the timeout, to avoid conflict when a 'timeout' method exists for some other reason" do
+        @resolve.expects(:timeout).never
+        @resolve.expects(:limit).returns "foo"
+        Timeout.expects(:timeout).with("foo")
+
+        @resolve.setcode { sleep 2; "raise This is a test"}
+        @resolve.value
+      end
+
+      it "should timeout after the provided timeout" do
+        @resolve.expects(:warn)
+        @resolve.timeout = 0.1
+        @resolve.setcode { sleep 2; raise "This is a test" }
+        Thread.expects(:new).yields
+
+        @resolve.value.should be_nil
+      end
+
+      it "should waitall to avoid zombies if the timeout is exceeded" do
+        @resolve.stubs(:warn)
+        @resolve.timeout = 0.1
+        @resolve.setcode { sleep 2; raise "This is a test" }
+
+        Thread.expects(:new).yields
+        Process.expects(:waitall)
+
+        @resolve.value
+      end
     end
-
-    it "should allow the adding of confines" do
-        Facter::Util::Resolution.new("yay").should respond_to(:confine)
+  end
+
+  it "should return its value when converted to a string" do
+    @resolve = Facter::Util::Resolution.new("yay")
+    @resolve.expects(:value).returns "myval"
+    @resolve.to_s.should == "myval"
+  end
+
+  it "should allow the adding of confines" do
+    Facter::Util::Resolution.new("yay").should respond_to(:confine)
+  end
+
+  it "should provide a method for returning the number of confines" do
+    @resolve = Facter::Util::Resolution.new("yay")
+    @resolve.confine "one" => "foo", "two" => "fee"
+    @resolve.weight.should == 2
+  end
+
+  it "should return 0 confines when no confines have been added" do
+    Facter::Util::Resolution.new("yay").weight.should == 0
+  end
+
+  it "should provide a way to set the weight" do
+    @resolve = Facter::Util::Resolution.new("yay")
+    @resolve.has_weight(45)
+    @resolve.weight.should == 45
+  end
+
+  it "should allow the weight to override the number of confines" do
+    @resolve = Facter::Util::Resolution.new("yay")
+    @resolve.confine "one" => "foo", "two" => "fee"
+    @resolve.weight.should == 2
+    @resolve.has_weight(45)
+    @resolve.weight.should == 45
+  end
+
+  it "should have a method for determining if it is suitable" do
+    Facter::Util::Resolution.new("yay").should respond_to(:suitable?)
+  end
+
+  describe "when adding confines" do
+    before do
+      @resolve = Facter::Util::Resolution.new("yay")
     end
 
-    it "should provide a method for returning the number of confines" do
-        @resolve = Facter::Util::Resolution.new("yay")
-        @resolve.confine "one" => "foo", "two" => "fee"
-        @resolve.weight.should == 2
+    it "should accept a hash of fact names and values" do
+      lambda { @resolve.confine :one => "two" }.should_not raise_error
     end
 
-    it "should return 0 confines when no confines have been added" do
-        Facter::Util::Resolution.new("yay").weight.should == 0
-    end
+    it "should create a Util::Confine instance for every argument in the provided hash" do
+      Facter::Util::Confine.expects(:new).with("one", "foo")
+      Facter::Util::Confine.expects(:new).with("two", "fee")
 
-    it "should provide a way to set the weight" do
-        @resolve = Facter::Util::Resolution.new("yay")
-        @resolve.has_weight(45)
-        @resolve.weight.should == 45
+      @resolve.confine "one" => "foo", "two" => "fee"
     end
 
-    it "should allow the weight to override the number of confines" do
-        @resolve = Facter::Util::Resolution.new("yay")
-        @resolve.confine "one" => "foo", "two" => "fee"
-        @resolve.weight.should == 2
-        @resolve.has_weight(45)
-        @resolve.weight.should == 45
-    end
+  end
 
-    it "should have a method for determining if it is suitable" do
-        Facter::Util::Resolution.new("yay").should respond_to(:suitable?)
+  describe "when determining suitability" do
+    before do
+      @resolve = Facter::Util::Resolution.new("yay")
     end
 
-    describe "when adding confines" do
-        before do
-            @resolve = Facter::Util::Resolution.new("yay")
-        end
-
-        it "should accept a hash of fact names and values" do
-            lambda { @resolve.confine :one => "two" }.should_not raise_error
-        end
-
-        it "should create a Util::Confine instance for every argument in the provided hash" do
-            Facter::Util::Confine.expects(:new).with("one", "foo")
-            Facter::Util::Confine.expects(:new).with("two", "fee")
-
-            @resolve.confine "one" => "foo", "two" => "fee"
-        end
-
+    it "should always be suitable if no confines have been added" do
+      @resolve.should be_suitable
     end
 
-    describe "when determining suitability" do
-        before do
-            @resolve = Facter::Util::Resolution.new("yay")
-        end
+    it "should be unsuitable if any provided confines return false" do
+      confine1 = mock 'confine1', :true? => true
+      confine2 = mock 'confine2', :true? => false
+      Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
+      @resolve.confine :one => :two, :three => :four
 
-        it "should always be suitable if no confines have been added" do
-            @resolve.should be_suitable
-        end
-
-        it "should be unsuitable if any provided confines return false" do
-            confine1 = mock 'confine1', :true? => true
-            confine2 = mock 'confine2', :true? => false
-            Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
-            @resolve.confine :one => :two, :three => :four
-
-            @resolve.should_not be_suitable
-        end
+      @resolve.should_not be_suitable
+    end
 
-        it "should be suitable if all provided confines return true" do
-            confine1 = mock 'confine1', :true? => true
-            confine2 = mock 'confine2', :true? => true
-            Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
-            @resolve.confine :one => :two, :three => :four
+    it "should be suitable if all provided confines return true" do
+      confine1 = mock 'confine1', :true? => true
+      confine2 = mock 'confine2', :true? => true
+      Facter::Util::Confine.expects(:new).times(2).returns(confine1).then.returns(confine2)
+      @resolve.confine :one => :two, :three => :four
 
-            @resolve.should be_suitable
-        end
+      @resolve.should be_suitable
     end
+  end
 
-    it "should have a class method for executing code" do
-        Facter::Util::Resolution.should respond_to(:exec)
-    end
+  it "should have a class method for executing code" do
+    Facter::Util::Resolution.should respond_to(:exec)
+  end
 
-    # It's not possible, AFAICT, to mock %x{}, so I can't really test this bit.
-    describe "when executing code" do
-        it "should deprecate the interpreter parameter" do
-            Facter.expects(:warnonce).with("The interpreter parameter to 'exec' is deprecated and will be removed in a future version.")
-            Facter::Util::Resolution.exec("/something", "/bin/perl")
-        end
+  # It's not possible, AFAICT, to mock %x{}, so I can't really test this bit.
+  describe "when executing code" do
+    it "should deprecate the interpreter parameter" do
+      Facter.expects(:warnonce).with("The interpreter parameter to 'exec' is deprecated and will be removed in a future version.")
+      Facter::Util::Resolution.exec("/something", "/bin/perl")
+    end
 
-        it "should execute the binary" do
-            Facter::Util::Resolution.exec("echo foo").should == "foo"
-        end
+    it "should execute the binary" do
+      Facter::Util::Resolution.exec("echo foo").should == "foo"
     end
+  end
 end