facter 2.0.1.rc1-universal-darwin

data/spec/unit/util/loader_spec.rb

@@ -0,0 +1,286 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/loader'
+
+describe Facter::Util::Loader do
+  before :each do
+    Facter::Util::Loader.any_instance.unstub(:load_all)
+  end
+
+  def loader_from(places)
+    env = places[:env] || {}
+    search_path = places[:search_path] || []
+    loader = Facter::Util::Loader.new(env)
+    loader.stubs(:search_path).returns search_path
+    loader
+  end
+
+  it "should have a method for loading individual facts by name" do
+    Facter::Util::Loader.new.should respond_to(:load)
+  end
+
+  it "should have a method for loading all facts" do
+    Facter::Util::Loader.new.should respond_to(:load_all)
+  end
+
+  it "should have a method for returning directories containing facts" do
+    Facter::Util::Loader.new.should respond_to(:search_path)
+  end
+
+  describe "#valid_seach_path?" do
+    let(:loader) { Facter::Util::Loader.new }
+
+    # Used to have test for " " as a directory since that should
+    # be a relative directory, but on Windows in both 1.8.7 and
+    # 1.9.3 it is an absolute directory (WTF Windows). Considering
+    # we didn't have a valid use case for a " " directory, the
+    # test was removed.
+
+    [
+      '.',
+      '..',
+      '...',
+      '.foo',
+      '../foo',
+      'foo',
+      'foo/bar',
+      'foo/../bar',
+      ' /',
+      ' \/',
+    ].each do |dir|
+      it "should be false for relative path #{dir}" do
+        loader.should_not be_valid_search_path dir
+      end
+    end
+    [
+      '/.',
+      '/..',
+      '/...',
+      '/.foo',
+      '/../foo',
+      '/foo',
+      '/foo/bar',
+      '/foo/../bar',
+      '/ ',
+      '/ /..',
+    ].each do |dir|
+      it "should be true for absolute path #{dir}" do
+        loader.should be_valid_search_path dir
+      end
+    end
+  end
+
+  describe "when determining the search path" do
+    let(:loader) { Facter::Util::Loader.new }
+
+    it "should include the facter subdirectory of all paths in ruby LOAD_PATH" do
+      dirs = $LOAD_PATH.collect { |d| File.expand_path('facter', d) }
+      loader.stubs(:valid_search_path?).returns(true)
+      File.stubs(:directory?).returns true
+
+      paths = loader.search_path
+
+      dirs.each do |dir|
+        paths.should be_include(dir)
+      end
+    end
+
+    it "should exclude invalid search paths" do
+      dirs = $LOAD_PATH.collect { |d| File.join(d, "facter") }
+      loader.stubs(:valid_search_path?).returns(false)
+      paths = loader.search_path
+      dirs.each do |dir|
+        paths.should_not be_include(dir)
+      end
+    end
+
+    it "should include all search paths registered with Facter" do
+      Facter.expects(:search_path).returns %w{/one /two}
+      loader.stubs(:valid_search_path?).returns true
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+      File.stubs(:directory?).with('/two').returns true
+
+      paths = loader.search_path
+      paths.should be_include("/one")
+      paths.should be_include("/two")
+    end
+
+    it "should warn on invalid search paths registered with Facter" do
+      Facter.expects(:search_path).returns %w{/one two/three}
+      loader.stubs(:valid_search_path?).returns false
+      loader.stubs(:valid_search_path?).with('/one').returns true
+      loader.stubs(:valid_search_path?).with('two/three').returns false
+      Facter.expects(:warn).with('Excluding two/three from search path. Fact file paths must be an absolute directory').once
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+
+      paths = loader.search_path
+      paths.should be_include("/one")
+      paths.should_not be_include("two/three")
+    end
+
+    it "should strip paths that are valid paths but not are not present" do
+      Facter.expects(:search_path).returns %w{/one /two}
+      loader.stubs(:valid_search_path?).returns false
+      loader.stubs(:valid_search_path?).with('/one').returns true
+      loader.stubs(:valid_search_path?).with('/two').returns true
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one').returns true
+      File.stubs(:directory?).with('/two').returns false
+
+      paths = loader.search_path
+      paths.should be_include("/one")
+      paths.should_not be_include('/two')
+    end
+
+    describe "and the FACTERLIB environment variable is set" do
+      it "should include all paths in FACTERLIB" do
+        loader = Facter::Util::Loader.new("FACTERLIB" => "/one/path#{File::PATH_SEPARATOR}/two/path")
+
+      File.stubs(:directory?).returns false
+      File.stubs(:directory?).with('/one/path').returns true
+      File.stubs(:directory?).with('/two/path').returns true
+
+        loader.stubs(:valid_search_path?).returns true
+        paths = loader.search_path
+        %w{/one/path /two/path}.each do |dir|
+          paths.should be_include(dir)
+        end
+      end
+    end
+  end
+
+  describe "when loading facts" do
+    it "should load values from the matching environment variable if one is present" do
+      loader = loader_from(:env => { "facter_testing" => "yayness" })
+
+      Facter.expects(:add).with("testing")
+
+      loader.load(:testing)
+    end
+
+    it "should load any files in the search path with names matching the fact name" do
+      loader = loader_from(:search_path => %w{/one/dir /two/dir})
+
+      loader.expects(:search_path).returns %w{/one/dir /two/dir}
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns true
+
+      Kernel.expects(:load).with("/one/dir/testing.rb")
+
+      loader.load(:testing)
+    end
+
+    it 'should not load any ruby files from subdirectories matching the fact name in the search path' do
+      loader = Facter::Util::Loader.new
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns true
+      Kernel.expects(:load).with("/one/dir/testing.rb")
+
+      File.stubs(:directory?).with("/one/dir/testing").returns true
+      loader.stubs(:search_path).returns %w{/one/dir}
+
+      Dir.stubs(:entries).with("/one/dir/testing").returns %w{foo.rb bar.rb}
+      %w{/one/dir/testing/foo.rb /one/dir/testing/bar.rb}.each do |f|
+        File.stubs(:directory?).with(f).returns false
+        Kernel.stubs(:load).with(f)
+      end
+
+      loader.load(:testing)
+    end
+
+    it "should not load files that don't end in '.rb'" do
+      loader = Facter::Util::Loader.new
+      loader.expects(:search_path).returns %w{/one/dir}
+      File.stubs(:file?).returns false
+      File.expects(:file?).with("/one/dir/testing.rb").returns false
+      File.expects(:exist?).with("/one/dir/testing").never
+      Kernel.expects(:load).never
+
+      loader.load(:testing)
+    end
+  end
+
+  describe "when loading all facts" do
+    let(:loader) { Facter::Util::Loader.new }
+
+    before :each do
+      loader.stubs(:search_path).returns []
+
+      File.stubs(:directory?).returns true
+    end
+
+    it "should load all files in all search paths" do
+      loader = loader_from(:search_path => %w{/one/dir /two/dir})
+
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb /one/dir/b.rb}
+      Dir.expects(:glob).with('/two/dir/*.rb').returns %w{/two/dir/c.rb /two/dir/d.rb}
+
+      %w{/one/dir/a.rb /one/dir/b.rb /two/dir/c.rb /two/dir/d.rb}.each do |f|
+        File.expects(:file?).with(f).returns true
+        Kernel.expects(:load).with(f)
+      end
+
+      loader.load_all
+    end
+
+    it "should not try to load subdirectories of search paths" do
+      loader.expects(:search_path).returns %w{/one/dir /two/dir}
+
+      # a.rb is a directory
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb /one/dir/b.rb}
+      File.expects(:file?).with('/one/dir/a.rb').returns false
+      File.expects(:file?).with('/one/dir/b.rb').returns true
+      Kernel.expects(:load).with('/one/dir/b.rb')
+
+      # c.rb is a directory
+      Dir.expects(:glob).with('/two/dir/*.rb').returns %w{/two/dir/c.rb /two/dir/d.rb}
+      File.expects(:file?).with('/two/dir/c.rb').returns false
+      File.expects(:file?).with('/two/dir/d.rb').returns true
+      Kernel.expects(:load).with('/two/dir/d.rb')
+
+      loader.load_all
+    end
+
+    it "should not raise an exception when a file is unloadable" do
+      loader.expects(:search_path).returns %w{/one/dir}
+
+      Dir.expects(:glob).with('/one/dir/*.rb').returns %w{/one/dir/a.rb}
+      File.expects(:file?).with('/one/dir/a.rb').returns true
+
+      Kernel.expects(:load).with("/one/dir/a.rb").raises(LoadError)
+      Facter.expects(:warn)
+
+      expect { loader.load_all }.to_not raise_error
+    end
+
+    it "should load all facts from the environment" do
+      Facter::Util::Resolution.with_env "facter_one" => "yayness", "facter_two" => "boo" do
+        loader.load_all
+      end
+      Facter.value(:one).should == 'yayness'
+      Facter.value(:two).should == 'boo'
+    end
+
+    it "should only load all facts one time" do
+      loader = loader_from(:env => {})
+      loader.expects(:load_env).once
+
+      loader.load_all
+      loader.load_all
+    end
+  end
+
+  it "should load facts on the facter search path only once" do
+    facterlibdir = File.expand_path(File.dirname(__FILE__) + '../../../fixtures/unit/util/loader')
+
+    Facter::Util::Loader.new('FACTERLIB' => facterlibdir).load_all
+
+    Facter.value(:nosuchfact).should be_nil
+  end
+end

data/spec/unit/util/macaddress_spec.rb

@@ -0,0 +1,141 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'facter/util/macaddress'
+
+describe "standardized MAC address" do
+  it "should have zeroes added if missing" do
+    Facter::Util::Macaddress::standardize("0:ab:cd:e:12:3").should == "00:ab:cd:0e:12:03"
+  end
+
+  it "should be identical if each octet already has two digits" do
+    Facter::Util::Macaddress::standardize("00:ab:cd:0e:12:03").should == "00:ab:cd:0e:12:03"
+  end
+
+  it "should be nil if input is nil" do
+    proc { result = Facter::Util::Macaddress.standardize(nil) }.should_not raise_error
+    Facter::Util::Macaddress.standardize(nil).should be_nil
+  end
+end
+
+describe "Darwin", :unless => Facter::Util::Config.is_windows? do
+  test_cases = [
+    # version,           iface, real macaddress,     fallback macaddress
+    ["9.8.0",            'en0', "00:17:f2:06:e4:2e", "00:17:f2:06:e4:2e"],
+    ["10.3.0",           'en0', "00:17:f2:06:e3:c2", "00:17:f2:06:e3:c2"],
+    ["10.6.4",           'en1', "58:b0:35:7f:25:b3", "58:b0:35:fa:08:b1"],
+    ["10.6.6_dualstack", "en1", "00:25:00:48:19:ef", "00:25:4b:ca:56:72"]
+  ]
+
+  test_cases.each do |version, default_iface, macaddress, fallback_macaddress|
+    netstat_file = fixtures("netstat", "darwin_#{version.tr('.', '_')}")
+    ifconfig_file_no_iface = fixtures("ifconfig", "darwin_#{version.tr('.', '_')}")
+    ifconfig_file = "#{ifconfig_file_no_iface}_#{default_iface}"
+
+    describe "version #{version}" do
+      describe Facter::Util::Macaddress::Darwin do
+        describe ".default_interface" do
+          describe "when netstat has a default interface" do
+            before do
+              Facter::Util::Macaddress::Darwin.stubs(:netstat_command).returns("cat \"#{netstat_file}\"")
+            end
+
+            it "should return the default interface name" do
+              Facter::Util::Macaddress::Darwin.default_interface.should == default_iface
+            end
+          end
+        end
+
+        describe ".macaddress" do
+          describe "when netstat has a default interface" do
+            before do
+              Facter.stubs(:warn)
+              Facter::Util::Macaddress::Darwin.stubs(:default_interface).returns('')
+              Facter::Util::Macaddress::Darwin.stubs(:ifconfig_command).returns("cat \"#{ifconfig_file}\"")
+            end
+
+            it "should return the macaddress of the default interface" do
+              Facter::Util::Macaddress::Darwin.macaddress.should == macaddress
+            end
+          end
+
+          describe "when netstat does not have a default interface" do
+            before do
+              Facter::Util::Macaddress::Darwin.stubs(:default_interface).returns("")
+              Facter::Util::Macaddress::Darwin.stubs(:ifconfig_command).returns("cat \"#{ifconfig_file_no_iface}\"")
+            end
+
+            it "should warn about the lack of default" do
+              Facter.expects(:warn).with("Could not find a default route. Using first non-loopback interface")
+              Facter::Util::Macaddress::Darwin.macaddress
+            end
+
+            it "should return the macaddress of the first non-loopback interface" do
+              Facter.expects(:warn).with("Could not find a default route. Using first non-loopback interface")
+              Facter::Util::Macaddress::Darwin.macaddress.should == fallback_macaddress
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+describe "The macaddress fact" do
+  context "on Windows" do
+    require 'facter/util/wmi'
+    require 'facter/util/registry'
+    require 'facter_spec/windows_network'
+
+    include FacterSpec::WindowsNetwork
+
+    before :each do
+      Facter.fact(:kernel).stubs(:value).returns('windows')
+      Facter::Util::Registry.stubs(:hklm_read).returns(nic_bindings)
+    end
+
+    describe "when you have no active network adapter" do
+      it "should return nil if there are no active (or any) network adapters" do
+        Facter::Util::WMI.expects(:execquery).returns([])
+
+        Facter.value(:macaddress).should == nil
+      end
+    end
+
+    describe "when you have one network adapter" do
+      it "should return properly" do
+        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
+        Facter::Util::WMI.expects(:execquery).returns([nic])
+
+        Facter.value(:macaddress).should == macAddress0
+      end
+    end
+
+    describe "when you have more than one network adapter" do
+      it "should return the macaddress of the adapter with the lowest IP connection metric (best connection)" do
+        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+        nics[:nic1].expects(:IPConnectionMetric).returns(5)
+        Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+        Facter.value(:macaddress).should == macAddress1
+      end
+
+      context "when the IP connection metric is the same" do
+        it "should return the macaddress of the adapter with the lowest binding order" do
+          nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+          Facter::Util::WMI.expects(:execquery).returns(nics.values)
+
+          Facter.value(:macaddress).should == macAddress0
+        end
+
+        it "should return the macaddress of the adapter with the lowest MACAddress when multiple adapters have the same IP connection metric when the lowest MACAddress is not first" do
+          nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
+          Facter::Util::WMI.expects(:execquery).returns(nics.values)
+          Facter::Util::Registry.stubs(:hklm_read).returns(["\\Device\\#{settingId1}", "\\Device\\#{settingId0}" ])
+
+          Facter.value(:macaddress).should == macAddress1
+        end
+      end
+    end
+  end
+end

data/spec/unit/util/macosx_spec.rb

@@ -0,0 +1,113 @@
+#! /usr/bin/env ruby
+
+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::Core::Execution.expects(:exec).with("/usr/sbin/system_profiler -xml foo").returns "yay"
+    Facter::Util::Macosx.profiler_xml("foo").should == "yay"
+  end
+
+  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
+
+  it 'should fail when trying to read invalid XML' do
+    STDERR.stubs(:<<)
+    expect {
+      Facter::Util::Macosx.intern_xml('<bad}|%-->xml<--->')
+    }.to raise_error(RuntimeError, /A plist file could not be properly read by CFPropertyList/)
+  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 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 '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
+
+    before do
+      Facter::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productName").returns "Mac OS X"
+      Facter::Core::Execution.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::Core::Execution.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::Core::Execution.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::Core::Execution.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::Core::Execution.expects(:exec).with("/usr/bin/sw_vers -productVersion").returns "2.3"
+      Facter::Util::Macosx.sw_vers["macosx_productversion_minor"].should == "0"
+    end
+  end
+end