facter 1.6.18 → 1.7.0.rc1

data/spec/unit/util/macosx_spec.rb

@@ -4,15 +4,46 @@ require 'spec_helper'
 require 'facter/util/macosx'
 
 describe Facter::Util::Macosx do
+  let(:badplist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+    <!DOCTYPE plist PUBLIC -//Apple Computer//DTD PLIST 1.0//EN http://www.apple.com/DTDs/PropertyList-1.0.dtd>
+    <plist version="1.0">
+      <dict>
+          <key>test</key>
+              <string>file</string>
+                </dict>
+                </plist>'
+  end
+
+  let(:goodplist) do
+    '<?xml version="1.0" encoding="UTF-8"?>
+    <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+    <plist version="1.0">
+    <dict>
+      <key>test</key>
+        <string>file</string>
+        </dict>
+        </plist>'
+  end
+
   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 correct a bad XML doctype string' do
+    Facter.expects(:debug).with('Had to fix plist with incorrect DOCTYPE declaration')
+    Facter::Util::Macosx.intern_xml(badplist)
+  end
+
+  it 'should return a hash given XML data' do
+    test_hash = { 'test' => 'file' }
+    Facter::Util::Macosx.intern_xml(goodplist).should == test_hash
+  end
 
-    Facter::Util::Macosx.intern_xml("foo").should == "bar"
+  it 'should fail when trying to read invalid XML' do
+    expect { Facter::Util::Macosx.intern_xml('<bad}|%-->xml<--->') }.to \
+      raise_error(RuntimeError, /A plist file could not be properly read by Facter::Util::CFPropertyList/)
   end
 
   describe "when collecting profiler data" do
@@ -43,19 +74,19 @@ describe Facter::Util::Macosx 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",
@@ -64,14 +95,14 @@ describe Facter::Util::Macosx do
                                                         "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"

data/spec/unit/util/manufacturer_spec.rb

@@ -34,8 +34,9 @@ describe Facter::Manufacturer do
   it "should not set manufacturer 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.fact(:hardwareisa).stubs(:value).returns("sparc")
 
-    Facter::Util::Resolution.stubs(:exec).returns(nil)
+    Facter::Util::Resolution.stubs(:exec).with(regexp_matches(/prtdiag/)).returns(nil)
     Facter::Manufacturer.prtdiag_sparc_find_system_info()
     Facter.value(:manufacturer).should_not == "Sun Microsystems"
   end
@@ -122,6 +123,16 @@ Handle 0x001F
     Facter.value(:ramlocation).should == "System Board Or Motherboard"
   end
 
+  it "should return an appropriate uuid on linux" do
+    Facter.fact(:kernel).stubs(:value).returns("Linux")
+    dmidecode = my_fixture_read("intel_linux_dmidecode")
+    Facter::Manufacturer.expects(:get_dmi_table).returns(dmidecode)
+   
+    query = { '[Ss]ystem [Ii]nformation' => [ { 'UUID:' => 'uuid' } ] }
+    Facter::Manufacturer.dmi_find_system_info(query)
+    Facter.value(:uuid).should == "60A98BB3-95B6-E111-AF74-4C72B9247D28"
+  end
+
   def find_product_name(os)
     output_file = case os
       when "FreeBSD" then my_fixture("freebsd_dmidecode")

data/spec/unit/util/parser_spec.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+require 'facter/util/parser'
+require 'tempfile'
+require 'tmpdir.rb'
+
+describe Facter::Util::Parser do
+  include PuppetlabsSpec::Files
+
+  describe "extension_matches? function" do
+    it "should match extensions when subclass uses match_extension" do
+      Facter::Util::Parser.extension_matches?("myfile.foobar", "foobar").should == true
+    end
+
+    it "should match extensions when subclass uses match_extension with an array" do
+      Facter::Util::Parser.extension_matches?("myfile.ext1", ["ext1","ext2","ext3"]).should == true
+      Facter::Util::Parser.extension_matches?("myfile.ext2", ["ext1","ext2","ext3"]).should == true
+      Facter::Util::Parser.extension_matches?("myfile.ext3", ["ext1","ext2","ext3"]).should == true
+    end
+
+    it "should match extension ignoring case on file" do
+      Facter::Util::Parser.extension_matches?("myfile.EXT1", "ext1").should == true
+      Facter::Util::Parser.extension_matches?("myfile.ExT1", "ext1").should == true
+      Facter::Util::Parser.extension_matches?("myfile.exT1", "ext1").should == true
+    end
+
+    it "should match extension ignoring case for match_extension" do
+      Facter::Util::Parser.extension_matches?("myfile.EXT1", "EXT1").should == true
+      Facter::Util::Parser.extension_matches?("myfile.ExT1", "EXT1").should == true
+      Facter::Util::Parser.extension_matches?("myfile.exT1", "EXT1").should == true
+    end
+  end
+
+  let(:data) do {"one" => "two", "three" => "four"} end
+
+  describe "yaml" do
+    let(:data_in_yaml) do YAML.dump(data) end
+    let(:data_file) do "/tmp/foo.yaml" end
+
+    it "should return a hash of whatever is stored on disk" do
+      File.stubs(:read).with(data_file).returns(data_in_yaml)
+      described_class.parser_for(data_file).results.should == data
+    end
+
+    it "should handle exceptions and warn" do
+      # YAML data with an error
+      File.stubs(:read).with(data_file).returns(data_in_yaml + "}")
+      Facter.expects(:warn).at_least_once
+      lambda { Facter::Util::Parser.parser_for(data_file).results }.should_not raise_error
+    end
+  end
+
+  describe "json" do
+    let(:data_in_json) do JSON.dump(data) end
+    let(:data_file) do "/tmp/foo.json" end
+
+    it "should return a hash of whatever is stored on disk" do
+      pending("this test requires the json library") unless Facter.json?
+      File.stubs(:read).with(data_file).returns(data_in_json)
+      Facter::Util::Parser.parser_for(data_file).results.should == data
+    end
+  end
+
+  describe "txt" do
+    let(:data_file) do "/tmp/foo.txt" end
+
+    shared_examples_for "txt parser" do
+      it "should return a hash of whatever is stored on disk" do
+        File.stubs(:read).with(data_file).returns(data_in_txt)
+        Facter::Util::Parser.parser_for(data_file).results.should == data
+      end
+    end
+
+    context "well formed data" do
+      let(:data_in_txt) do "one=two\nthree=four\n" end
+      it_behaves_like "txt parser"
+    end
+    
+    context "extra equal sign" do
+      let(:data_in_txt) do "one=two\nthree=four=five\n" end
+      let(:data) do {"one" => "two", "three" => "four=five"} end
+      it_behaves_like "txt parser"
+    end
+
+    context "extra data" do
+      let(:data_in_txt) do "one=two\nfive\nthree=four\n" end
+      it_behaves_like "txt parser"
+    end
+  end
+
+  describe "scripts" do
+    let :cmd do "/tmp/foo.sh" end
+    let :data_in_txt do "one=two\nthree=four\n" end
+
+    before :each do
+      Facter::Util::Resolution.stubs(:exec).with(cmd).returns(data_in_txt)
+      File.stubs(:executable?).with(cmd).returns(true)
+    end
+
+    it "should return a hash of whatever is returned by the executable" do
+      pending("this test does not run on windows") if Facter::Util::Config.is_windows?
+      File.stubs(:file?).with(cmd).returns(true)
+      Facter::Util::Parser.parser_for(cmd).results.should == data
+    end
+
+    it "should not parse a directory" do
+      File.stubs(:file?).with(cmd).returns(false)
+      Facter::Util::Parser.parser_for(cmd).results.should be_nil
+    end
+
+    context "on Windows" do
+      let :cmd do "/tmp/foo.bat" end
+
+      before :each do
+        Facter::Util::Config.stubs(:is_windows?).returns(true)
+      end
+
+      let :parser do
+        Facter::Util::Parser.parser_for(cmd)
+      end
+
+      it "should return no results" do
+        parser.results.should be_nil
+      end
+    end
+  end
+
+  describe "nothing parser" do
+    it "uses the nothing parser when there is no other parser" do
+      Facter::Util::Parser.parser_for("this.is.not.valid").results.should be_nil
+    end
+  end
+end

data/spec/unit/util/resolution_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'facter/util/resolution'
 
 describe Facter::Util::Resolution do
+  include FacterSpec::ConfigHelper
+
   it "should require a name" do
     lambda { Facter::Util::Resolution.new }.should raise_error(ArgumentError)
   end
@@ -12,6 +14,12 @@ describe Facter::Util::Resolution do
     Facter::Util::Resolution.new("yay").name.should == "yay"
   end
 
+  it "should be able to set the value" do
+    resolve = Facter::Util::Resolution.new("yay")
+    resolve.value = "foo"
+    resolve.value.should == "foo"
+  end
+
   it "should have a method for setting the weight" do
     Facter::Util::Resolution.new("yay").should respond_to(:has_weight)
   end
@@ -43,6 +51,66 @@ describe Facter::Util::Resolution do
     res.limit.should == "testing"
   end
 
+
+  describe "when overriding environment variables" do
+    it "should execute the caller's block with the specified env vars" do
+      test_env = { "LANG" => "C", "FOO" => "BAR" }
+      Facter::Util::Resolution.with_env test_env do
+        test_env.keys.each do |key|
+          ENV[key].should == test_env[key]
+        end
+      end
+    end
+
+    it "should restore pre-existing environment variables to their previous values" do
+      orig_env = {}
+      new_env = {}
+      # an arbitrary sentinel value to use to temporarily set the environment vars to
+      sentinel_value = "Abracadabra"
+
+      # grab some values from the existing ENV (arbitrarily choosing 3 here)
+      ENV.keys.first(3).each do |key|
+        # save the original values so that we can test against them later
+        orig_env[key] = ENV[key]
+        # create bogus temp values for the chosen keys
+        new_env[key] = sentinel_value
+      end
+
+      # verify that, during the 'with_env', the new values are used
+      Facter::Util::Resolution.with_env new_env do
+        orig_env.keys.each do |key|
+          ENV[key].should == new_env[key]
+        end
+      end
+
+      # verify that, after the 'with_env', the old values are restored
+      orig_env.keys.each do |key|
+        ENV[key].should == orig_env[key]
+      end
+    end
+
+    it "should not be affected by a 'return' statement in the yield block" do
+      @sentinel_var = :resolution_test_foo.to_s
+
+      # the intent of this test case is to test a yield block that contains a return statement.  However, it's illegal
+      # to use a return statement outside of a method, so we need to create one here to give scope to the 'return'
+      def handy_method()
+        ENV[@sentinel_var] = "foo"
+        new_env = { @sentinel_var => "bar" }
+
+        Facter::Util::Resolution.with_env new_env do
+          ENV[@sentinel_var].should == "bar"
+          return
+        end
+      end
+
+      handy_method()
+
+      ENV[@sentinel_var].should == "foo"
+
+    end
+  end
+
   describe "when setting the code" do
     before do
       Facter.stubs(:warnonce)
@@ -87,6 +155,27 @@ describe Facter::Util::Resolution do
     end
   end
 
+  describe 'callbacks when flushing facts' do
+    class FlushFakeError < StandardError; end
+
+    subject do
+      Facter::Util::Resolution.new("jeff")
+    end
+
+    context '#on_flush' do
+      it 'accepts a block with on_flush' do
+        subject.on_flush() { raise NotImplementedError }
+      end
+    end
+
+    context '#flush' do
+      it 'calls the block passed to on_flush' do
+        subject.on_flush() { raise FlushFakeError }
+        expect { subject.flush }.to raise_error FlushFakeError
+      end
+    end
+  end
+
   it "should be able to return a value" do
     Facter::Util::Resolution.new("yay").should respond_to(:value)
   end
@@ -96,6 +185,11 @@ describe Facter::Util::Resolution do
       @resolve = Facter::Util::Resolution.new("yay")
     end
 
+    it "should return any value that has been provided" do
+      @resolve.value = "foo"
+      @resolve.value.should == "foo"
+    end
+
     describe "and setcode has not been called" do
       it "should return nil" do
         Facter::Util::Resolution.expects(:exec).with(nil, nil).never
@@ -106,7 +200,7 @@ describe Facter::Util::Resolution do
     describe "and the code is a string" do
       describe "on windows" do
         before do
-          Facter::Util::Config.stubs(:is_windows?).returns(true)
+          given_a_configuration_of(:is_windows => true)
         end
 
         it "should return the result of executing the code" do
@@ -125,7 +219,7 @@ describe Facter::Util::Resolution do
 
       describe "on non-windows systems" do
         before do
-          Facter::Util::Config.stubs(:is_windows?).returns(false)
+          given_a_configuration_of(:is_windows => false)
         end
 
         it "should return the result of executing the code" do
@@ -490,14 +584,52 @@ describe Facter::Util::Resolution do
 
   # It's not possible, AFAICT, to mock %x{}, so I can't really test this bit.
   describe "when executing code" do
+    # set up some command strings, making sure we get the right version for both unix and windows
+    echo_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c "echo foo"' : 'echo foo'
+    echo_env_var_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c "echo %%%s%%"' : 'echo $%s'
+
     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
 
+    # execute a simple echo command
     it "should execute the binary" do
-      test_command = Facter::Util::Config.is_windows? ? 'cmd.exe /c echo foo' : 'echo foo'
-      Facter::Util::Resolution.exec(test_command).should == "foo"
+      Facter::Util::Resolution.exec(echo_command).should == "foo"
+    end
+
+    it "should override the LANG environment variable" do
+      Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
+    end
+
+    it "should respect other overridden environment variables" do
+      Facter::Util::Resolution.with_env( {"FOO" => "foo"} ) do
+        Facter::Util::Resolution.exec(echo_env_var_command % 'FOO').should == "foo"
+      end
+    end
+
+    it "should restore overridden LANG environment variable after execution" do
+      # we're going to call with_env in a nested fashion, to make sure that the environment gets restored properly
+      # at each level
+      Facter::Util::Resolution.with_env( {"LANG" => "foo"} ) do
+        # Resolution.exec always overrides 'LANG' for its own execution scope
+        Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
+        # But after 'exec' completes, we should see our value restored
+        ENV['LANG'].should == "foo"
+        # Now we'll do a nested call to with_env
+        Facter::Util::Resolution.with_env( {"LANG" => "bar"} ) do
+          # During 'exec' it should still be 'C'
+          Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
+          # After exec it should be restored to our current value for this level of the nesting...
+          ENV['LANG'].should == "bar"
+        end
+        # Now we've dropped out of one level of nesting,
+        ENV['LANG'].should == "foo"
+        # Call exec one more time just for kicks
+        Facter::Util::Resolution.exec(echo_env_var_command % 'LANG').should == "C"
+        # One last check at our current nesting level.
+        ENV['LANG'].should == "foo"
+      end
     end
 
     context "when run on unix", :as_platform => :posix  do