facter 1.6.9 → 1.6.10

data/spec/puppetlabs_spec/verbose.rb

@@ -0,0 +1,9 @@
+# Support code for running stuff with warnings disabled.
+module Kernel
+  def with_verbose_disabled
+    verbose, $VERBOSE = $VERBOSE, nil
+    result = yield
+    $VERBOSE = verbose
+    return result
+  end
+end

data/spec/puppetlabs_spec_helper.rb

@@ -11,6 +11,7 @@ end
 require 'puppetlabs_spec/files'
 require 'puppetlabs_spec/fixtures'
 require 'puppetlabs_spec/matchers'
+require 'puppetlabs_spec/verbose'
 
 RSpec.configure do |config|
   # Include PuppetlabsSpec helpers so they can be called at convenience

data/spec/shared_contexts/platform.rb

@@ -0,0 +1,55 @@
+# Contexts for stubbing platforms
+# In a describe or context block, adding :as_platform => :windows or
+# :as_platform => :posix will stub the relevant facter config, as well as
+# the behavior of Ruby's filesystem methods by changing File::ALT_SEPARATOR.
+#
+#
+#
+shared_context "windows", :as_platform => :windows do
+  before :each do
+    Facter.fact(:operatingsystem).stubs(:value).returns('Windows')
+    Facter::Util::Config.stubs(:is_windows?).returns true
+  end
+
+  around do |example|
+    file_alt_separator = File::ALT_SEPARATOR
+    file_path_separator = File::PATH_SEPARATOR
+    # prevent Ruby from warning about changing a constant
+    with_verbose_disabled do
+      File::ALT_SEPARATOR = '\\'
+      File::PATH_SEPARATOR = ';'
+    end
+    begin
+      example.run
+    ensure
+      with_verbose_disabled do
+        File::ALT_SEPARATOR = file_alt_separator
+        File::PATH_SEPARATOR = file_path_separator
+      end
+    end
+  end
+end
+
+shared_context "posix", :as_platform => :posix do
+  before :each do
+    Facter::Util::Config.stubs(:is_windows?).returns false
+  end
+
+  around do |example|
+    file_alt_separator = File::ALT_SEPARATOR
+    file_path_separator = File::PATH_SEPARATOR
+    # prevent Ruby from warning about changing a constant
+    with_verbose_disabled do
+      File::ALT_SEPARATOR = nil
+      File::PATH_SEPARATOR = ':'
+    end
+    begin
+      example.run
+    ensure
+      with_verbose_disabled do
+        File::ALT_SEPARATOR = file_alt_separator
+        File::PATH_SEPARATOR = file_path_separator
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -11,6 +11,11 @@ require 'rspec'
 require 'facter'
 require 'fileutils'
 require 'puppetlabs_spec_helper'
+require 'pathname'
+
+Pathname.glob("#{dir}/shared_contexts/*.rb") do |file|
+  require file.relative_path_from(Pathname.new(dir))
+end
 
 RSpec.configure do |config|
   config.mock_with :mocha

data/spec/unit/architecture_spec.rb

@@ -21,6 +21,8 @@ describe "Architecture fact" do
     ["Gentoo","i586"] => "x86",
     ["Gentoo","i686"] => "x86",
     ["Gentoo","pentium"] => "x86",
+    ["windows","i386"] => "x86",
+    ["windows","x64"] => "x64",
   }
   generic_archs = Hash.new
   generic_archs = {

data/spec/unit/domain_spec.rb

@@ -98,19 +98,39 @@ describe "Domain name facts" do
   end
 
   describe "on Windows" do
-    it "should use the DNSDomain for the first nic where ip is enabled" do
+    before(:each) do
       Facter.fact(:kernel).stubs(:value).returns("windows")
+      require 'facter/util/registry'
+    end
+    describe "with primary dns suffix" do
+      before(:each) do
+        Facter::Util::Registry.stubs(:hklm_read).returns('baz.com')
+      end
+      it "should get the primary dns suffix" do
+        Facter.fact(:domain).value.should == 'baz.com'
+      end
+      it "should not execute the wmi query" do
+        require 'facter/util/wmi'
+        Facter::Util::WMI.expects(:execquery).never
+        Facter.fact(:domain).value
+      end
+    end
+    describe "without primary dns suffix" do
+      before(:each) do
+        Facter::Util::Registry.stubs(:hklm_read).returns('')
+      end
+      it "should use the DNSDomain for the first nic where ip is enabled" do
+        nic = stubs 'nic'
+        nic.stubs(:DNSDomain).returns("foo.com")
 
-      nic = stubs 'nic'
-      nic.stubs(:DNSDomain).returns("foo.com")
-
-      nic2 = stubs 'nic'
-      nic2.stubs(:DNSDomain).returns("bar.com")
+        nic2 = stubs 'nic'
+        nic2.stubs(:DNSDomain).returns("bar.com")
 
-      require 'facter/util/wmi'
-      Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns([nic, nic2])
+        require 'facter/util/wmi'
+        Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns([nic, nic2])
 
-      Facter.fact(:domain).value.should == 'foo.com'
+        Facter.fact(:domain).value.should == 'foo.com'
+      end
     end
   end
 end

data/spec/unit/facter_spec.rb

@@ -74,8 +74,9 @@ describe Facter do
 
   describe "when provided code as a string" do
     it "should execute the code in the shell" do
+      test_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c echo yup' : 'echo yup'
       Facter.add("shell_testing") do
-        setcode "echo yup"
+        setcode test_command
       end
 
       Facter["shell_testing"].value.should == "yup"

data/spec/unit/hardwaremodel_spec.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter'
+
+describe "Hardwaremodel fact" do
+  it "should match uname -m by default" do
+    Facter.fact(:kernel).stubs(:value).returns("Darwin")
+    Facter::Util::Resolution.stubs(:exec).with("uname -m").returns("Inky")
+
+    Facter.fact(:hardwaremodel).value.should == "Inky"
+  end
+
+  describe "on Windows" do
+    require 'facter/util/wmi'
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns("windows")
+    end
+
+    it "should detect i686" do
+      cpu = mock('cpu', :Architecture => 0, :Level => 6)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "i686"
+    end
+
+    it "should detect x64" do
+      cpu = mock('cpu', :Architecture => 9)
+      Facter::Util::WMI.expects(:execquery).returns([cpu])
+
+      Facter.fact(:hardwaremodel).value.should == "x64"
+    end
+  end
+end

data/spec/unit/ipaddress6_spec.rb

@@ -44,7 +44,7 @@ describe "IPv6 address fact" do
     Facter::Util::Config.stubs(:is_windows?).returns(true)
 
     fixture = netsh_fixture('windows_netsh_addresses_with_multiple_interfaces')
-    Facter::Util::Resolution.stubs(:exec).with('d:/windows/system32/netsh interface ipv6 show address level=verbose').
+    Facter::Util::Resolution.stubs(:exec).with('d:/windows/system32/netsh.exe interface ipv6 show address level=verbose').
       returns(fixture)
 
     Facter.value(:ipaddress6).should == "2001:0:4137:9e76:2087:77a:53ef:7527"

data/spec/unit/lsbdistcodename_spec.rb

@@ -10,13 +10,13 @@ describe "lsbdistcodename fact" do
         Facter.fact(:kernel).stubs(:value).returns kernel
       end
 
-      it "should return the codename through lsb_release -c -s" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -c -s').returns 'n/a'
+      it "should return the codename through lsb_release -c -s 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -c -s 2>/dev/null').returns 'n/a'
         Facter.fact(:lsbdistcodename).value.should == 'n/a'
       end
 
       it "should return nil if lsb_release is not installed" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -c -s').returns nil
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -c -s 2>/dev/null').returns nil
         Facter.fact(:lsbdistcodename).value.should be_nil
       end
     end

data/spec/unit/lsbdistdescription_spec.rb

@@ -10,13 +10,13 @@ describe "lsbdistdescription fact" do
         Facter.fact(:kernel).stubs(:value).returns kernel
       end
 
-      it "should return the description through lsb_release -d -s" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -d -s').returns '"Gentoo Base System release 2.1"'
+      it "should return the description through lsb_release -d -s 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -d -s 2>/dev/null').returns '"Gentoo Base System release 2.1"'
         Facter.fact(:lsbdistdescription).value.should == 'Gentoo Base System release 2.1'
       end
 
       it "should return nil if lsb_release is not installed" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -d -s').returns nil
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -d -s 2>/dev/null').returns nil
         Facter.fact(:lsbdistdescription).value.should be_nil
       end
     end

data/spec/unit/lsbdistid_spec.rb

@@ -10,13 +10,13 @@ describe "lsbdistid fact" do
         Facter.fact(:kernel).stubs(:value).returns kernel
       end
 
-      it "should return the id through lsb_release -i -s" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -i -s').returns 'Gentoo'
+      it "should return the id through lsb_release -i -s 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -i -s 2>/dev/null').returns 'Gentoo'
         Facter.fact(:lsbdistid).value.should == 'Gentoo'
       end
 
-      it "should return nil if lsb_release is not installed" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -i -s').returns nil
+      it "should return nil if lsb_release is not installed 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -i -s 2>/dev/null').returns nil
         Facter.fact(:lsbdistid).value.should be_nil
       end
     end

data/spec/unit/lsbdistrelease_spec.rb

@@ -10,13 +10,13 @@ describe "lsbdistrelease fact" do
         Facter.fact(:kernel).stubs(:value).returns kernel
       end
 
-      it "should return the release through lsb_release -r -s" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -r -s').returns '2.1'
+      it "should return the release through lsb_release -r -s 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -r -s 2>/dev/null').returns '2.1'
         Facter.fact(:lsbdistrelease).value.should == '2.1'
       end
 
       it "should return nil if lsb_release is not installed" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -r -s').returns nil
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -r -s 2>/dev/null').returns nil
         Facter.fact(:lsbdistrelease).value.should be_nil
       end
     end

data/spec/unit/lsbrelease_spec.rb

@@ -10,13 +10,13 @@ describe "lsbrelease fact" do
         Facter.fact(:kernel).stubs(:value).returns kernel
       end
 
-      it "should return the release through lsb_release -v -s" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -v -s').returns 'n/a'
+      it "should return the release through lsb_release -v -s 2>/dev/null" do
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -v -s 2>/dev/null').returns 'n/a'
         Facter.fact(:lsbrelease).value.should == 'n/a'
       end
 
       it "should return nil if lsb_release is not installed" do
-        Facter::Util::Resolution.stubs(:exec).with('lsb_release -v -s').returns nil
+        Facter::Util::Resolution.stubs(:exec).with('lsb_release -v -s 2>/dev/null').returns nil
         Facter.fact(:lsbrelease).value.should be_nil
       end
     end

data/spec/unit/processor_spec.rb

@@ -16,6 +16,8 @@ describe "Processor facts" do
     def load(procs)
       require 'facter/util/wmi'
       Facter::Util::WMI.stubs(:execquery).with("select * from Win32_Processor").returns(procs)
+      # This is to workaround #14674
+      Facter.fact(:architecture).stubs(:value).returns("x64")
 
       # processor facts belong to a file with a different name,
       # so load the file explicitly (after stubbing kernel),

data/spec/unit/util/registry_spec.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env rspec
+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

@@ -284,6 +284,210 @@ describe Facter::Util::Resolution do
     Facter::Util::Resolution.should respond_to(:exec)
   end
 
+  # taken from puppet: spec/unit/util_spec.rb
+  describe "#absolute_path?" do
+    context "when run on unix", :as_platform => :posix do
+      %w[/ /foo /foo/../bar //foo //Server/Foo/Bar //?/C:/foo/bar /\Server/Foo /foo//bar/baz].each do |path|
+        it "should return true for #{path}" do
+          Facter::Util::Resolution.should be_absolute_path(path)
+        end
+      end
+
+      %w[. ./foo \foo C:/foo \\Server\Foo\Bar \\?\C:\foo\bar \/?/foo\bar \/Server/foo foo//bar/baz].each do |path|
+        it "should return false for #{path}" do
+          Facter::Util::Resolution.should_not be_absolute_path(path)
+        end
+      end
+    end
+
+    context "when run on windows", :as_platform => :windows  do
+      %w[C:/foo C:\foo \\\\Server\Foo\Bar \\\\?\C:\foo\bar //Server/Foo/Bar //?/C:/foo/bar /\?\C:/foo\bar \/Server\Foo/Bar c:/foo//bar//baz].each do |path|
+        it "should return true for #{path}" do
+          Facter::Util::Resolution.should be_absolute_path(path)
+        end
+      end
+
+      %w[/ . ./foo \foo /foo /foo/../bar //foo C:foo/bar foo//bar/baz].each do |path|
+        it "should return false for #{path}" do
+          Facter::Util::Resolution.should_not be_absolute_path(path)
+        end
+      end
+    end
+  end
+
+  describe "#search_paths" do
+    context "on windows", :as_platform => :windows do
+      it "should use the PATH environment variable to determine locations" do
+        ENV.expects(:[]).with('PATH').returns 'C:\Windows;C:\Windows\System32'
+        Facter::Util::Resolution.search_paths.should == %w{C:\Windows C:\Windows\System32}
+      end
+    end
+
+    context "on posix", :as_platform => :posix do
+      it "should use the PATH environment variable plus /sbin and /usr/sbin on unix" do
+        ENV.expects(:[]).with('PATH').returns "/bin:/usr/bin"
+        Facter::Util::Resolution.search_paths.should == %w{/bin /usr/bin /sbin /usr/sbin}
+      end
+    end
+  end
+
+  describe "#which" do
+    context "when run on posix", :as_platform => :posix  do
+      before :each do
+        Facter::Util::Resolution.stubs(:search_paths).returns [ '/bin', '/sbin', '/usr/sbin']
+      end
+
+      context "and provided with an absolute path" do
+        it "should return the binary if executable" do
+          File.expects(:executable?).with('/opt/foo').returns true
+          Facter::Util::Resolution.which('/opt/foo').should == '/opt/foo'
+        end
+
+        it "should return nil if the binary is not executable" do
+          File.expects(:executable?).with('/opt/foo').returns false
+          Facter::Util::Resolution.which('/opt/foo').should be_nil
+        end
+      end
+
+      context "and not provided with an absolute path" do
+        it "should return the absolute path if found" do
+          File.expects(:executable?).with('/bin/foo').returns false
+          File.expects(:executable?).with('/sbin/foo').returns true
+          File.expects(:executable?).with('/usr/sbin/foo').never
+          Facter::Util::Resolution.which('foo').should == '/sbin/foo'
+        end
+
+        it "should return nil if not found" do
+          File.expects(:executable?).with('/bin/foo').returns false
+          File.expects(:executable?).with('/sbin/foo').returns false
+          File.expects(:executable?).with('/usr/sbin/foo').returns false
+          Facter::Util::Resolution.which('foo').should be_nil
+        end
+      end
+    end
+
+    context "when run on windows", :as_platform => :windows do
+      before :each do
+        Facter::Util::Resolution.stubs(:search_paths).returns ['C:\Windows\system32', 'C:\Windows', 'C:\Windows\System32\Wbem' ]
+        ENV.stubs(:[]).with('PATHEXT').returns nil
+      end
+
+      context "and provided with an absolute path" do
+        it "should return the binary if executable" do
+          File.expects(:executable?).with('C:\Tools\foo.exe').returns true
+          File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns true
+          Facter::Util::Resolution.which('C:\Tools\foo.exe').should == 'C:\Tools\foo.exe'
+          Facter::Util::Resolution.which('\\\\remote\dir\foo.exe').should == '\\\\remote\dir\foo.exe'
+        end
+
+        it "should return the binary with added extension if executable" do
+          ['.COM', '.BAT', '.CMD', '' ].each do |ext|
+            File.stubs(:executable?).with('C:\Windows\system32\netsh'+ext).returns false
+          end
+          File.expects(:executable?).with('C:\Windows\system32\netsh.EXE').returns true
+
+          Facter.expects(:warnonce).with('Using Facter::Util::Resolution.which with an absolute path like C:\\Windows\\system32\\netsh but no fileextension is deprecated. Please add the correct extension (.EXE)')
+          Facter::Util::Resolution.which('C:\Windows\system32\netsh').should == 'C:\Windows\system32\netsh.EXE'
+        end
+
+        it "should return nil if the binary is not executable" do
+          File.expects(:executable?).with('C:\Tools\foo.exe').returns false
+          File.expects(:executable?).with('\\\\remote\dir\foo.exe').returns false
+          Facter::Util::Resolution.which('C:\Tools\foo.exe').should be_nil
+          Facter::Util::Resolution.which('\\\\remote\dir\foo.exe').should be_nil
+        end
+      end
+
+      context "and not provided with an absolute path" do
+        it "should return the absolute path if found" do
+          File.expects(:executable?).with('C:\Windows\system32\foo.exe').returns false
+          File.expects(:executable?).with('C:\Windows\foo.exe').returns true
+          File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').never
+          Facter::Util::Resolution.which('foo.exe').should == 'C:\Windows\foo.exe'
+        end
+
+        it "should return the absolute path with file extension if found" do
+          ['.COM', '.EXE', '.BAT', '.CMD', '' ].each do |ext|
+            File.stubs(:executable?).with('C:\Windows\system32\foo'+ext).returns false
+            File.stubs(:executable?).with('C:\Windows\System32\Wbem\foo'+ext).returns false
+          end
+          ['.COM', '.BAT', '.CMD', '' ].each do |ext|
+            File.stubs(:executable?).with('C:\Windows\foo'+ext).returns false
+          end
+          File.stubs(:executable?).with('C:\Windows\foo.EXE').returns true
+
+          Facter::Util::Resolution.which('foo').should == 'C:\Windows\foo.EXE'
+        end
+
+        it "should return nil if not found" do
+          File.expects(:executable?).with('C:\Windows\system32\foo.exe').returns false
+          File.expects(:executable?).with('C:\Windows\foo.exe').returns false
+          File.expects(:executable?).with('C:\Windows\System32\Wbem\foo.exe').returns false
+          Facter::Util::Resolution.which('foo.exe').should be_nil
+        end
+      end
+    end
+
+    describe "#expand_command" do
+      context "on windows", :as_platform => :windows do
+        it "should expand binary" do
+          Facter::Util::Resolution.expects(:which).with('cmd').returns 'C:\Windows\System32\cmd'
+          Facter::Util::Resolution.expand_command(
+            'cmd /c echo foo > C:\bar'
+          ).should == 'C:\Windows\System32\cmd /c echo foo > C:\bar'
+        end
+
+        it "should expand double quoted binary" do
+          Facter::Util::Resolution.expects(:which).with('my foo').returns 'C:\My Tools\my foo.exe'
+          Facter::Util::Resolution.expand_command('"my foo" /a /b').should == '"C:\My Tools\my foo.exe" /a /b'
+        end
+
+        it "should not expand single quoted binary" do
+          Facter::Util::Resolution.expects(:which).with('\'C:\My').returns nil
+          Facter::Util::Resolution.expand_command('\'C:\My Tools\foo.exe\' /a /b').should be_nil
+        end
+
+        it "should quote expanded binary if found in path with spaces" do
+          Facter::Util::Resolution.expects(:which).with('foo').returns 'C:\My Tools\foo.exe'
+          Facter::Util::Resolution.expand_command('foo /a /b').should == '"C:\My Tools\foo.exe" /a /b'
+        end
+
+        it "should return nil if not found" do
+          Facter::Util::Resolution.expects(:which).with('foo').returns nil
+          Facter::Util::Resolution.expand_command('foo /a | stuff >> /dev/null').should be_nil
+        end
+      end
+
+      context "on unix", :as_platform => :posix do
+        it "should expand binary" do
+          Facter::Util::Resolution.expects(:which).with('foo').returns '/bin/foo'
+          Facter::Util::Resolution.expand_command('foo -a | stuff >> /dev/null').should == '/bin/foo -a | stuff >> /dev/null'
+        end
+
+        it "should expand double quoted binary" do
+          Facter::Util::Resolution.expects(:which).with('/tmp/my foo').returns '/tmp/my foo'
+          Facter::Util::Resolution.expand_command(%q{"/tmp/my foo" bar}).should == %q{"/tmp/my foo" bar}
+        end
+
+        it "should expand single quoted binary" do
+          Facter::Util::Resolution.expects(:which).with('my foo').returns '/home/bob/my path/my foo'
+          Facter::Util::Resolution.expand_command(%q{'my foo' -a}).should == %q{'/home/bob/my path/my foo' -a}
+        end
+
+        it "should quote expanded binary if found in path with spaces" do
+          Facter::Util::Resolution.expects(:which).with('foo.sh').returns '/home/bob/my tools/foo.sh'
+          Facter::Util::Resolution.expand_command('foo.sh /a /b').should == %q{'/home/bob/my tools/foo.sh' /a /b}
+        end
+
+        it "should return nil if not found" do
+          Facter::Util::Resolution.expects(:which).with('foo').returns nil
+          Facter::Util::Resolution.expand_command('foo -a | stuff >> /dev/null').should be_nil
+        end
+      end
+    end
+
+  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
@@ -292,41 +496,73 @@ describe Facter::Util::Resolution do
     end
 
     it "should execute the binary" do
-      Facter::Util::Resolution.exec("echo foo").should == "foo"
+      test_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c echo foo' : 'echo foo'
+      Facter::Util::Resolution.exec(test_command).should == "foo"
     end
-  end
 
-  describe "have_which" do
-    before :each do
-      Facter::Util::Resolution.instance_variable_set(:@have_which, nil)
+    context "when run on unix", :as_platform => :posix  do
+      context "binary is present" do
+        it "should run the command if path to binary is absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with('/usr/bin/uname -m').returns('/usr/bin/uname -m')
+          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').returns 'x86_64'
+          Facter::Util::Resolution.exec('/usr/bin/uname -m').should == 'x86_64'
+        end
 
-      # we do not execute anything in the following test cases itself
-      # but we rely on $? to be an instance of Process::Status. So
-      # just execute anything here to make sure that $? is not nil
-      %x{echo foo}
-    end
+        it "should run the expanded command if path to binary not absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with('uname -m').returns('/usr/bin/uname -m')
+          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').returns 'x86_64'
+          Facter::Util::Resolution.exec('uname -m').should == 'x86_64'
+        end
+      end
 
-    it "on windows should always return false" do
-      Facter::Util::Config.stubs(:is_windows?).returns(true)
-      Facter::Util::Resolution.expects(:`).
-        with('which which >/dev/null 2>&1').never
-      Facter::Util::Resolution.have_which.should == false
+      context "binary is not present" do
+        it "should not run the command if path to binary is absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with('/usr/bin/uname -m').returns nil
+          Facter::Util::Resolution.expects(:`).with('/usr/bin/uname -m').never
+          Facter::Util::Resolution.exec('/usr/bin/uname -m').should be_nil
+        end
+        it "should not run the command if path to binary is not absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with('uname -m').returns nil
+          Facter::Util::Resolution.expects(:`).with('uname -m').never
+          Facter::Util::Resolution.exec('uname -m').should be_nil
+        end
+      end
     end
 
-    it "on other platforms than windows should return true if which exists" do
-      Facter::Util::Config.stubs(:is_windows?).returns(false)
-      Facter::Util::Resolution.expects(:`).
-        with('which which >/dev/null 2>&1').returns('')
-      Process::Status.any_instance.stubs(:success?).returns true
-      Facter::Util::Resolution.have_which.should == true
-    end
+    context "when run on windows", :as_platform => :windows do
+      context "binary is present" do
+        it "should run the command if path to binary is absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with(%q{C:\Windows\foo.exe /a /b}).returns(%q{C:\Windows\foo.exe /a /b})
+          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).returns 'bar'
+          Facter::Util::Resolution.exec(%q{C:\Windows\foo.exe /a /b}).should == 'bar'
+        end
 
-    it "on other platforms than windows should return false if which returns non-zero exit code" do
-      Facter::Util::Config.stubs(:is_windows?).returns(false)
-      Facter::Util::Resolution.expects(:`).
-        with('which which >/dev/null 2>&1').returns('')
-      Process::Status.any_instance.stubs(:success?).returns false
-      Facter::Util::Resolution.have_which.should == false
+        it "should run the expanded command if path to binary not absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with(%q{foo.exe /a /b}).returns(%q{C:\Windows\foo.exe /a /b})
+          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).returns 'bar'
+          Facter::Util::Resolution.exec(%q{foo.exe /a /b}).should == 'bar'
+        end
+      end
+
+      context "binary is not present" do
+        it "should not run the command if path to binary is absolute" do
+          Facter::Util::Resolution.expects(:expand_command).with(%q{C:\Windows\foo.exe /a /b}).returns nil
+          Facter::Util::Resolution.expects(:`).with(%q{C:\Windows\foo.exe /a /b}).never
+          Facter::Util::Resolution.exec(%q{C:\Windows\foo.exe /a /b}).should be_nil
+        end
+        it "should try to run the command and return output of a shell-builtin" do
+          Facter::Util::Resolution.expects(:expand_command).with(%q{echo foo}).returns nil
+          Facter::Util::Resolution.expects(:`).with(%q{echo foo}).returns 'foo'
+          Facter.expects(:warnonce).with('Using Facter::Util::Resolution.exec with a shell built-in is deprecated. Most built-ins can be replaced with native ruby commands. If you really have to run a built-in, pass "cmd /c your_builtin" as a command')
+          Facter::Util::Resolution.exec(%q{echo foo}).should == 'foo'
+        end
+        it "should try to run the command and return nil if not shell-builtin" do
+          Facter::Util::Resolution.expects(:expand_command).with(%q{echo foo}).returns nil
+          Facter::Util::Resolution.stubs(:`).with(%q{echo foo}).raises Errno::ENOENT, 'some_error_message'
+          Facter.expects(:warnonce).never
+          Facter::Util::Resolution.exec(%q{echo foo}).should be_nil
+        end
+      end
     end
   end
 end