facter 4.0.26 → 4.0.28

data/acceptance/tests/options/custom_facts_facterlib.rb

@@ -0,0 +1,33 @@
+# This test verifies that we can load a custom fact using the environment variable FACTERLIB
+test_name "C14779: custom facts are loaded from the environment variable FACTERLIB path" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content = <<EOM
+Facter.add('custom_fact') do
+  setcode do
+    "facterlib"
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create custom directory and fact" do
+      custom_dir = agent.tmpdir('facter_lib_dir')
+      custom_fact = File.join(custom_dir, 'custom_fact.rb')
+      create_remote_file(agent, custom_fact, content)
+
+      teardown do
+        on(agent, "rm -rf '#{custom_dir}'")
+      end
+
+      step "Agent #{agent}: facter should resolve a fact from the directory specified by the environment variable FACTERLIB" do
+        on(agent, facter('custom_fact', :environment => { 'FACTERLIB' => custom_dir })) do |facter_output|
+          assert_equal("facterlib", facter_output.stdout.chomp, "Incorrect custom fact value for fact in FACTERLIB")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/options/custom_facts_list.rb

@@ -0,0 +1,48 @@
+# facter should be able to be called with multiple --custom-dir's and find a fact in each
+# directory specified
+test_name "C99999: custom fact commandline option --custom-dir can be specified multiple times" do
+  tag 'risk:high'
+
+  require 'json'
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content_1 = <<EOM
+Facter.add('custom_fact_1') do
+  setcode do
+    "testvalue_1"
+  end
+end
+EOM
+
+  content_2 = <<EOM
+Facter.add('custom_fact_2') do
+  setcode do
+    "testvalue_2"
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create custom fact directory and a custom fact in each" do
+      custom_dir_1 = agent.tmpdir('custom_dir_1')
+      custom_dir_2 = agent.tmpdir('custom_dir_2')
+      custom_fact_1 = File.join(custom_dir_1, 'custom_fact.rb')
+      custom_fact_2 = File.join(custom_dir_2, 'custom_fact.rb')
+      create_remote_file(agent, custom_fact_1, content_1)
+      create_remote_file(agent, custom_fact_2, content_2)
+
+      teardown do
+        on(agent, "rm -rf '#{custom_dir_1}' '#{custom_dir_2}'")
+      end
+
+      step "Agent #{agent}: resolve a fact from each specified --custom-dir option" do
+        on(agent, facter("--custom-dir #{custom_dir_1} --custom-dir #{custom_dir_2} --json")) do |facter_output|
+          results = JSON.parse(facter_output.stdout)
+          assert_equal("testvalue_1", results['custom_fact_1'], "Incorrect custom fact value for custom_fact_1")
+          assert_equal("testvalue_2", results['custom_fact_2'], "Incorrect custom fact value for custom_fact_2")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/options/custom_facts_load_path.rb

@@ -0,0 +1,42 @@
+# This test verifies that we can load a custom fact using the ruby $LOAD_PATH variable
+#
+# Facter searches all directories in the Ruby $LOAD_PATH variable for subdirectories
+# named ‘facter’, and loads all Ruby files in those directories.
+test_name "C14777: custom facts loaded from facter subdirectory found in $LOAD_PATH directory" do
+  confine :except, :platform => 'cisco_nexus' # see BKR-749
+
+  tag 'risk:medium'
+
+  require 'puppet/acceptance/common_utils'
+  extend Puppet::Acceptance::CommandUtils
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content = <<EOM
+Facter.add('custom_fact') do
+  setcode do
+    "load_path"
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: determine $LOAD_PATH and create custom fact" do
+      on(agent, "#{ruby_command(agent)} -e 'puts $LOAD_PATH[0]'")
+      load_path_facter_dir = File.join(stdout.chomp, 'facter')
+      on(agent, "mkdir -p \"#{load_path_facter_dir}\"")
+      custom_fact = File.join(load_path_facter_dir, 'custom_fact.rb')
+      create_remote_file(agent, custom_fact, content)
+
+      teardown do
+        on(agent, "rm -rf '#{load_path_facter_dir}'")
+      end
+
+      step("Agent #{agent}: resolve the custom fact that is in a facter directory on the $LOAD_PATH")
+      on(agent, facter("custom_fact")) do |facter_output|
+        assert_equal("load_path", facter_output.stdout.chomp, "Incorrect custom fact value for fact in $LOAD_PATH/facter")
+      end
+    end
+  end
+end

data/acceptance/tests/options/debug.rb

@@ -0,0 +1,12 @@
+# This test is intended to ensure that the --debug command-line option works
+# properly. This option prints debugging information to stderr.
+test_name "C63191: --debug command-line option prints debugging information to stderr" do
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve debug info from stderr using --debug option" do
+      on(agent, facter('--debug')) do
+        assert_match(/DEBUG/, stderr, "Expected DEBUG information in stderr")
+      end
+    end
+  end
+end

data/acceptance/tests/options/external_facts.rb

@@ -0,0 +1,28 @@
+# This tests checks that we can call facter with a --external-dir and get an external fact
+# from that directory
+test_name "C99974: external fact commandline options --external-dir resolves an external fact" do
+  tag 'risk:low'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    step "Agent #{agent}: create an external fact directory with an external fact" do
+      external_dir = agent.tmpdir('external_dir')
+      ext = get_external_fact_script_extension(agent['platform'])
+      external_fact = File.join(external_dir, "external_fact#{ext}")
+      create_remote_file(agent, external_fact, external_fact_content(agent['platform'], 'single_fact', 'external_value'))
+      on(agent, "chmod +x '#{external_fact}'")
+
+      teardown do
+        on(agent, "rm -rf '#{external_dir}'")
+      end
+
+      step "Agent #{agent}: resolve a fact from each specified --external_dir option" do
+        on(agent, facter("--external-dir #{external_dir} single_fact")) do |facter_output|
+          assert_equal("external_value", facter_output.stdout.chomp, "Incorrect external fact value")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/options/external_facts_list.rb

@@ -0,0 +1,35 @@
+# facter should be able to be called with multiple --external-dir's and find a fact in each
+# directory specified
+
+test_name "C99998: external fact commandline option --external-dir can be specified multiple times" do
+  tag 'risk:high'
+
+  require 'json'
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    step "Agent #{agent}: create external fact directories and a external fact in each" do
+      external_dir_1 = agent.tmpdir('external_dir_1')
+      external_dir_2 = agent.tmpdir('external_dir_2')
+      ext = get_external_fact_script_extension(agent['platform'])
+      external_fact_1 = File.join(external_dir_1, "external_fact#{ext}")
+      external_fact_2 = File.join(external_dir_2, "external_fact#{ext}")
+      create_remote_file(agent, external_fact_1, external_fact_content(agent['platform'], 'external_fact_1', 'external_value_1'))
+      create_remote_file(agent, external_fact_2, external_fact_content(agent['platform'], 'external_fact_2', 'external_value_2'))
+      on(agent, "chmod +x '#{external_fact_1}' '#{external_fact_2}'")
+
+      teardown do
+        on(agent, "rm -rf '#{external_dir_1}' '#{external_dir_2}'")
+      end
+
+      step "Agent #{agent}: resolve a fact from each specified --external_dir option" do
+        on(agent, facter("--external-dir #{external_dir_1} --external-dir #{external_dir_2} --json")) do |facter_output|
+          results = JSON.parse(facter_output.stdout)
+          assert_equal("external_value_1", results['external_fact_1'], "Incorrect external fact value for external_fact_1")
+          assert_equal("external_value_2", results['external_fact_2'], "Incorrect external fact value for external_fact_2")
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/options/help.rb

@@ -0,0 +1,13 @@
+# This test is intended to ensure that the --help command-line option works
+# properly. This option prints usage information and available command-line
+# options.
+test_name "C99984: --help command-line option prints usage information to stdout" do
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve usage info from stdout using --help option" do
+      on(agent, facter('--help')) do
+        assert_match(/(facter|facter-ng) \[options\] \[query\] \[query\] \[...\]/, stdout, "Expected stdout to contain usage information")
+      end
+    end
+  end
+end

data/acceptance/tests/options/json.rb

@@ -0,0 +1,43 @@
+# This test is intended to ensure that the --json command-line option works
+# properly. This option causes Facter to output facts in JSON format.
+# A custom fact is used to test for parity between Facter's output and
+# the expected JSON output.
+test_name "C99966, C98083: --json command-line option results in valid JSON output" do
+
+  require 'json'
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content = <<EOM
+Facter.add('structured_fact') do
+  setcode do
+    { "foo" => {"nested" => "value1"}, "bar" => "value2", "baz" => "value3", "true" => true, "false" => false }
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create a structured custom fact" do
+      custom_dir = get_user_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      custom_fact = File.join(custom_dir, 'custom_fact.rb')
+      on(agent, "mkdir -p '#{custom_dir}'")
+      create_remote_file(agent, custom_fact, content)
+      on(agent, "chmod +x '#{custom_fact}'")
+
+      teardown do
+        on(agent, "rm -f '#{custom_fact}'")
+      end
+
+      step "Agent #{agent}: retrieve output using the --json option" do
+        on(agent, facter("--custom-dir '#{custom_dir}' --json structured_fact")) do
+          begin
+            expected = {"structured_fact" => {"foo" => {"nested" => "value1"}, "bar" => "value2", "baz" => "value3", "true" => true, "false" => false}}
+            assert_equal(expected, JSON.parse(stdout.chomp), "JSON output does not match expected output")
+          rescue
+            fail_test "Couldn't parse output as JSON"
+          end
+        end
+      end
+    end
+  end
+end

data/acceptance/tests/options/list_block_groups.rb

@@ -0,0 +1,15 @@
+# This tests is intended to verify that passing the `--list-block-groups` flag
+# will cause the names of blockable resolvers to be printed to stdout. It should not list
+# any resolver name that is not blockable.
+test_name "C99969: the `--list-block-groups` command line flag prints available block groups to stdout" do
+  tag 'risk:medium', 'facter_3'
+
+  agents.each do |agent|
+    step "the EC2 blockgroup should be listed" do
+      on(agent, facter("--list-block-groups")) do |facter_output|
+        assert_match(/EC2/, facter_output.stdout, "Expected the EC2 group to be listed")
+        assert_match(/ec2_metadata/, facter_output.stdout, "Expected the EC2 group's facts to be listed")
+      end
+    end
+  end
+end

data/acceptance/tests/options/list_block_groups_facter_4.rb

@@ -0,0 +1,15 @@
+# This tests is intended to verify that passing the `--list-block-groups` flag
+# will cause the names of blockable resolvers to be printed to stdout. It should not list
+# any resolver name that is not blockable.
+test_name "the `--list-block-groups` command line flag prints available block groups to stdout" do
+  tag 'risk:medium'
+
+  agents.each do |agent|
+    step "the EC2 blockgroup should be listed" do
+      on(agent, facter("--list-block-groups")) do |facter_output|
+        assert_match(/EC2/, facter_output.stdout, "Expected the EC2 group to be listed")
+        assert_match(/ec2_metadata/, facter_output.stdout, "Expected the EC2 group's facts to be listed")
+      end
+    end
+  end
+end

data/acceptance/tests/options/list_cache_groups.rb

@@ -0,0 +1,65 @@
+# This tests is intended to verify that passing the `--list-cache-groups` flag
+# will cause the names of cacheable resolvers to be printed to stdout.
+test_name "C99970: the `--list-cache-groups` command line flag prints available cache groups to stdout" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    external_dir = agent.tmpdir('external_dir')
+    etc_factsd_dir = get_etc_factsd_dir(agent['platform'])
+    filename = "test.yaml"
+    etc_factsd_path = "#{etc_factsd_dir}/#{filename}"
+
+    teardown do
+      on(agent, "rm -rf '#{external_dir}' '#{etc_factsd_path}'")
+    end
+
+    step "the various cache groups should be listed" do
+      on(agent, facter("--list-cache-groups")) do |facter_output|
+        assert_match(/EC2/, facter_output.stdout, "EC2 group should be listed as cacheable")
+        assert_match(/ec2_metadata/, facter_output.stdout, "EC2 group's facts should be listed")
+        assert_match(/kernel/, facter_output.stdout, "kernel group should be listed as cacheable")
+        assert_match(/kernelversion/, facter_output.stdout, "kernel group's facts should be listed as cacheable")
+      end
+    end
+
+    step "the various external facts file should be visible as caching groups" do
+      external_filename = "external_facts_filename"
+      ext = get_external_fact_script_extension(agent['platform'])
+      external_fact_script = File.join(external_dir, "#{external_filename}#{ext}")
+      create_remote_file(agent, external_fact_script, external_fact_content(agent['platform'], "a", "b"))
+      on(agent, "chmod +x '#{external_fact_script}'")
+
+      external_fact_script_txt = File.join(external_dir, "#{external_filename}.txt")
+      create_remote_file(agent, external_fact_script_txt, '')
+
+      external_fact_script_json = File.join(external_dir, "#{external_filename}.json")
+      create_remote_file(agent, external_fact_script_json, '')
+
+      external_fact_script_yaml = File.join(external_dir, "#{external_filename}.yaml")
+      create_remote_file(agent, external_fact_script_yaml, '')
+
+      on(agent, facter("--external-dir #{external_dir} --list-cache-groups")) do |facter_output|
+        assert_match(/#{external_filename}#{ext}/, facter_output.stdout, "external facts script files should be listed as cacheable")
+        assert_match(/#{external_filename}.txt/, facter_output.stdout, "external facts txt files should be listed as cacheable")
+        assert_match(/#{external_filename}.json/, facter_output.stdout, "external facts json files should be listed as cacheable")
+        assert_match(/#{external_filename}.yaml/, facter_output.stdout, "external facts yaml files should be listed as cacheable")
+      end
+      on(agent, "rm -rf '#{external_dir}'")
+    end
+
+    step "external facts groups should be listed only without --no-external-facts" do
+      on(agent, "mkdir -p '#{etc_factsd_dir}'")
+      create_remote_file(agent, etc_factsd_path, 'test_fact: test_value')
+      on(agent, facter("--list-cache-groups")) do |facter_output|
+        assert_match(/#{filename}/, facter_output.stdout, "external facts script files should be listed as cacheable")
+      end
+      on(agent, facter("--list-cache-groups --no-external-facts")) do |facter_output|
+        assert_no_match(/#{filename}/, facter_output.stdout, "external facts script files should now be listed as cacheable when --no-external-facts is used")
+      end
+      on(agent, "rm -f '#{etc_factsd_path}'")
+    end
+  end
+end

data/acceptance/tests/options/log_level.rb

@@ -0,0 +1,13 @@
+# This test is intended to ensure that the --log-level command-line option works
+# properly. This option can be used with an argument to specify the level of logging
+# which will present in Facter's output.
+test_name "C99985: --log-level command-line option can be used to specify logging level" do
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve debug info from stderr using `--log-level debug` option" do
+      on(agent, facter('--log-level debug')) do
+        assert_match(/DEBUG/, stderr, "Expected DEBUG information in stderr")
+      end
+    end
+  end
+end

data/acceptance/tests/options/no_block.rb

@@ -0,0 +1,34 @@
+# This tests is intended to verify that passing the `--no-block` command to facter will prevent
+# fact blocking, despite a blocklist being specified in the config file.
+test_name "C99971: the `--no-block` command line flag prevents facts from being blocked" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    # default facter.conf
+    facter_conf_default_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    facter_conf_default_path = File.join(facter_conf_default_dir, "facter.conf")
+
+    teardown do
+      on(agent, "rm -rf '#{facter_conf_default_dir}'", :acceptable_exit_codes => [0, 1])
+    end
+
+    # create the directories
+    on(agent, "mkdir -p '#{facter_conf_default_dir}'")
+
+    step "Agent #{agent}: create config file" do
+      create_remote_file(agent, facter_conf_default_path, <<-FILE)
+      cli : { debug : true }
+      facts : { blocklist : [ "EC2" ] }
+      FILE
+    end
+
+    step "no facts should be blocked when `--no-block` is specified" do
+      on(agent, facter("--no-block")) do |facter_output|
+        assert_no_match(/blocking collection of .+ facts/, facter_output.stderr, "Expected no facts to be blocked")
+      end
+    end
+  end
+end

data/acceptance/tests/options/no_cache_should_not_cache_facts.rb

@@ -0,0 +1,43 @@
+# This test is intended to verify that the `--no-cache` command line flag will
+# cause facter to not do any caching of facts
+test_name "C99968: --no-cache command-line option causes facter to not cache facts" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # the uptime fact should be resolvable on ALL systems
+  # Note: do NOT use the kernel fact, as it is used to configure the tests
+  cached_fact_name = "uptime"
+  config = <<-FILE
+  cli : { debug : true }
+  facts : { ttls : [ { "#{cached_fact_name}" : 30 minutes } ] }
+  FILE
+
+  agents.each do |agent|
+    kernel_version = on(agent, facter('kernelmajversion')).stdout.chomp.to_f
+    config_dir = get_default_fact_dir(agent['platform'], kernel_version)
+    config_file = File.join(config_dir, "facter.conf")
+
+    cached_facts_dir = get_cached_facts_dir(agent['platform'], kernel_version)
+    cached_fact_file = File.join(cached_facts_dir, cached_fact_name)
+
+    on(agent, "rm -f '#{cached_fact_file}'", :acceptable_exit_codes => [0, 1])
+
+    teardown do
+      on(agent, "rm -rf '#{config_dir}'", :acceptable_exit_codes => [0, 1])
+      on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+    end
+
+    step "Agent #{agent}: create config file in default location" do
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+    end
+
+    step "facter should not cache facts when --no-cache is specified" do
+      on(agent, facter("--no-cache")) do |facter_output|
+        assert_no_match(/caching/, facter_output.stderr, "facter should not have tried to cache any facts")
+      end
+    end
+  end
+end