facter 2.5.7 → 3.9.6.cfacter.20180606

data/spec/unit/fqdn_spec.rb

@@ -1,16 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "fqdn fact" do
-  it "should concatenate hostname and domain" do
-    Facter.fact(:hostname).stubs(:value).returns("foo")
-    Facter.fact(:domain).stubs(:value).returns("bar")
-    Facter.fact(:fqdn).value.should == "foo.bar"
-  end
-  it "should return hostname when domain is nil" do
-    Facter.fact(:hostname).stubs(:value).returns("foo")
-    Facter.fact(:domain).stubs(:value).returns(nil)
-    Facter.fact(:fqdn).value.should == "foo"
-  end
-end

data/spec/unit/gce/metadata_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-require 'facter/gce/metadata'
-
-describe Facter::GCE::Metadata, :if => Facter.json? do
-
-  describe "contacting the metadata server" do
-    it "retries the request when a connection error is thrown" do
-      subject.stubs(:open).returns(stub(:read => '{"hello": "world"}'))
-      seq = sequence('open-uri seq')
-      Timeout.expects(:timeout).with(0.05).twice.in_sequence(seq).raises(Timeout::Error)
-      Timeout.expects(:timeout).with(0.05).once.in_sequence(seq).yields
-      expect(subject.fetch).to eq({'hello' => 'world'})
-    end
-
-    it "logs the exception when all retries failed" do
-      Timeout.expects(:timeout).with(0.05).times(3).raises(Timeout::Error)
-      Facter.expects(:log_exception).with(instance_of(Timeout::Error), instance_of(String))
-      expect(subject.fetch).to be_nil
-    end
-  end
-
-  describe "parsing the metadata response" do
-    let(:body) { my_fixture_read('metadata.json') }
-    before do
-      subject.stubs(:open).returns(stub(:read => body))
-    end
-
-    it "transforms hash values with the 'image' key" do
-      expect(subject.fetch['instance']['image']).to eq 'centos6'
-    end
-
-    it "transforms hash values with the 'machineType' key" do
-      expect(subject.fetch['instance']['machineType']).to eq 'n1-standard-1'
-    end
-
-    it "transforms hash values with the 'zone' key" do
-      expect(subject.fetch['instance']['zone']).to eq 'us-central1-b'
-    end
-
-    it "transforms hash values with the 'network' key" do
-      expect(subject.fetch['instance']['networkInterfaces'][0]['network']).to eq 'default'
-    end
-
-    it "splits up the elements of the 'sshKeys' value into an array" do
-      expect(subject.fetch['project']['attributes']['sshKeys'][0]).to match(/justin:ssh-rsa/)
-      expect(subject.fetch['project']['attributes']['sshKeys'][1]).to match(/adrien:ssh-rsa/)
-    end
-  end
-end

data/spec/unit/gce_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-require 'facter/gce/metadata'
-
-describe "gce_metadata" do
-  let(:querier) { stub('GCE metadata querier') }
-
-  before do
-    Facter::GCE::Metadata.stubs(:new).returns querier
-    Facter.collection.internal_loader.load(:ec2)
-  end
-
-  subject { Facter.fact(:gce).resolution(:rest) }
-
-  it "is unsuitable when the virtual type is not gce" do
-    Facter.fact(:virtual).stubs(:value).returns 'kvm'
-    expect(subject).to_not be_suitable
-  end
-
-  it "is unsuitable when JSON is not available" do
-    Facter.stubs(:json?).returns false
-    expect(subject).to_not be_suitable
-  end
-
-  it "is suitable when both the virtual type is gce and JSON is available" do
-    Facter.fact(:virtual).stubs(:value).returns 'gce'
-    Facter.stubs(:json?).returns true
-    expect(subject).to be_suitable
-  end
-
-  it "resolves the fact by querying GCE metadata API" do
-    querier.expects(:fetch).returns({'hello' => 'world'})
-    expect(subject.value).to eq({'hello' => 'world'})
-  end
-end

data/spec/unit/gid_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-describe "gid fact" do
-
-  describe "on non-SunOS systems with id" do
-    it "should return the current group" do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      Facter::Core::Execution.expects(:which).with('id').returns(true)
-      Facter::Core::Execution.expects(:exec).once.with('id -ng').returns 'bar'
-
-      Facter.fact(:gid).value.should == 'bar'
-    end
-  end
-
-  describe "on non-SunOS systems without id" do
-    it "is not supported" do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      Facter::Core::Execution.expects(:which).with('id').returns(false)
-
-      Facter.fact(:gid).value.should == nil
-    end
-  end
-
-  describe "on SunOS systems with /usr/xpg4/bin/id" do
-    it "should return the current group" do
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-      File.expects(:exist?).with('/usr/xpg4/bin/id').returns true
-      Facter::Core::Execution.expects(:exec).with('/usr/xpg4/bin/id -ng').returns 'bar'
-
-      Facter.fact(:gid).value.should == 'bar'
-    end
-  end
-
-  describe "on SunOS systems without /usr/xpg4/bin/id" do
-    it "is not supported" do
-      Facter.fact(:kernel).stubs(:value).returns("SunOS")
-      File.expects(:exist?).with('/usr/xpg4/bin/id').returns false
-
-      Facter.fact(:gid).value.should == nil
-    end
-  end
-
-  describe "on windows systems" do
-    it "is not supported" do
-      Facter.fact(:kernel).stubs(:value).returns("windows")
-      Facter::Core::Execution.expects(:which).with('id').returns(true)
-
-      Facter.fact(:gid).value.should == nil
-    end
-  end
-end

data/spec/unit/hardwareisa_spec.rb

@@ -1,41 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-
-describe "Hardwareisa fact" do
-  it "should match uname -p on Linux" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Inky")
-
-    Facter.fact(:hardwareisa).value.should == "Inky"
-  end
-
-  it "should match uname -p on Darwin" do
-    Facter.fact(:kernel).stubs(:value).returns("Darwin")
-    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Blinky")
-
-    Facter.fact(:hardwareisa).value.should == "Blinky"
-  end
-
-  it "should match uname -p on SunOS" do
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Pinky")
-
-    Facter.fact(:hardwareisa).value.should == "Pinky"
-  end
-
-  it "should match uname -p on FreeBSD" do
-    Facter.fact(:kernel).stubs(:value).returns("FreeBSD")
-    Facter::Core::Execution.stubs(:execute).with("uname -p", anything).returns("Clyde")
-
-    Facter.fact(:hardwareisa).value.should == "Clyde"
-  end
-
-  it "should match uname -m on HP-UX" do
-    Facter.fact(:kernel).stubs(:value).returns("HP-UX")
-    Facter::Core::Execution.stubs(:execute).with("uname -m", anything).returns("Pac-Man")
-
-    Facter.fact(:hardwareisa).value.should == "Pac-Man"
-  end
-end

data/spec/unit/hardwaremodel_spec.rb

@@ -1,58 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter'
-
-describe "Hardwaremodel fact" do
-  it "should match uname -m by default" do
-    Facter.fact(:kernel).stubs(:value).returns("Darwin")
-    Facter.fact(:operatingsystem).stubs(:value).returns("Darwin")
-    Facter::Core::Execution.stubs(:execute).with("uname -m", anything).returns("Inky")
-
-    Facter.fact(:hardwaremodel).value.should == "Inky"
-  end
-
-  describe "on Windows" do
-    require 'facter/util/wmi'
-    before :each do
-      Facter.fact(:kernel).stubs(:value).returns("windows")
-      Facter.fact(:operatingsystem).stubs(:value).returns("windows")
-    end
-
-    it "should detect i486" do
-      cpu = mock('cpu', :Architecture => 0)
-      cpu.expects(:Level).returns(4).twice
-      Facter::Util::WMI.expects(:execquery).returns([cpu])
-
-      Facter.fact(:hardwaremodel).value.should == "i486"
-    end
-
-    it "should detect i686" do
-      cpu = mock('cpu', :Architecture => 0, :Level => 6)
-      Facter::Util::WMI.expects(:execquery).returns([cpu])
-
-      Facter.fact(:hardwaremodel).value.should == "i686"
-    end
-
-    it "should detect x64" do
-      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 64, :Level => 6)
-      Facter::Util::WMI.expects(:execquery).returns([cpu])
-
-      Facter.fact(:hardwaremodel).value.should == "x64"
-    end
-
-    it "(#16948) reports i686 when a 32 bit OS is running on a 64 bit CPU" do
-      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 6)
-      Facter::Util::WMI.expects(:execquery).returns([cpu])
-
-      Facter.fact(:hardwaremodel).value.should == "i686"
-    end
-
-    it "(#20989) should report i686 when a 32 bit OS is running on a 64 bit CPU and when level is greater than 6 (and not something like i1586)" do
-      cpu = mock('cpu', :Architecture => 9, :AddressWidth => 32, :Level => 15)
-      Facter::Util::WMI.expects(:execquery).returns([cpu])
-
-      Facter.fact(:hardwaremodel).value.should == "i686"
-    end
-  end
-end

data/spec/unit/hostname_spec.rb

@@ -1,40 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "Hostname facts" do
-
-  describe "on linux" do
-    before do
-      Facter.fact(:kernel).stubs(:value).returns("Linux")
-      Facter.fact(:kernelrelease).stubs(:value).returns("2.6")
-    end
-
-    it "should use the hostname command" do
-      Facter::Core::Execution.expects(:execute).with('hostname').at_least_once
-      Facter.fact(:hostname).value.should be_nil
-    end
-
-    it "should use hostname as the fact if unqualified" do
-      Facter::Core::Execution.stubs(:execute).with('hostname').returns('host1')
-      Facter.fact(:hostname).value.should == "host1"
-    end
-
-    it "should truncate the domain name if qualified" do
-      Facter::Core::Execution.stubs(:execute).with('hostname').returns('host1.example.com')
-      Facter.fact(:hostname).value.should == "host1"
-    end
-  end
-
-  describe "on darwin release R7" do
-    before do
-      Facter.fact(:kernel).stubs(:value).returns("Darwin")
-      Facter.fact(:kernelrelease).stubs(:value).returns("R7")
-    end
-
-    it "should use scutil to get the hostname" do
-      Facter::Core::Execution.expects(:execute).with('/usr/sbin/scutil --get LocalHostName', anything).returns("host1")
-      Facter.fact(:hostname).value.should == "host1"
-    end
-  end
-end

data/spec/unit/id_spec.rb

@@ -1,29 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-
-describe "id fact" do
-  include FacterSpec::ConfigHelper
-
-  kernel = [ 'Linux', 'Darwin', 'windows', 'FreeBSD', 'OpenBSD', 'NetBSD', 'AIX', 'HP-UX' ]
-
-  kernel.each do |k|
-    describe "with kernel reported as #{k}" do
-      it "should return the current user" do
-        given_a_configuration_of(:is_windows => k == 'windows')
-        Facter.fact(:kernel).stubs(:value).returns(k)
-        Facter::Core::Execution.expects(:execute).once.with('whoami', anything).returns 'bar'
-
-        Facter.fact(:id).value.should == 'bar'
-      end
-    end
-  end
-
-  it "should return the current user on Solaris" do
-    given_a_configuration_of(:is_windows => false)
-    Facter.fact(:kernel).stubs(:value).returns 'SunOS'
-    Facter::Core::Execution.expects(:execute).once.with('/usr/xpg4/bin/id -un', anything).returns 'bar'
-
-    Facter.fact(:id).value.should == 'bar'
-  end
-end

data/spec/unit/interfaces_spec.rb

@@ -1,67 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'shared_formats/parses'
-require 'facter/util/ip'
-
-shared_examples_for "interface netmask and mtu from ifconfig output" do |platform, interface, netmask, mtu, fixture|
-  it "should be correct on #{platform} for interface #{interface}" do
-    Facter::Util::IP.stubs(:exec_ifconfig).returns(my_fixture_read(fixture))
-    Facter::Util::IP.stubs(:get_output_for_interface_and_label).
-      returns(my_fixture_read("#{fixture}.#{interface}"))
-    Facter.collection.internal_loader.load(:interfaces)
-
-    Facter.fact("netmask_#{interface}".intern).value.should eq(netmask)
-    Facter.fact("mtu_#{interface}".intern).value.should eq(mtu)
-  end
-end
-
-describe "Per Interface IP facts" do
-  it "should replace the ':' in an interface list with '_'" do
-    # So we look supported
-    Facter.fact(:kernel).stubs(:value).returns("SunOS")
-
-    Facter::Util::IP.stubs(:get_interfaces).returns %w{eth0:1 eth1:2}
-    Facter.fact(:interfaces).value.should == %{eth0_1,eth1_2}
-  end
-
-  it "should replace non-alphanumerics in an interface list with '_'" do
-    Facter.fact(:kernel).stubs(:value).returns("windows")
-
-    Facter::Util::IP.stubs(:get_interfaces).returns ["Local Area Connection", "Loopback \"Pseudo-Interface\" (#1)"]
-    Facter.fact(:interfaces).value.should == %{Local_Area_Connection,Loopback__Pseudo_Interface____1_}
-  end
-
-  it "should properly format a mac address" do
-    Facter::Util::IP.stubs(:get_interfaces).returns ["net0"]
-    Facter::Util::IP.stubs(:get_interface_value).returns "0:12:34:56:78:90"
-
-    Facter.collection.internal_loader.load(:interfaces)
-
-    fact = Facter.fact("macaddress_net0".intern)
-    fact.value.should eq("00:12:34:56:78:90")
-  end
-
-  it "should support ipv6 address starting by [180ef]" do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-    Facter::Util::IP.stubs(:exec_ifconfig) \
-      .returns(my_fixture_read('ifconfig_net_tools_1.60_v6.txt'))
-    Facter.collection.internal_loader.load(:interfaces)
-    Facter.fact('ipaddress6_em1'.intern).value \
-      .should eq('1610:10:20:209:212:3fff:febe:2201')
-  end
-
-end
-
-describe "Netmask and MTU handling on Linux" do
-  before :each do
-    Facter.fact(:kernel).stubs(:value).returns("Linux")
-  end
-
-  example_behavior_for "interface netmask and mtu from ifconfig output",
-    "Archlinux (net-tools 1.60)", "em1",
-    "255.255.255.0", 1500, "ifconfig_net_tools_1.60.txt"
-  example_behavior_for "interface netmask and mtu from ifconfig output",
-    "Archlinux (net-tools 1.60)", "lo",
-    "255.0.0.0", 16436, "ifconfig_net_tools_1.60.txt"
-end

data/spec/unit/ipaddress6_spec.rb

@@ -1,180 +0,0 @@
-#! /usr/bin/env ruby
-
-require 'spec_helper'
-require 'facter/util/ip'
-
-def ifconfig_fixture(filename)
-  File.read(fixtures('ifconfig', filename))
-end
-
-describe "The IPv6 address fact" do
-  include FacterSpec::ConfigHelper
-
-  before do
-    given_a_configuration_of(:is_windows => false)
-  end
-
-  it "should return ipaddress6 information for Darwin" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Darwin')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["-a"]).
-      returns(ifconfig_fixture('darwin_ifconfig_all_with_multiple_interfaces'))
-
-    Facter.value(:ipaddress6).should == "2610:10:20:209:223:32ff:fed5:ee34"
-  end
-
-  it "should return ipaddress6 information for Linux" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
-      returns(ifconfig_fixture('linux_ifconfig_all_with_multiple_interfaces'))
-
-    Facter.value(:ipaddress6).should == "2610:10:20:209:212:3fff:febe:2201"
-  end
-
-  it "should return ipaddress6 information for Linux with recent net-tools" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
-      returns(ifconfig_fixture('ifconfig_net_tools_1.60.txt'))
-
-    Facter.value(:ipaddress6).should == "2610:10:20:209:212:3fff:febe:2201"
-  end
-
-  it "should return ipaddress6 with fe80 in any other octet than the first for Linux" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
-      returns(ifconfig_fixture('linux_ifconfig_all_with_multiple_interfaces_and_fe80'))
-
-    Facter.value(:ipaddress6).should == "2610:10:20:209:212:3fff:fe80:2201"
-  end
-
-  it "should not return ipaddress6 link-local address for Linux" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('Linux')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["2>/dev/null"]).
-      returns(ifconfig_fixture('linux_ifconfig_all_with_multiple_interfaces_and_no_public_ipv6'))
-
-    Facter.value(:ipaddress6).should be_false
-  end
-
-  it "should return ipaddress6 information for Solaris" do
-    Facter::Core::Execution.stubs(:exec).with('uname -s').returns('SunOS')
-    Facter::Util::IP.stubs(:get_ifconfig).returns("/usr/sbin/ifconfig")
-    Facter::Util::IP.stubs(:exec_ifconfig).with(["-a"]).
-      returns(ifconfig_fixture('sunos_ifconfig_all_with_multiple_interfaces'))
-
-    Facter.value(:ipaddress6).should == "2610:10:20:209:203:baff:fe27:a7c"
-  end
-
-  context "on Windows" do
-    require 'facter/util/wmi'
-    require 'facter/util/registry'
-    require 'facter/util/ip/windows'
-    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)
-      given_a_configuration_of(:is_windows => true)
-    end
-
-    it "should do what when VPN is turned on?"
-
-    context "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).with(Facter::Util::IP::Windows::WMI_IP_INFO_QUERY).returns([])
-
-        Facter.value(:ipaddress6).should == nil
-      end
-    end
-
-    it "should return nil if the system doesn't have ipv6 installed", :if => Facter::Util::Config.is_windows? do
-      require 'win32/registry'
-      Facter::Util::Resolution.any_instance.expects(:warn).never
-      Facter::Util::Registry.stubs(:hklm_read).raises(Win32::Registry::Error, 2)
-
-      Facter.value(:ipaddress6).should == nil
-    end
-
-    context "when you have one network adapter" do
-      it "should return empty if ipv6 is not on" do
-        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
-        nic.expects(:IPAddress).returns([ipAddress1])
-        Facter::Util::WMI.expects(:execquery).returns([nic])
-
-        Facter.value(:ipaddress6).should == nil
-      end
-
-      it "should return the ipv6 address properly" do
-        Facter::Util::WMI.expects(:execquery).returns([given_a_valid_windows_nic_with_ipv4_and_ipv6])
-
-        Facter.value(:ipaddress6).should == ipv6Address0
-      end
-
-      it "should return the first ipv6 address if there is more than one (multi-homing)" do
-        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
-        nic.expects(:IPAddress).returns([ipAddress0, ipv6Address0,ipv6Address1])
-        Facter::Util::WMI.expects(:execquery).returns([nic])
-
-        Facter.value(:ipaddress6).should == ipv6Address0
-      end
-
-      it "should return return nil if the ipv6 address is link local" do
-        nic = given_a_valid_windows_nic_with_ipv4_and_ipv6
-        nic.expects(:IPAddress).returns([ipAddress0, ipv6LinkLocal])
-        Facter::Util::WMI.expects(:execquery).returns([nic])
-
-        Facter.value(:ipaddress6).should == nil
-      end
-    end
-
-    context "when you have more than one network adapter" do
-      it "should return empty if ipv6 is not on" do
-        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
-        nics[:nic0].expects(:IPAddress).returns([ipAddress0])
-        nics[:nic1].expects(:IPAddress).returns([ipAddress1])
-        Facter::Util::WMI.expects(:execquery).returns(nics.values)
-
-        Facter.value(:ipaddress6).should == nil
-      end
-
-      it "should return the ipv6 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(:ipaddress6).should == ipv6Address1
-      end
-
-      it "should return the ipv6 of the adapter with the lowest IP connection metric (best connection) that has ipv6 enabled" do
-        nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
-        nics[:nic1].expects(:IPConnectionMetric).returns(5)
-        nics[:nic1].expects(:IPAddress).returns([ipAddress1])
-        Facter::Util::WMI.expects(:execquery).returns(nics.values)
-
-        Facter.value(:ipaddress6).should == ipv6Address0
-      end
-
-      context "when the IP connection metric is the same" do
-        it "should return the ipv6 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(:ipaddress6).should == ipv6Address0
-        end
-
-        it "should return the ipv6 of the adapter with the lowest binding order even if the adapter is not first" do
-          nics = given_two_valid_windows_nics_with_ipv4_and_ipv6
-          Facter::Util::Registry.stubs(:hklm_read).returns(["\\Device\\#{settingId1}", "\\Device\\#{settingId0}" ])
-          Facter::Util::WMI.expects(:execquery).returns(nics.values)
-
-          Facter.value(:ipaddress6).should == ipv6Address1
-        end
-      end
-    end
-  end
-end