cfacter 3.11.0.rc.20180314

data/ext/facter/facter/acceptance/tests/external_facts/root_uses_default_external_fact_dir.rb

@@ -0,0 +1,34 @@
+# facter resolves facts from the default facts.d directory
+# on Unix this can be 3 directories (See fact_directory_precedence.rb)
+# Unix - /opt/puppetlabs/facter/facts.d/
+# Windows - C:\ProgramData\PuppetLabs\facter\facts.d\
+test_name "C87571: facter resolves facts in the default facts.d directory" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    os_version = on(agent, facter('kernelmajversion')).stdout.chomp.to_f
+    ext = get_external_fact_script_extension(agent['platform'])
+    factsd = get_factsd_dir(agent['platform'], os_version)
+    fact_file = File.join(factsd, "external_fact_1#{ext}")
+    content = external_fact_content(agent['platform'], 'external_fact', 'external_value')
+
+    teardown do
+      on(agent, "rm -f '#{fact_file}'")
+    end
+
+    step "Agent #{agent}: setup default external facts directory and fact" do
+      on(agent, "mkdir -p '#{factsd}'")
+      create_remote_file(agent, fact_file, content)
+      on(agent, "chmod +x '#{fact_file}'")
+    end
+
+    step "agent #{agent}: resolve the external fact" do
+      on(agent, facter('external_fact')) do |facter_output|
+        assert_equal('external_value', facter_output.stdout.chomp, 'Expected to resolve the external_fact')
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/external_facts/structured_executable_facts.rb

@@ -0,0 +1,139 @@
+# This test is intended to demonstrate that executable external facts can return
+# YAML or JSON data, in addition to plain key-value pairs. If the output cannot be
+# parsed as YAML, it will fall back to key-value pair parsing, and only fail if
+# this is also invalid.
+test_name "executable external facts can return structured data" do
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  unix_fact_yaml = <<EOM
+#!/bin/sh
+echo "yaml_fact: [ 'one', 'two', 'three' ]"
+EOM
+
+  unix_fact_json = <<EOM
+#!/bin/sh
+echo "{ json_fact: { element: 1 } }"
+EOM
+
+  unix_fact_kv = <<EOM
+#!/bin/sh
+echo "kv_fact=one"
+EOM
+
+  unix_fact_bad = <<EOM
+#!/bin/sh
+echo "bad_fact : : not, json"
+EOM
+
+  win_fact_yaml = <<EOM
+@echo off
+echo yaml_fact: [ 'one', 'two', 'three' ]
+EOM
+
+  win_fact_json = <<EOM
+@echo off
+echo { json_fact: { element: 1 } }
+EOM
+
+  win_fact_kv = <<EOM
+@echo off
+echo kv_fact=one
+EOM
+
+  win_fact_bad = <<EOM
+@echo off
+echo bad_fact : : not, json
+EOM
+
+  yaml_structured_output = <<EOM
+[
+  "one",
+  "two",
+  "three"
+]
+EOM
+
+  json_structured_output = <<EOM
+{
+  element => 1
+}
+EOM
+
+  kv_output = 'one'
+
+  agents.each do |agent|
+    os_version = on(agent, facter('kernelmajversion')).stdout.chomp.to_f
+    factsd = get_factsd_dir(agent['platform'], os_version)
+    ext = get_external_fact_script_extension(agent['platform'])
+
+    if agent['platform'] =~ /windows/
+      yaml_content = win_fact_yaml
+      json_content = win_fact_json
+      kv_content = win_fact_kv
+      bad_fact_content = win_fact_bad
+    else
+      yaml_content = unix_fact_yaml
+      json_content = unix_fact_json
+      kv_content = unix_fact_kv
+      bad_fact_content = unix_fact_bad
+    end
+
+    step "Agent #{agent}: setup default external facts directory (facts.d)" do
+      on(agent, "mkdir -p '#{factsd}'")
+    end
+
+    teardown do
+      on(agent, "rm -rf '#{factsd}'")
+    end
+
+    step "Agent #{agent}: create an executable yaml fact in default facts.d" do
+      yaml_fact = File.join(factsd, "yaml_fact#{ext}")
+      create_remote_file(agent, yaml_fact, yaml_content)
+      on(agent, "chmod +x '#{yaml_fact}'")
+
+      step "YAML output should produce a structured fact" do
+        on(agent, facter("yaml_fact")) do
+          assert_match(/#{yaml_structured_output}/, stdout, "Expected properly structured fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create an executable json fact in default facts.d" do
+      json_fact = File.join(factsd, "json_fact#{ext}")
+      create_remote_file(agent, json_fact, json_content)
+      on(agent, "chmod +x '#{json_fact}'")
+
+      step "JSON output should produce a structured fact" do
+        on(agent, facter("json_fact")) do
+          assert_match(/#{json_structured_output}/, stdout, "Expected properly structured fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create an executable key-value fact in default facts.d" do
+      kv_fact = File.join(factsd, "kv_fact#{ext}")
+      create_remote_file(agent, kv_fact, kv_content)
+      on(agent, "chmod +x '#{kv_fact}'")
+
+      step "output that is neither yaml nor json should not produce a structured fact" do
+        on(agent, facter("kv_fact")) do
+          assert_match(/#{kv_output}/, stdout, "Expected a simple key-value fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create a malformed executable fact in default facts.d" do
+      bad_fact = File.join(factsd, "bad_fact#{ext}")
+      create_remote_file(agent, bad_fact, bad_fact_content)
+      on(agent, "chmod +x '#{bad_fact}'")
+
+      step "should error when output is not in a supported format" do
+        on(agent, facter("bad_fact --debug")) do
+          assert_match(/Could not parse executable fact/, stderr, "Expected parsing the malformed fact to fail")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/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/ext/facter/facter/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+/,
+    }
+    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+/,
+                             'dmi.product.uuid'      => /[-0-9A-Fa-f]+/,
+                            })
+    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/ext/facter/facter/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/ext/facter/facter/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/ext/facter/facter/acceptance/tests/facts/networking_facts.rb

@@ -0,0 +1,76 @@
+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))
+      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))
+      end
+    end
+  end
+end

data/ext/facter/facter/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/ext/facter/facter/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/ext/facter/facter/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