facter 4.0.26 → 4.0.28

data/acceptance/tests/facter_returns_success_on_non_existent_fact.rb

@@ -0,0 +1,9 @@
+test_name 'C100160: facter exits with success when asked for a non-existent fact' do
+  tag 'risk:high'
+
+  agents.each do |agent|
+    step 'facter should return exit code 0 for querying non-existing-fact without --strict flag' do
+      on(agent, facter('non-existing-fact'), :acceptable_exit_codes => 0)
+    end
+  end
+end

data/acceptance/tests/facts/dmi.rb

@@ -0,0 +1,51 @@
+test_name "C96148: verify dmi facts" do
+  tag 'risk:med'
+
+  confine :except, :platform => 'aix' # no dmi support
+  confine :except, :platform => 'huawei' # no dmi support
+  confine :except, :platform => 'osx' # no dmi support
+  confine :except, :platform => 'sparc' # no dmi support
+  confine :except, :platform => 'ppc64' # no dmi support on linux on powerpc
+
+  require 'json'
+  require 'facter/acceptance/base_fact_utils'
+  extend Facter::Acceptance::BaseFactUtils
+
+  agents.each do |agent|
+    expected_facts = {
+        'dmi.manufacturer' => /\w+/,
+        'dmi.product.name' => /\w+/,
+        'dmi.product.uuid' => /[-0-9A-Fa-f]+/,
+    }
+    unless agent['platform'] =~ /windows/
+      expected_facts.merge!({'dmi.bios.release_date' => /\d+\/\d+\/\d+/,
+                             'dmi.bios.vendor'       => /\w+/,
+                             'dmi.bios.version'      => /\d+/,
+                             'dmi.chassis.type'      => /\w+/,
+                            })
+    end
+    unless agent['platform'] =~ /windows|cisco|aarch64|el-/
+      expected_facts.merge!({'dmi.chassis.asset_tag' => /\w+/})
+    end
+    unless agent['platform'] =~ /cisco|aarch64|el-/
+      expected_facts.merge!({'dmi.product.serial_number' => /\w+/})
+    end
+    unless agent['platform'] =~ /windows|cisco|solaris|aarch64|el-/
+      expected_facts.merge!({'dmi.board.asset_tag'     => /\w+|/,
+                             'dmi.board.manufacturer'  => /\w+/,
+                             'dmi.board.product'       => /\w+/,
+                             'dmi.board.serial_number' => /None|\w+/
+                            })
+    end
+
+    step("verify that dmi structured fact contains facts") do
+      on(agent, facter("--json dmi")) do |facter_results|
+        json_facts = JSON.parse(facter_results.stdout)
+        expected_facts.each do |fact, value|
+          actual_fact = json_result_fact_by_key_path(json_facts, fact)
+          assert_match(value, actual_fact.to_s, "Incorrect fact pattern for '#{fact}'")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/facts/facterversion.rb

@@ -0,0 +1,11 @@
+test_name "C15286: verify facterversion fact" do
+  tag 'risk:low'
+
+  agents.each do |agent|
+    step("verify that fact facterversion is a version string") do
+      on(agent, facter("facterversion")) do |facter_result|
+        assert_match(/\d+\.\d+\.\d+/, facter_result.stdout.chomp, "Expected 'facterversion' fact to be a version string")
+      end
+    end
+  end
+end

data/acceptance/tests/facts/identity.rb

@@ -0,0 +1,52 @@
+test_name 'C100202: Facter identity facts resolve on all platforms' do
+  tag 'risk:high'
+
+  require 'json'
+
+  agents.each do |agent|
+    step 'Ensure the identity fact resolves as expected' do
+      if agent['platform'] =~ /windows/
+        # Regular expression to validate the username from facter in the form of '<domain>\<username>'
+        # Reference - https://msdn.microsoft.com/en-us/library/bb726984.aspx
+        # - The domain name can be any character or empty
+        # - Must contain a backslash between the domain and username
+        # - Username must be at least one character and not contain the following charaters; " / \ [ ] : ; | = , + * ? < >
+        expected_identity = {
+            'user'       => /.*\\[^\\\/\"\[\]:|<>+=;,?*@]+$/,
+            'privileged' => 'true'
+        }
+      elsif agent['platform'] =~ /aix-/
+        expected_identity = {
+            'gid'        => '0',
+            'group'      => 'system',
+            'uid'        => '0',
+            'user'       => 'root',
+            'privileged' => 'true'
+        }
+      elsif agent['platform'] =~ /osx-/
+        expected_identity = {
+            'gid'        => '0',
+            'group'      => 'wheel',
+            'uid'        => '0',
+            'user'       => 'root',
+            'privileged' => 'true'
+        }
+      else
+        expected_identity = {
+            'gid'        => '0',
+            'group'      => 'root',
+            'uid'        => '0',
+            'user'       => 'root',
+            'privileged' => 'true'
+        }
+      end
+
+      on(agent, facter('--json')) do |facter_result|
+        results = JSON.parse(facter_result.stdout)
+        expected_identity.each do |fact, value|
+          assert_match(value, results['identity'][fact].to_s, "Incorrect fact value for identity.#{fact}")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/facts/mountpoints_fact.rb

@@ -0,0 +1,12 @@
+test_name '(FACT-1964) Facter mountpoints does not show rootfs as type for root directory' do
+
+  confine :to, :platform => /el/
+
+  agents.each do |agent|
+    step 'Ensure that mountpoints does not contain rootfs as type for root directory' do
+      on(agent, facter("mountpoints")) do |facter_result|
+        assert_no_match(/rootfs/, facter_result.stdout.chomp, "Expected mountpoint with rootfs type to not be present")
+      end
+    end
+  end
+end

data/acceptance/tests/facts/networking_facts.rb

@@ -0,0 +1,93 @@
+test_name 'C59029: networking facts should be fully populated' do
+  tag 'risk:high'
+
+#
+# This test is intended to ensure that networking facts resolves
+# as expected across supported platforms.
+#
+
+  @ip_regex       = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/
+  @netmask_regex  = /^(((128|192|224|240|248|252|254)\.0\.0\.0)|(255\.(0|128|192|224|240|248|252|254)\.0\.0)|(255\.255\.(0|128|192|224|240|248|252|254)\.0)|(255\.255\.255\.(0|128|192|224|240|248|252|254)))$/
+
+  expected_networking = {
+      "networking.dhcp"     => @ip_regex,
+      "networking.ip"       => @ip_regex,
+      "networking.ip6"      => /[a-f0-9]+:+/,
+      "networking.mac"      => /[a-f0-9]{2}:/,
+      "networking.mtu"      => /\d+/,
+      "networking.netmask"  => @netmask_regex,
+      "networking.netmask6" => /[a-f0-9]+:/,
+      "networking.network"  => @ip_regex,
+      "networking.network6" => /([a-f0-9]+)?:([a-f0-9]+)?/
+  }
+
+  agents.each do |agent|
+    primary_interface = fact_on(agent, 'networking.primary')
+    refute_empty(primary_interface)
+
+    expected_bindings = {
+        "networking.interfaces.#{primary_interface}.bindings.0.address" => @ip_regex,
+        "networking.interfaces.#{primary_interface}.bindings.0.netmask" => @netmask_regex,
+        "networking.interfaces.#{primary_interface}.bindings.0.network" => @ip_regex,
+        "networking.interfaces.#{primary_interface}.bindings6.0.address" => /[a-f0-9:]+/,
+        "networking.interfaces.#{primary_interface}.bindings6.0.netmask" => /[a-f0-9:]+/,
+        "networking.interfaces.#{primary_interface}.bindings6.0.network" => /[a-f0-9:]+/
+    }
+
+    if agent['platform'] =~ /eos|solaris|aix|cisco/
+      #remove the invalid networking facts on eccentric platforms
+      expected_networking.delete("networking.ip6")
+      expected_networking.delete("networking.netmask6")
+      expected_networking.delete("networking.network6")
+
+      #remove invalid bindings for the primary networking interface eccentric platforms
+      expected_bindings.delete("networking.interfaces.#{primary_interface}.bindings6.0.address")
+      expected_bindings.delete("networking.interfaces.#{primary_interface}.bindings6.0.netmask")
+      expected_bindings.delete("networking.interfaces.#{primary_interface}.bindings6.0.network")
+    end
+
+    if agent['platform'] =~ /aix|sparc|cisco|huawei|sles|s390x/
+      # some of our testing platforms do not use DHCP
+      expected_networking.delete("networking.dhcp")
+    end
+
+    if agent['platform'] =~ /cisco/
+      # Cisco main interface does not define netmask or network
+      expected_networking.delete("networking.network")
+      expected_networking.delete("networking.netmask")
+
+      #remove invalid bindings for Cisco's primary networking interface
+      expected_bindings.delete("networking.interfaces.#{primary_interface}.bindings.0.netmask")
+      expected_bindings.delete("networking.interfaces.#{primary_interface}.bindings.0.network")
+    end
+
+    step "Ensure the Networking fact resolves with reasonable values for at least one interface" do
+      expected_networking.each do |fact, value|
+        assert_match(value, fact_on(agent, fact).to_s)
+      end
+    end
+
+    step "Ensure bindings for the primary networking interface are present" do
+      expected_bindings.each do |fact, value|
+        assert_match(value, fact_on(agent, fact).to_s)
+      end
+    end
+  end
+
+  # Verify that IP Address v6 and network v6 is retrieved correctly and does not contain the interface identifier
+  agents.each do |agent|
+    if agent['platform'] =~ /windows/
+      step("verify that ipaddress6 is retrieved correctly") do
+        on(agent, facter("ipaddress6")) do |facter_result|
+          assert_match(/^[a-fA-F0-9:]+$/, facter_result.stdout.chomp)
+        end
+      end
+
+      step("verify that network6 is retrieved correctly") do
+        on(agent, facter("network6")) do |facter_result|
+          assert_match(/([a-fA-F0-9:]+)?:([a-fA-F0-9:]+)?$/, facter_result.stdout.chomp)
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/facts/nim_type.rb

@@ -0,0 +1,12 @@
+test_name "Test nim_type fact" do
+
+  confine :to, :platform => /aix/
+
+  agents.each do |agent|
+    step("verify that nim_type is retrieved correctly") do
+      on(agent, facter("nim_type")) do |facter_result|
+        assert_equal("standalone", facter_result.stdout.chomp)
+      end
+    end
+  end
+end

data/acceptance/tests/facts/non_root_users_without_errors.rb

@@ -0,0 +1,32 @@
+test_name "C59196: running facter as a non-root user should not produce permission errors" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'windows' # this test currently only supported on unix systems FACT-1647
+  confine :except, :platform => 'aix' # system su(1) command prints errors cannot access parent directories and ticket FACT-1586
+  confine :except, :platform => 'cisco' # system su(1) command prints errors cannot access parent directories
+  confine :except, :platform => 'osx' # system su(1) command prints errors cannot access parent directories
+  confine :except, :platform => 'solaris' # system su(1) command prints errors cannot access parent directories
+  confine :except, :platform => 'eos-' # does not support user creation ARISTA-37
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    non_root_user = "nonroot"
+    facter_path = on(agent, "which facter").stdout.chomp
+
+    step "Agent #{agent}: create a #{non_root_user} user to run facter with" do
+      on(agent, "puppet resource user #{non_root_user} ensure=present shell='#{user_shell(agent)}'")
+    end
+
+    teardown do
+      on(agent, puppet("resource user #{non_root_user} ensure=absent"))
+    end
+
+    step "Agent #{agent}: run facter as #{non_root_user} and get no errors" do
+      on(agent, %Q[su #{non_root_user} -c "'#{facter_path}'"]) do |facter_results|
+        assert_empty(facter_results.stderr.chomp, "Expected no errors from facter when run as user #{non_root_user}")
+      end
+    end
+  end
+end

data/acceptance/tests/facts/operatingsystem_detection_after_clear_on_ubuntu.rb

@@ -0,0 +1,26 @@
+test_name 'C14891: Facter should properly detect operatingsystem on Ubuntu after a Facter.clear' do
+  tag 'risk:high'
+
+  confine :to, :platform => /ubuntu/
+
+  require "puppet/acceptance/common_utils"
+
+  script_contents = <<-OS_DETECT
+  require 'facter'
+  Facter['operatingsystem'].value
+  Facter.clear
+  exit Facter['operatingsystem'].value == 'Ubuntu'
+  OS_DETECT
+
+  agents.each do |agent|
+    script_dir = agent.tmpdir('ubuntu')
+    script_name = File.join(script_dir, "facter_os_detection_test")
+    create_remote_file(agent, script_name, script_contents)
+
+    teardown do
+      on(agent, "rm -rf '#{script_dir}'")
+    end
+
+    on(agent, "#{Puppet::Acceptance::CommandUtils.ruby_command(agent)} #{script_name}", :acceptable_exit_codes => 0)
+  end
+end

data/acceptance/tests/facts/os_processors_and_kernel.rb

@@ -0,0 +1,20 @@
+test_name 'C100193: Facter os, processors, and kernel facts resolve on all platforms' do
+  tag 'risk:high'
+
+  require 'json'
+  require 'facter/acceptance/base_fact_utils'
+  extend Facter::Acceptance::BaseFactUtils
+
+  agents.each do |agent|
+    step 'Ensure the os, processors, and kernel fact resolves as expected' do
+      expected_facts = os_processors_and_kernel_expected_facts(agent)
+      on(agent, facter('--json')) do |facter_result|
+        results = JSON.parse(facter_result.stdout)
+        expected_facts.each do |fact, value|
+          actual_fact = json_result_fact_by_key_path(results, fact)
+          assert_match(value, actual_fact.to_s, "Incorrect fact value for #{fact}")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/facts/osx_numeric_hostname.rb

@@ -0,0 +1,23 @@
+test_name 'Querying the fqdn with a numeric hostname should not fail' do
+
+  # calling getaddrinfo with a numeric value on OS X does not fill the
+  # ai_canonname field of the addrinfo structure
+  confine :to, :platform => /^osx-/
+
+  agents.each do |agent|
+    original_hostname = agent.hostname.split('.').first
+    numeric_hostname = 42
+
+    teardown do
+      on(agent, "scutil --set HostName #{original_hostname}")
+    end
+
+    step "Change hostname from '#{original_hostname}' to '#{numeric_hostname}'" do
+      on(agent, "scutil --set HostName #{numeric_hostname}")
+    end
+
+    step 'Verify fqdn fact does not fail' do
+      on(agent, facter('fqdn'))
+    end
+  end
+end

data/acceptance/tests/facts/partitions.rb

@@ -0,0 +1,37 @@
+test_name "C96148: verify partitions facts" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'osx' # no partitions on osx
+  confine :except, :platform => 'windows' # no partitions on windows
+  confine :except, :platform => 'solaris' # no partitions on solaris
+
+  require 'json'
+
+  possible_facts = [
+      ['backing_file', /^\/.*/],
+      ['filesystem', /\w/],
+      ['uuid', /^[-a-zA-Z0-9]+$/],
+      ['partuuid', /^[-a-f0-9]+$/],
+      ['mount', /^\/.*/],
+      ['label', /.*/],
+      ['partlabel', /\w+/],
+  ]
+
+  agents.each do |agent|
+    step("verify that partitions contain facts") do
+      on(agent, facter("--json partitions")) do |facter_output|
+        facter_results = JSON.parse(facter_output.stdout)
+        facter_results['partitions'].each_key do |partition_name|
+          partition_facts = facter_results['partitions'][partition_name]
+          assert_match(/\d+\.\d+ [TGMK]iB/, partition_facts['size'], "Expected partition '#{partition_name}' fact 'size' to match expression")
+          assert(partition_facts['size_bytes'] >= 0, "Expected partition '#{partition_name}' fact 'size_bytes' to be positive")
+          possible_facts.each do |fact, expression|
+            unless partition_facts[fact].nil?
+              assert_match(expression, partition_facts[fact], "Expected partition '#{partition_name}' fact '#{fact}' to match expression")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/facts/productname.rb

@@ -0,0 +1,15 @@
+test_name "C89604: verify productname fact" do
+  tag 'risk:low'
+
+  confine :except, :platform => 'aix' # not supported on
+  confine :except, :platform => 'huawei' # not supported on
+  confine :except, :platform => 'ppc64' # not supported on linux on powerpc
+
+  agents.each do |agent|
+    step("verify the fact productname") do
+      on(agent, facter("productname")) do |facter_result|
+        assert_match(/\w+/, facter_result.stdout.chomp, "Expected fact 'productname' to be set")
+      end
+    end
+  end
+end

data/acceptance/tests/facts/ruby.rb

@@ -0,0 +1,59 @@
+test_name "C100305: The Ruby fact should resolve as expected in AIO" do
+  tag 'risk:high'
+
+#
+# This test is intended to ensure that the the ruby fact resolves
+# as expected in AIO across supported platforms.
+#
+  skip_test "Ruby fact test is confined to AIO" if @options[:type] != 'aio'
+
+  require 'json'
+  require 'facter/acceptance/base_fact_utils'
+  extend Facter::Acceptance::BaseFactUtils
+
+  agents.each do |agent|
+    step "Ensure the Ruby fact resolves as expected" do
+      case agent['platform']
+        when /windows/
+          ruby_platform = agent['ruby_arch'] == 'x64' ? 'x64-mingw32' : 'i386-mingw32'
+        when /osx/
+          ruby_platform = /x86_64-darwin[\d.]+/
+        when /aix/
+          ruby_platform = /powerpc-aix[\d.]+/
+        when /solaris/
+          if agent['platform'] =~ /sparc/
+            ruby_platform = /sparc-solaris[\d.]+/
+          else
+            ruby_platform = /i386-solaris[\d.]+/
+          end
+        when /cisco_ios_xr/
+          ruby_platform = /x86_64-linux/
+        when /huaweios/
+          ruby_platform = /powerpc-linux/
+        else
+          if agent['ruby_arch']
+            ruby_platform = agent['ruby_arch'] == 'x64' ? /(x86_64|powerpc64le|aarch64)-linux/ : /(i486|i686|s390x)-linux/
+          else
+            ruby_platform = agent['platform'] =~ /64/ ? /(x86_64|powerpc64le|aarch64)-linux/ : /(i486|i686|s390x)-linux/
+          end
+      end
+
+      ruby_version   = /2\.\d+\.\d+/
+      expected_facts = {
+          'ruby.platform' => ruby_platform,
+          'ruby.sitedir'  => /\/site_ruby/,
+          'ruby.version'  => ruby_version
+      }
+
+      step("verify that ruby structured fact contains facts") do
+        on(agent, facter("--json ruby")) do |facter_results|
+          json_facts = JSON.parse(facter_results.stdout)
+          expected_facts.each do |fact, value|
+            actual_fact = json_result_fact_by_key_path(json_facts, fact)
+            assert_match(value, actual_fact.to_s, "Incorrect fact pattern for '#{fact}'")
+          end
+        end
+      end
+    end
+  end
+end