facter 2.5.7-x64-mingw32 → 3.9.6.cfacter.20180412-x64-mingw32

data/spec/unit/util/loader_spec.rb

@@ -1,286 +0,0 @@
-#! /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
-    loader = loader_from(:env => {})
-    loader.load_all
-
-    loader.expects(:kernel_load).with(regexp_matches(/ec2/)).never
-    loader.load(:ec2)
-  end
-end

data/spec/unit/util/macaddress_spec.rb

@@ -1,143 +0,0 @@
-#! /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.fact(:operatingsystem).stubs(:value).returns('windows')
-      Facter.fact(:osfamily).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

@@ -1,114 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/config'
-require 'facter/util/macosx' unless Facter::Util::Config.is_windows?
-
-describe "Facter::Util::Macosx", :unless => Facter::Util::Config.is_windows? 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 2>/dev/null").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