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

data/spec/unit/core/suitable_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'facter/core/suitable'
-
-describe Facter::Core::Suitable do
-
-  class SuitableClass
-    def initialize
-      @confines = []
-    end
-    attr_reader :confines
-    include Facter::Core::Suitable
-  end
-
-  subject { SuitableClass.new }
-
-  describe "confining on facts" do
-    it "can add confines with a fact and a single value" do
-      subject.confine :kernel => 'Linux'
-    end
-
-    it "creates a Facter::Util::Confine object for the confine call" do
-      subject.confine :kernel => 'Linux'
-      conf = subject.confines.first
-      expect(conf).to be_a_kind_of Facter::Util::Confine
-      expect(conf.fact).to eq :kernel
-      expect(conf.values).to eq ['Linux']
-    end
-  end
-
-  describe "confining on blocks" do
-    it "can add a single fact with a block parameter" do
-      subject.confine(:one) { true }
-    end
-
-    it "creates a Util::Confine instance for the provided fact with block parameter" do
-      block = lambda { true }
-      Facter::Util::Confine.expects(:new).with("one")
-
-      subject.confine("one", &block)
-    end
-
-    it "should accept a single block parameter" do
-      subject.confine() { true }
-    end
-
-    it "should create a Util::Confine instance for the provided block parameter" do
-      block = lambda { true }
-      Facter::Util::Confine.expects(:new)
-
-      subject.confine(&block)
-    end
-  end
-
-  describe "determining weight" do
-    it "is zero if no confines are set" do
-      expect(subject.weight).to eq 0
-    end
-
-    it "defaults to the number of confines" do
-      subject.confine :kernel => 'Linux'
-      expect(subject.weight).to eq 1
-    end
-
-    it "can be explicitly set" do
-      subject.has_weight 10
-      expect(subject.weight).to eq 10
-    end
-
-    it "prefers an explicit weight over the number of confines" do
-      subject.confine :kernel => 'Linux'
-      subject.has_weight 11
-      expect(subject.weight).to eq 11
-    end
-  end
-
-  describe "determining suitability" do
-    it "is true if all confines for the object evaluate to true" do
-      subject.confine :kernel => 'Linux'
-      subject.confine :operatingsystem => 'Redhat'
-
-      subject.confines.each { |confine| confine.stubs(:true?).returns true }
-
-      expect(subject).to be_suitable
-    end
-
-    it "is false if any confines for the object evaluate to false" do
-      subject.confine :kernel => 'Linux'
-      subject.confine :operatingsystem => 'Redhat'
-
-      subject.confines.first.stubs(:true?).returns true
-      subject.confines.first.stubs(:true?).returns false
-
-      expect(subject).to_not be_suitable
-    end
-
-    it "recalculates suitability on every invocation" do
-      subject.confine :kernel => 'Linux'
-
-      subject.confines.first.stubs(:true?).returns false
-      expect(subject).to_not be_suitable
-      subject.confines.first.unstub(:true?)
-      subject.confines.first.stubs(:true?).returns true
-      expect(subject).to be_suitable
-    end
-  end
-end

data/spec/unit/dhcp_servers_spec.rb

@@ -1,212 +0,0 @@
-require 'spec_helper'
-
-describe "DHCP server facts" do
-  describe "on Linux OS's" do
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns 'Linux'
-      Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route'))
-    end
-
-    describe "with nmcli version <= 0.9.8 available" do
-      before :each do
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
-        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.8.0')
-      end
-
-      describe "with a main interface configured with DHCP" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("connected\n")
-        end
-
-        it "should produce a dhcp_servers fact that includes values for 'system' as well as each dhcp enabled interface" do
-          Facter.fact(:dhcp_servers).value.should == { 'system' => '192.168.1.1', 'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with a main interface NOT configured with DHCP" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_static"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("connected\n")
-        end
-
-        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
-          Facter.fact(:dhcp_servers).value.should == {'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with no default gateway" do
-        before :each do
-          Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route_nogw'))
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("connected\n")
-        end
-
-        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
-          Facter.fact(:dhcp_servers).value.should == {'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with no DHCP enabled interfaces" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface eth0").returns(my_fixture_read("nmcli_eth0_static"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d list iface wlan0").returns(my_fixture_read("nmcli_wlan0_static"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("connected\n")
-        end
-
-        it "should not produce a dhcp_servers fact" do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-
-      describe "with no CONNECTED devices" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices_disconnected"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("disconnected\n")
-        end
-
-        it "should not produce a dhcp_servers fact" do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-    end
-
-    describe "with nmcli version >= 0.9.9 available" do
-      before :each do
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
-        Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.9.0-20.git20131003.fc20')
-      end
-
-      describe "with a main interface configured with DHCP" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("connected\n")
-        end
-
-        it "should produce a dhcp_servers fact that includes values for 'system' as well as each dhcp enabled interface" do
-          Facter.fact(:dhcp_servers).value.should == { 'system' => '192.168.1.1', 'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with a main interface NOT configured with DHCP" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_static"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("connected\n")
-        end
-
-        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
-          Facter.fact(:dhcp_servers).value.should == {'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with no default gateway" do
-        before :each do
-          Facter::Util::FileRead.stubs(:read).with('/proc/net/route').returns(my_fixture_read('route_nogw'))
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_dhcp"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("connected\n")
-        end
-
-        it "should a dhcp_servers fact that includes values for each dhcp enables interface and NO 'system' value" do
-          Facter.fact(:dhcp_servers).value.should == {'eth0' => '192.168.1.1', 'wlan0' => '192.168.2.1' }
-        end
-      end
-
-      describe "with no DHCP enabled interfaces" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show eth0").returns(my_fixture_read("nmcli_eth0_static"))
-          Facter::Core::Execution.stubs(:exec).with("nmcli -f all d show wlan0").returns(my_fixture_read("nmcli_wlan0_static"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("connected\n")
-        end
-
-        it "should not produce a dhcp_servers fact" do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-
-      describe "with no CONNECTED devices" do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with("nmcli d").returns(my_fixture_read("nmcli_devices_disconnected"))
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("disconnected\n")
-        end
-
-        it "should not produce a dhcp_servers fact" do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-    end
-
-    describe 'without NetworkManager running' do
-      before :each do
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns('/usr/bin/nmcli')
-      end
-
-      describe 'with nmcli version >= 0.9.9 available' do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("unknown\n")
-          Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.9.0')
-        end
-
-        it 'should not produce a dhcp_servers fact' do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-
-      describe 'with nmcli version <= 0.9.8 available' do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("unknown\n")
-          Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.7.0')
-        end
-
-        it 'should not produce a dhcp_servers fact' do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-      describe 'with nmcli version >= 0.9.9 available but printing an error to STDERR' do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE g 2>/dev/null').returns("\n")
-          Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.9.0')
-        end
-
-        it 'should not produce a dhcp_servers fact' do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-
-      describe 'with nmcli version <= 0.9.8 available but printing an error to STDERR' do
-        before :each do
-          Facter::Core::Execution.stubs(:exec).with('nmcli -t -f STATE nm 2>/dev/null').returns("\n")
-          Facter::Core::Execution.stubs(:exec).with('nmcli --version').returns('nmcli tool, version 0.9.7.0')
-        end
-
-        it 'should not produce a dhcp_servers fact' do
-          Facter.fact(:dhcp_servers).value.should be_nil
-        end
-      end
-
-    end
-
-    describe "without nmcli available" do
-      before :each do
-        Facter::Core::Execution.stubs(:which).with('nmcli').returns(nil)
-      end
-
-      it "should not produce a dhcp_server fact" do
-        Facter.fact(:dhcp_servers).value.should be_nil
-      end
-    end
-  end
-end

data/spec/unit/domain_spec.rb

@@ -1,310 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'stringio'
-
-describe "Domain name facts" do
-
-  def resolv_conf_contains(*lines)
-    file_handle = StringIO.new(lines.join("\n"))
-    FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(true)
-    File.stubs(:open).with("/etc/resolv.conf").yields(file_handle)
-  end
-
-  [
-    { :kernel => "Linux", :hostname_command => "hostname -f 2> /dev/null" },
-    { :kernel => "SunOS", :hostname_command => "hostname 2> /dev/null" },
-    { :kernel => "Darwin", :hostname_command => "hostname -f 2> /dev/null" },
-    { :kernel => "FreeBSD", :hostname_command => "hostname -f 2> /dev/null" },
-    { :kernel => "HP-UX", :hostname_command => "hostname 2> /dev/null" },
-  ].each do |scenario|
-
-    describe "on #{scenario[:kernel]}" do
-      let(:hostname_command) { scenario[:hostname_command] }
-      let(:dnsdomain_command) { "dnsdomainname 2> /dev/null" }
-
-      def the_hostname_is(value)
-        Facter::Core::Execution.stubs(:exec).with(hostname_command).returns(value)
-      end
-
-      def the_dnsdomainname_is(value)
-        Facter::Core::Execution.stubs(:exec).with(dnsdomain_command).returns(value)
-      end
-
-      before do
-        Facter.fact(:kernel).stubs(:value).returns(scenario[:kernel])
-      end
-
-      it "should use the hostname binary" do
-        the_hostname_is("test.example.com")
-
-        Facter.fact(:domain).value.should == "example.com"
-      end
-
-      it "should fall back to the dnsdomainname binary" do
-        the_hostname_is("myhost")
-        the_dnsdomainname_is("example.com")
-
-        Facter.fact(:domain).value.should == "example.com"
-      end
-
-      it "should fall back to /etc/resolv.conf" do
-        the_hostname_is("myhost")
-        the_dnsdomainname_is("")
-
-        resolv_conf_contains("domain testing.com")
-
-        Facter.fact(:domain).value.should == "testing.com"
-      end
-
-      describe "Top level domain" do
-        it "should find the domain name" do
-          the_hostname_is("ns01.tld")
-
-          Facter.fact(:domain).value.should == "tld"
-        end
-      end
-
-      describe "when using /etc/resolv.conf" do
-        before do
-          the_hostname_is("")
-          the_dnsdomainname_is("")
-        end
-
-        it "should use the domain field over the search field" do
-          resolv_conf_contains(
-            "nameserver 4.2.2.1",
-            "search example.org",
-            "domain example.com"
-          )
-
-          Facter.fact(:domain).value.should == 'example.com'
-        end
-
-        it "should fall back to the search field" do
-          resolv_conf_contains(
-            "nameserver 4.2.2.1",
-            "search example.org"
-          )
-
-          Facter.fact(:domain).value.should == 'example.org'
-        end
-
-        it "should use the first domain in the search field" do
-          resolv_conf_contains("search example.org example.net")
-
-          Facter.fact(:domain).value.should == 'example.org'
-        end
-
-        # Test permutations of domain and search, where 'domain' can be a value of
-        # the search keyword and the domain keyword
-        # and also where 'search' can be a value of the search keyword and the
-        # domain keyword
-        # For example, /etc/resolv.conf may look like:
-        #     domain domain
-        # or
-        #     search search
-        # or
-        #     domain search
-        #
-        #
-        # Why someone would have their machines named 'www.domain' or 'www.search', I
-        # don't know, but we'll at least handle it properly
-        [
-         [["domain domain"], "domain"],
-         [["domain search"], "search"],
-         [["search domain"], "domain"],
-         [["search search"], "search"],
-         [["search domain notdomain"], "domain"],
-         [["#search notdomain", "search search"], "search"],
-         [["# search notdomain", "search search"], "search"],
-         [["#domain notdomain", "domain domain"], "domain"],
-         [["# domain notdomain", "domain domain"], "domain"],
-        ].each do |tuple|
-          conf  = tuple[0]
-          expect = tuple[1]
-          it "should return #{expect} from \"#{conf}\"" do
-            resolv_conf_contains(*conf)
-
-            Facter.fact(:domain).value.should == expect
-          end
-        end
-      end
-    end
-  end
-
-  describe "on Windows" 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
-
-      def expects_dnsdomains(domains)
-        nics = []
-
-        domains.each do |domain|
-          nic = stubs 'nic'
-          nic.stubs(:DNSDomain).returns(domain)
-          nics << nic
-        end
-
-        require 'facter/util/wmi'
-        Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns(nics)
-      end
-
-      it "uses the first DNSDomain" do
-        expects_dnsdomains(['foo.com', 'bar.com'])
-
-        Facter.fact(:domain).value.should == 'foo.com'
-      end
-
-      it "uses the first non-nil DNSDomain" do
-        expects_dnsdomains([nil, 'bar.com'])
-
-        Facter.fact(:domain).value.should == 'bar.com'
-      end
-
-      it "uses the first non-empty DNSDomain" do
-        expects_dnsdomains(['', 'bar.com'])
-
-        Facter.fact(:domain).value.should == 'bar.com'
-      end
-
-      context "without any network adapters with a specified DNSDomain" do
-        let(:hostname_command) { 'hostname > NUL' }
-
-        it "should return nil" do
-          expects_dnsdomains([nil])
-
-          Facter::Core::Execution.stubs(:exec).with(hostname_command).returns('sometest')
-          FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(false)
-
-          Facter.fact(:domain).value.should be_nil
-        end
-      end
-    end
-  end
-
-  describe "with trailing dots" do
-    describe "on Windows" do
-      before do
-        Facter.fact(:kernel).stubs(:value).returns("windows")
-        require 'facter/util/registry'
-        require 'facter/util/wmi'
-      end
-
-      [{:registry => 'testdomain.', :wmi => '', :expect => 'testdomain'},
-       {:registry => '', :wmi => 'testdomain.', :expect => 'testdomain'},
-      ].each do |scenario|
-
-        describe "scenarios" do
-          before(:each) do
-            Facter::Util::Registry.stubs(:hklm_read).returns(scenario[:registry])
-            nic = stubs 'nic'
-            nic.stubs(:DNSDomain).returns(scenario[:wmi])
-            Facter::Util::WMI.stubs(:execquery).with("select DNSDomain from Win32_NetworkAdapterConfiguration where IPEnabled = True").returns([nic])
-          end
-
-          it "should return #{scenario[:expect]}" do
-            Facter.fact(:domain).value.should == scenario[:expect]
-          end
-
-          it "should remove trailing dots"  do
-            Facter.fact(:domain).value.should_not =~ /\.$/
-          end
-        end
-      end
-    end
-
-    describe "on everything else" do
-      before do
-        Facter.fact(:kernel).stubs(:value).returns("Linux")
-        FileTest.stubs(:exists?).with("/etc/resolv.conf").returns(true)
-      end
-
-      [
-        {
-          :scenario => 'when there is only a hostname',
-          :hostname => 'host.testdomain.',
-          :dnsdomainname => '',
-          :resolve_domain => '',
-          :resolve_search => '',
-          :expect => 'testdomain'
-        },
-        {
-          :scenario => 'when there is only a domain name',
-          :hostname => '',
-          :dnsdomainname => 'testdomain.',
-          :resolve_domain => '',
-          :resolve_search => '',
-          :expect => 'testdomain'
-        },
-        {
-          :scenario => 'when there is only a resolve domain',
-          :hostname => '',
-          :dnsdomainname => '',
-          :resolve_domain => 'testdomain.',
-          :resolve_search => '',
-          :expect => 'testdomain'
-        },
-        {
-          :scenario => 'when there is only a resolve search',
-          :hostname => '',
-          :dnsdomainname => '',
-          :resolve_domain => '',
-          :resolve_search => 'testdomain.',
-          :expect => 'testdomain'
-        },
-        {
-          :scenario => 'when there is no information available',
-          :hostname => '',
-          :dnsdomainname => '',
-          :resolve_domain => '',
-          :resolve_search => '',
-          :expect => nil
-        }
-      ].each do |scenario|
-
-        describe scenario[:scenario] do
-          before(:each) do
-            Facter::Core::Execution.stubs(:exec).with("hostname -f 2> /dev/null").returns(scenario[:hostname])
-            Facter::Core::Execution.stubs(:exec).with("dnsdomainname 2> /dev/null").returns(scenario[:dnsdomainname])
-            resolv_conf_contains(
-              "search #{scenario[:resolve_search]}",
-              "domain #{scenario[:resolve_domain]}"
-            )
-          end
-
-          it "should remove trailing dots" do
-            Facter.fact(:domain).value.should_not =~ /\.$/
-          end
-
-          it "should return #{scenario[:expect]}" do
-            Facter.fact(:domain).value.should == scenario[:expect]
-          end
-        end
-      end
-    end
-  end
-end