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

data/spec/unit/util/config_spec.rb

@@ -1,120 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe Facter::Util::Config do
-  include PuppetlabsSpec::Files
-
-  describe "ENV['HOME'] is unset", :unless => Facter::Util::Root.root? do
-    around do |example|
-      Facter::Core::Execution.with_env('HOME' => nil) do
-        example.run
-      end
-    end
-
-    it "should not set @external_facts_dirs" do
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      Facter::Util::Config.external_facts_dirs.should be_empty
-    end
-  end
-
-  describe "is_windows? function" do
-    it "should detect windows if Ruby RbConfig::CONFIG['host_os'] returns a windows OS" do
-      host_os = ["mswin","win32","dos","mingw","cygwin"]
-      host_os.each do |h|
-        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
-        Facter::Util::Config.is_windows?.should be_true
-      end
-    end
-
-    it "should not detect windows if Ruby RbConfig::CONFIG['host_os'] returns a non-windows OS" do
-      host_os = ["darwin","linux"]
-      host_os.each do |h|
-        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
-        Facter::Util::Config.is_windows?.should be_false
-      end
-    end
-  end
-
-  describe "is_mac? function" do
-    it "should detect mac if Ruby RbConfig::CONFIG['host_os'] returns darwin" do
-      host_os = ["darwin"]
-      host_os.each do |h|
-        RbConfig::CONFIG.stubs(:[]).with('host_os').returns(h)
-        Facter::Util::Config.is_mac?.should be_true
-      end
-    end
-  end
-
-  describe "external_facts_dirs" do
-    before :each do
-      Facter::Util::Root.stubs(:root?).returns(true)
-    end
-
-    it "should return the default value for linux" do
-      Facter::Util::Config.stubs(:is_windows?).returns(false)
-      Facter::Util::Config.stubs(:windows_data_dir).returns(nil)
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      Facter::Util::Config.external_facts_dirs.should == ["/opt/puppetlabs/facter/facts.d", "/etc/facter/facts.d", "/etc/puppetlabs/facter/facts.d"]
-    end
-
-    it "should return the default value for windows 2008" do
-      Facter::Util::Config.stubs(:is_windows?).returns(true)
-      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\ProgramData")
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\ProgramData", 'PuppetLabs', 'facter', 'facts.d')]
-    end
-
-    it "should return the default value for windows 2003R2" do
-      Facter::Util::Config.stubs(:is_windows?).returns(true)
-      Facter::Util::Config.stubs(:windows_data_dir).returns("C:\\Documents")
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      Facter::Util::Config.external_facts_dirs.should == [File.join("C:\\Documents", 'PuppetLabs', 'facter', 'facts.d')]
-    end
-
-    it "returns the old and new (AIO) paths under user's home directory when not root" do
-      Facter::Util::Root.stubs(:root?).returns(false)
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      Facter::Util::Config.external_facts_dirs.should == [File.expand_path(File.join("~", ".puppetlabs", "opt", "facter", "facts.d")),
-                                                          File.expand_path(File.join("~", ".facter", "facts.d"))]
-    end
-
-    it "includes additional values when user appends to the list" do
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      original_values = Facter::Util::Config.external_facts_dirs.dup
-      new_value = '/usr/share/newdir'
-      Facter::Util::Config.external_facts_dirs << new_value
-      Facter::Util::Config.external_facts_dirs.should == original_values + [new_value]
-    end
-
-    it "should only output new values when explicitly set" do
-      Facter::Util::Config.setup_default_ext_facts_dirs
-      new_value = ['/usr/share/newdir']
-      Facter::Util::Config.external_facts_dirs = new_value
-      Facter::Util::Config.external_facts_dirs.should == new_value
-    end
-
-  end
-
-  describe "override_binary_dir" do
-    it "should return the default value for linux" do
-      Facter::Util::Config.stubs(:is_windows?).returns(false)
-      Facter::Util::Config.setup_default_override_binary_dir
-      Facter::Util::Config.override_binary_dir.should == "/opt/puppetlabs/puppet/bin"
-    end
-
-    it "should return nil for windows" do
-      Facter::Util::Config.stubs(:is_windows?).returns(true)
-      Facter::Util::Config.setup_default_override_binary_dir
-      Facter::Util::Config.override_binary_dir.should == nil
-    end
-
-    it "should output new values when explicitly set" do
-      Facter::Util::Config.setup_default_override_binary_dir
-      new_value = '/usr/share/newdir'
-      Facter::Util::Config.override_binary_dir = new_value
-      Facter::Util::Config.override_binary_dir.should == new_value
-    end
-  end
-
-end

data/spec/unit/util/confine_spec.rb

@@ -1,148 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/confine'
-require 'facter/util/values'
-
-include Facter::Util::Values
-
-describe Facter::Util::Confine do
-  it "should require a fact name" do
-    Facter::Util::Confine.new("yay", true).fact.should == "yay"
-  end
-
-  it "should accept a value specified individually" do
-    Facter::Util::Confine.new("yay", "test").values.should == ["test"]
-  end
-
-  it "should accept multiple values specified at once" do
-    Facter::Util::Confine.new("yay", "test", "other").values.should == ["test", "other"]
-  end
-
-  it "should fail if no fact name is provided" do
-    lambda { Facter::Util::Confine.new(nil, :test) }.should raise_error(ArgumentError)
-  end
-
-  it "should fail if no values were provided" do
-    lambda { Facter::Util::Confine.new("yay") }.should raise_error(ArgumentError)
-  end
-
-  it "should have a method for testing whether it matches" do
-    Facter::Util::Confine.new("yay", :test).should respond_to(:true?)
-  end
-
-  describe "when evaluating" do
-    def confined(fact_value, *confines)
-      @fact.stubs(:value).returns fact_value
-      Facter::Util::Confine.new("yay", *confines).true?
-    end
-
-    before do
-      @fact = mock 'fact'
-      Facter.stubs(:[]).returns @fact
-    end
-
-    it "should return false if the fact does not exist" do
-      Facter.expects(:[]).with("yay").returns nil
-
-      Facter::Util::Confine.new("yay", "test").true?.should be_false
-    end
-
-    it "should use the returned fact to get the value" do
-      Facter.expects(:[]).with("yay").returns @fact
-
-      @fact.expects(:value).returns nil
-
-      Facter::Util::Confine.new("yay", "test").true?
-    end
-
-    it "should return false if the fact has no value" do
-      confined(nil, "test").should be_false
-    end
-
-    it "should return true if any of the provided values matches the fact's value" do
-      confined("two", "two").should be_true
-    end
-
-    it "should return true if any of the provided symbol values matches the fact's value" do
-      confined(:xy, :xy).should be_true
-    end
-
-    it "should return true if any of the provided integer values matches the fact's value" do
-      confined(1, 1).should be_true
-    end
-
-    it "should return true if any of the provided boolan values matches the fact's value" do
-      confined(true, true).should be_true
-    end
-
-    it "should return true if any of the provided array values matches the fact's value" do
-      confined([3,4], [3,4]).should be_true
-    end
-
-    it "should return true if any of the provided symbol values matches the fact's string value" do
-      confined(:one, "one").should be_true
-    end
-
-    it "should return true if any of the provided string values matches case-insensitive the fact's value" do
-      confined("four", "Four").should be_true
-    end
-
-    it "should return true if any of the provided symbol values matches case-insensitive the fact's string value" do
-      confined(:four, "Four").should be_true
-    end
-
-    it "should return true if any of the provided symbol values matches the fact's string value" do
-      confined("xy", :xy).should be_true
-    end
-
-    it "should return true if any of the provided regexp values matches the fact's string value" do
-      confined("abc", /abc/).should be_true
-    end
-
-    it "should return true if any of the provided ranges matches the fact's value" do
-      confined(6, (5..7)).should be_true
-    end
-
-    it "should return false if none of the provided values matches the fact's value" do
-      confined("three", "two", "four").should be_false
-    end
-
-    it "should return false if none of the provided integer values matches the fact's value" do
-      confined(2, 1, [3,4], (5..7)).should be_false
-    end
-
-    it "should return false if none of the provided boolan values matches the fact's value" do
-      confined(false, true).should be_false
-    end
-
-    it "should return false if none of the provided array values matches the fact's value" do
-      confined([1,2], [3,4]).should be_false
-    end
-
-    it "should return false if none of the provided ranges matches the fact's value" do
-      confined(8, (5..7)).should be_false
-    end
-
-    it "should accept and evaluate a block argument against the fact" do
-      @fact.expects(:value).returns 'foo'
-      confine = Facter::Util::Confine.new :yay do |f| f === 'foo' end
-      confine.true?.should be_true
-    end
-
-    it "should return false if the block raises a StandardError when checking a fact" do
-      @fact.stubs(:value).returns 'foo'
-      confine = Facter::Util::Confine.new :yay do |f| raise StandardError end
-      confine.true?.should be_false
-    end
-
-    it "should accept and evaluate only a block argument" do
-      Facter::Util::Confine.new { true }.true?.should be_true
-      Facter::Util::Confine.new { false }.true?.should be_false
-    end
-
-    it "should return false if the block raises a StandardError" do
-      Facter::Util::Confine.new { raise StandardError }.true?.should be_false
-    end
-  end
-end

data/spec/unit/util/dhcp_servers_spec.rb

@@ -1,63 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/dhcp_servers'
-
-describe Facter::Util::DHCPServers do
-
-  describe "retrieving the gateway device" do
-    it "returns nil when there are no default routes" do
-      Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route_nogw'))
-      described_class.gateway_device.should be_nil
-    end
-
-    it "returns the interface associated with the first default route" do
-      Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route'))
-      described_class.gateway_device.should eq "eth0"
-    end
-  end
-
-  describe "nmcli_version" do
-    {
-      'nmcli tool, version 0.9.8.0' => [0, 9, 8, 0],
-      'nmcli tool, version 0.9.8.10' => [0, 9, 8, 10],
-      'nmcli tool, version 0.9.8.9' => [0, 9, 8, 9],
-      'nmcli tool, version 0.9.9.0' => [0, 9, 9, 0],
-      'nmcli tool, version 0.9.9.9' => [0, 9, 9, 9],
-      'version 0.9.9.0-20.git20131003.fc20' => [0, 9, 9, 0],
-      'nmcli tool, version 0.9.9' => [0, 9, 9, 0],
-      'nmcli tool, version 0.9' => [0, 9, 0, 0],
-      'nmcli tool, version 1' => [1, 0, 0, 0]
-    }.each do |version, expected|
-      it "should turn #{version} into the integer #{expected}" do
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
-        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns(version)
-        
-        result = Facter::Util::DHCPServers.nmcli_version
-        result.is_a?(Array).should be true
-        result.should == expected
-      end
-    end
-  end
-
-  describe "device_dhcp_server" do
-    {
-        '0.1.2.3' => false,
-        '0.9.8.10' => false,
-        '0.9.9.0' => true,
-        '0.9.10.0' => true,
-        '0.10.0.0' => true,
-        '1.0.0.0' => true
-    }.each do |version, uses_show|
-      it "should use #{if uses_show then 'show' else 'list' end} for version #{version}" do
-        command = if uses_show then 'nmcli -f all d show eth0' else 'nmcli -f all d list iface eth0' end
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
-        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns "nmcli tool, version #{version}"
-        Facter::Core::Execution.stubs(:exec).with(command).returns 'DHCP4.OPTION[1]: dhcp_server_identifier = 192.168.1.1'
-        Facter::Util::DHCPServers.device_dhcp_server('eth0').should == '192.168.1.1'
-      end
-    end
-  end
-end
-
-

data/spec/unit/util/directory_loader_spec.rb

@@ -1,102 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-
-require 'facter/util/directory_loader'
-
-describe Facter::Util::DirectoryLoader do
-  include PuppetlabsSpec::Files
-  include FacterSpec::ConfigHelper
-
-  subject { Facter::Util::DirectoryLoader.new(tmpdir('directory_loader')) }
-  let(:collection) { Facter::Util::Collection.new(mock("internal loader"), subject) }
-
-  it "should make the directory available" do
-    subject.directory.should be_instance_of(String)
-  end
-
-  it "can be created with a given directory" do
-    Facter::Util::DirectoryLoader.loader_for("ext").directory.should == "ext"
-  end
-
-  it "raises an error when the directory does not exist" do
-    missing_dir = "missing"
-    File.stubs(:directory?).with(missing_dir).returns(false)
-    expect { Facter::Util::DirectoryLoader.loader_for(missing_dir) }.to raise_error Facter::Util::DirectoryLoader::NoSuchDirectoryError
-  end
-
-  it "should do nothing bad when dir doesn't exist" do
-    fakepath = "/foobar/path"
-    my_loader = Facter::Util::DirectoryLoader.new(fakepath)
-    FileTest.exists?(my_loader.directory).should be_false
-    expect { my_loader.load(collection) }.to_not raise_error
-   end
-
-  describe "when loading facts from disk" do
-    it "should be able to load files from disk and set facts" do
-      data = {"f1" => "one", "f2" => "two"}
-      write_to_file("data.yaml", YAML.dump(data))
-
-      subject.load(collection)
-
-      collection.value("f1").should == "one"
-      collection.value("f2").should == "two"
-    end
-
-    it "should ignore files that begin with '.'" do
-      not_to_be_used_collection = mock("collection should not be used")
-      not_to_be_used_collection.expects(:add).never
-
-      data = {"f1" => "one", "f2" => "two"}
-      write_to_file(".data.yaml", YAML.dump(data))
-
-      subject.load(not_to_be_used_collection)
-    end
-
-    %w{bak orig}.each do |ext|
-      it "should ignore files with an extension of '#{ext}'" do
-        Facter.expects(:warn).with(regexp_matches(/#{ext}/))
-        write_to_file("data" + ".#{ext}", "foo=bar")
-
-        subject.load(collection)
-      end
-    end
-
-    it "should warn when trying to parse unknown file types" do
-      write_to_file("file.unknownfiletype", "stuff=bar")
-
-      Facter.expects(:warn).with(regexp_matches(/file.unknownfiletype/))
-
-      subject.load(collection)
-    end
-
-    it "external facts should almost always precedence over all other facts" do
-      collection.add("f1", :value => "lower_weight_fact") { has_weight(Facter::Util::DirectoryLoader::EXTERNAL_FACT_WEIGHT - 1) }
-      data = {"f1" => "external_fact"}
-      write_to_file("data.yaml", YAML.dump(data))
-
-      subject.load(collection)
-
-      collection.value("f1").should == "external_fact"
-    end
-
-    describe "given a custom weight" do
-      subject { Facter::Util::DirectoryLoader.new(tmpdir('directory_loader'), 10) }
-
-      it "should set that weight for loaded external facts" do
-        collection.add("f1", :value => "higher_weight_fact") { has_weight(11) }
-        data = {"f1" => "external_fact"}
-        write_to_file("data.yaml", YAML.dump(data))
-
-        subject.load(collection)
-
-        collection.value("f1").should == "higher_weight_fact"
-      end
-    end
-  end
-
-  def write_to_file(file_name, to_write)
-    file = File.join(subject.directory, file_name)
-    File.open(file, "w") { |f| f.print to_write}
-  end
-end

data/spec/unit/util/ec2_spec.rb

@@ -1,184 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/ec2'
-
-describe Facter::Util::EC2 do
-  before do
-    # Squelch deprecation notices
-    Facter.stubs(:warnonce)
-  end
-  # This is the standard prefix for making an API call in EC2 (or fake)
-  # environments.
-  let(:api_prefix) { "http://169.254.169.254" }
-
-  describe "is_ec2_arp? method" do
-    describe "on linux" do
-      before :each do
-        # Return fake kernel
-        Facter.stubs(:value).with(:kernel).returns("linux")
-      end
-
-      it "should succeed if arp table contains fe:ff:ff:ff:ff:ff" do
-        ec2arp = my_fixture_read("linux-arp-ec2.out")
-        Facter::Core::Execution.expects(:exec).with("arp -an").\
-          at_least_once.returns(ec2arp)
-        Facter::Util::EC2.has_ec2_arp?.should == true
-      end
-
-      it "should succeed if arp table contains FE:FF:FF:FF:FF:FF" do
-        ec2arp = my_fixture_read("centos-arp-ec2.out")
-        Facter::Core::Execution.expects(:exec).with("arp -an").\
-          at_least_once.returns(ec2arp)
-        Facter::Util::EC2.has_ec2_arp?.should == true
-      end
-
-      it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
-        ec2arp = my_fixture_read("linux-arp-not-ec2.out")
-        Facter::Core::Execution.expects(:exec).with("arp -an").
-          at_least_once.returns(ec2arp)
-        Facter::Util::EC2.has_ec2_arp?.should == false
-      end
-    end
-
-    describe "on windows" do
-      before :each do
-        # Return fake kernel
-        Facter.stubs(:value).with(:kernel).returns("windows")
-      end
-
-      it "should succeed if arp table contains fe-ff-ff-ff-ff-ff" do
-        ec2arp = my_fixture_read("windows-2008-arp-a.out")
-        Facter::Core::Execution.expects(:exec).with("arp -a").\
-          at_least_once.returns(ec2arp)
-        Facter::Util::EC2.has_ec2_arp?.should == true
-      end
-
-      it "should fail if arp table does not contain fe-ff-ff-ff-ff-ff" do
-        ec2arp = my_fixture_read("windows-2008-arp-a-not-ec2.out")
-        Facter::Core::Execution.expects(:exec).with("arp -a").
-          at_least_once.returns(ec2arp)
-        Facter::Util::EC2.has_ec2_arp?.should == false
-      end
-    end
-
-    describe "on solaris" do
-      before :each do
-        Facter.stubs(:value).with(:kernel).returns("SunOS")
-      end
-
-      it "should fail if arp table does not contain fe:ff:ff:ff:ff:ff" do
-        ec2arp = my_fixture_read("solaris8_arp_a_not_ec2.out")
-
-        Facter::Core::Execution.expects(:exec).with("arp -a").
-          at_least_once.returns(ec2arp)
-
-        Facter::Util::EC2.has_ec2_arp?.should == false
-      end
-    end
-  end
-
-  describe "is_euca_mac? method" do
-    it "should return true when the mac is a eucalyptus one" do
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("d0:0d:1a:b0:a1:00")
-
-      Facter::Util::EC2.has_euca_mac?.should == true
-    end
-
-    it "should return false when the mac is not a eucalyptus one" do
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("0c:1d:a0:bc:aa:02")
-
-      Facter::Util::EC2.has_euca_mac?.should == false
-    end
-  end
-
-  describe "is_openstack_mac? method" do
-    it "should return true when the mac is an openstack one" do
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("02:16:3e:54:89:fd")
-
-      Facter::Util::EC2.has_openstack_mac?.should == true
-    end
-
-    it "should return true when the mac is a newer openstack mac" do
-      # https://github.com/openstack/nova/commit/b684d651f540fc512ced58acd5ae2ef4d55a885c#nova/utils.py
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("fa:16:3e:54:89:fd")
-
-      Facter::Util::EC2.has_openstack_mac?.should == true
-    end
-
-    it "should return true when the mac is a newer openstack mac and returned in upper case" do
-      # https://github.com/openstack/nova/commit/b684d651f540fc512ced58acd5ae2ef4d55a885c#nova/utils.py
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("FA:16:3E:54:89:FD")
-
-      Facter::Util::EC2.has_openstack_mac?.should == true
-    end
-
-    it "should return false when the mac is not a openstack one" do
-      Facter.expects(:value).with(:macaddress).\
-        at_least_once.returns("0c:1d:a0:bc:aa:02")
-
-      Facter::Util::EC2.has_openstack_mac?.should == false
-    end
-  end
-
-  describe "can_connect? method" do
-    it "returns true if api responds" do
-      # Return something upon connecting to the root
-      Module.any_instance.expects(:open).with("#{api_prefix}:80/", {:proxy => nil}).
-        at_least_once.returns("2008-02-01\nlatest")
-
-      Facter::Util::EC2.can_connect?.should be_true
-    end
-
-    describe "when connection times out" do
-      it "should return false" do
-        # Emulate a timeout when connecting by throwing an exception
-        Module.any_instance.expects(:open).with("#{api_prefix}:80/", {:proxy => nil}).
-          at_least_once.raises(RuntimeError)
-
-        Facter::Util::EC2.can_connect?.should be_false
-      end
-    end
-
-    describe "when connection is refused" do
-      it "should return false" do
-        # Emulate a connection refused
-        Module.any_instance.expects(:open).with("#{api_prefix}:80/", {:proxy => nil}).
-          at_least_once.raises(Errno::ECONNREFUSED)
-
-        Facter::Util::EC2.can_connect?.should be_false
-      end
-    end
-  end
-
-  describe "Facter::Util::EC2.userdata" do
-    let :not_found_error do
-      OpenURI::HTTPError.new("404 Not Found", StringIO.new)
-    end
-
-    let :example_userdata do
-      "owner=jeff@puppetlabs.com\ngroup=platform_team"
-    end
-
-    it 'returns nil when no userdata is present' do
-      Facter::Util::EC2.stubs(:read_uri).raises(not_found_error)
-      Facter::Util::EC2.userdata.should be_nil
-    end
-
-    it "returns the string containing the body" do
-      Facter::Util::EC2.stubs(:read_uri).returns(example_userdata)
-      Facter::Util::EC2.userdata.should == example_userdata
-    end
-
-    it "uses the specified API version" do
-      expected_uri = "http://169.254.169.254/2008-02-01/user-data/"
-      Facter::Util::EC2.expects(:read_uri).with(expected_uri).returns(example_userdata)
-      Facter::Util::EC2.userdata('2008-02-01').should == example_userdata
-    end
-  end
-end