cfacter 3.11.0.rc.20180314

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_cached_facts_expire_facts_do_not_read_the_old_cached_value.rb

@@ -0,0 +1,58 @@
+# This test verifies that expired cached facts are not used
+test_name "C100037: ttls configured cached valued that are expired are not returned" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  cached_fact_value = "CACHED_FACT_VALUE"
+  cached_fact_content = <<EOM
+{
+  "#{cached_factname}": "#{cached_fact_value}"
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      # Setup facter conf
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      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 "should not read from a cached JSON file for a fact that has been cached but the TTL expired" do
+        # Setup a known cached fact
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, facter(""))
+        create_remote_file(agent, cached_fact_file, cached_fact_content)
+        # Change the modified date to sometime in the far distant past
+        on(agent, "touch -mt 198001010000 '#{cached_fact_file}'")
+
+        on(agent, facter("#{cached_factname}")) do |facter_output|
+          assert_not_match(/#{cached_fact_value}/, facter_output.stdout, "Expected fact to not match the cached fact file")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_cached_facts_expire_facts_refresh_the_cached_value.rb

@@ -0,0 +1,61 @@
+# This test verifies that cached facts that are expired are refreshed
+test_name "C100040: ttls configured facts that are expired are refreshed" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  cached_fact_value = "EXPIRED_CACHED_FACT_VALUE"
+  cached_fact_content = <<EOM
+{
+  "#{cached_factname}": "#{cached_fact_value}"
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      # Setup facter conf
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      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 "should refresh an expired cached fact" do
+        # Setup a known cached fact
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, facter(""))
+        create_remote_file(agent, cached_fact_file, cached_fact_content)
+        # Change the modified date to sometime in the far distant past
+        on(agent, "touch -mt 198001010000 '#{cached_fact_file}'")
+        # Force facter to recache
+        on(agent, facter("#{cached_factname}"))
+
+        # Read cached fact file content
+        on(agent, "cat #{cached_fact_file}", :acceptable_exit_codes => [0]) do |cat_output|
+          assert_no_match(/#{cached_fact_value}/, cat_output.stdout, "Expected cached fact file to be refreshed")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_cached_facts_read_from_the_cached_value.rb

@@ -0,0 +1,57 @@
+# This test verifies that cached facts are used while still valid
+test_name "C100041: ttls configured cached facts are used while still valid" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  cached_fact_value = "CACHED_FACT_VALUE"
+  cached_fact_content = <<EOM
+{
+  "#{cached_factname}": "#{cached_fact_value}"
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      # Setup facter conf
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      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 "should read from a cached JSON file for a fact that has been cached" do
+        # Setup a known cached fact
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, facter(""))
+        create_remote_file(agent, cached_fact_file, cached_fact_content)
+
+        on(agent, facter("#{cached_factname} --debug")) do
+          assert_match(/loading cached values for .+ facts/, stderr, "Expected debug message to state that values are read from cache")
+          assert_match(/#{cached_fact_value}/, stdout, "Expected fact to match the cached fact file")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_cached_facts_that_are_corrupt_are_refreshed.rb

@@ -0,0 +1,53 @@
+# This test verifies that corrupt facts are refreshed with new values
+test_name "C100042: ttls configured cached facts that are corrupt are refreshed with new values" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      # Setup facter conf
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      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 "should refresh a cached fact if cache file is corrupt" do
+        # Setup a known cached fact
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, facter(""))
+        # Corrupt the cached fact file
+        create_remote_file(agent, cached_fact_file, 'ThisIsNotvalidJSON')
+
+        on(agent, facter("#{cached_factname}")) do
+          assert_match(/.+/, stdout, "Expected fact to be resolved")
+        end
+        on(agent, "cat #{cached_fact_file}", :acceptable_exit_codes => [0]) do |cat_output|
+          assert_match(/#{cached_factname}/, cat_output.stdout, "Expected cachced fact to contain the fact name")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_cached_facts_that_are_empty_return_an_empty_value.rb

@@ -0,0 +1,53 @@
+# This test verifies that cached facts that are empty return an empty string
+test_name "C100043: ttls configured cached facts that are empty, return an empty string" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  empty_cached_fact_content = <<EOM
+{ }
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      # Setup facter conf
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      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 "should return an empty string for an empty JSON document" do
+        # Setup a known cached fact
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, facter(""))
+        create_remote_file(agent, cached_fact_file, empty_cached_fact_content)
+
+        on(agent, facter("#{cached_factname}")) do |facter_output|
+          assert_empty(facter_output.stdout.chomp, "Expected fact to be empty")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_puppet_facts_creates_json_for_cached_facts.rb

@@ -0,0 +1,45 @@
+# Verify that setting a ttls, creates a json file for the cached fact when run
+# from puppet facts
+test_name "C100038: with ttls configured create cached facts when run from puppet facts" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      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")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      on(agent, "mkdir -p '#{facter_conf_default_dir}'")
+      create_remote_file(agent, facter_conf_default_path, config)
+
+      teardown do
+        on(agent, "rm -rf '#{cached_facts_dir}' '#{facter_conf_default_dir}'", :acceptable_exit_codes => [0, 1])
+      end
+
+      step "should create a JSON file for a fact that is to be cached" do
+        on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+        on(agent, puppet("facts --debug")) do |pupppet_fact_output|
+          assert_match(/caching values for .+ facts/, pupppet_fact_output.stdout, "Expected debug message to state that values will be cached")
+        end
+        on(agent, "cat #{cached_fact_file}", :acceptable_exit_codes => [0]) do |cat_output|
+          assert_match(/#{cached_factname}/, cat_output.stdout, "Expected cached fact file to contain fact information")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/ttls_puppet_facts_honors_cached_facts.rb

@@ -0,0 +1,54 @@
+# Verify that setting a ttls, puppet facts returns the cached value of the fact
+test_name "C100039: ttls configured cached facts run from puppet facts return cached facts" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # This fact must be resolvable on ALL platforms
+  # Do NOT use the 'kernel' fact as it is used to configure the tests
+  cached_factname = 'uptime'
+  config = <<EOM
+facts : {
+    ttls : [
+        { "#{cached_factname}" : 30 days }
+    ]
+}
+EOM
+
+  cached_value = "CACHED_FACT_VALUE"
+  cached_fact_content = <<EOM
+{
+  "#{cached_factname}": "#{cached_value}"
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      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")
+      cached_facts_dir = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      cached_fact_file = File.join(cached_facts_dir, cached_factname)
+
+      on(agent, "mkdir -p '#{facter_conf_default_dir}'")
+      create_remote_file(agent, facter_conf_default_path, config)
+
+      teardown do
+        on(agent, "rm -rf '#{cached_facts_dir}' '#{facter_conf_default_dir}'", :acceptable_exit_codes => [0, 1])
+      end
+
+      step "should read from a cached JSON file for a fact that has been cached" do
+        step "call puppet facts to setup the cached fact" do
+          on(agent, "rm -rf '#{cached_facts_dir}'", :acceptable_exit_codes => [0, 1])
+          on(agent, puppet("facts"))
+          create_remote_file(agent, cached_fact_file, cached_fact_content)
+        end
+
+        on(agent, puppet("facts --debug")) do |puppet_facts_output|
+          assert_match(/loading cached values for .+ facts/, puppet_facts_output.stdout, "Expected debug message to state that values are read from cache")
+          assert_match(/#{cached_value}/, puppet_facts_output.stdout, "Expected fact to match the cached fact file")
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/options/config_file/verbose.rb

@@ -0,0 +1,34 @@
+# This test is intended to demonstrate that setting cli.verbose to true in the 
+# config file causes INFO level logging to output to stderr.
+test_name "C99989: verbose config field prints verbose information to stderr" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  config = <<EOM
+cli : {
+    verbose : true
+}
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+      config_file = File.join(config_dir, "facter.conf")
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+
+      teardown do
+        on(agent, "rm -rf '#{config_dir}'", :acceptable_exit_codes => [0,1])
+      end
+
+      step "debug output should print when config file is loaded" do
+        on(agent, facter("")) do |facter_output|
+          assert_match(/INFO/, facter_output.stderr, "Expected stderr to contain verbose (INFO) statements")
+        end
+      end
+    end
+  end
+end
+

data/ext/facter/facter/acceptance/tests/options/custom_facts.rb

@@ -0,0 +1,34 @@
+# This test checks that we can call facter with a --custom-dir and get a custom fact
+# from that directory
+test_name "C14905: custom fact command line option --custom-dir loads custom fact" do
+  tag 'risk:low'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  content = <<EOM
+Facter.add('custom_fact') do
+  setcode do
+    "single_fact"
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create custom fact directory and a custom fact" do
+      custom_dir = agent.tmpdir('custom_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}: --custom-dir option should resolve custom facts from the specific directory" do
+        on(agent, facter("--custom-dir '#{custom_dir}' custom_fact")) do |facter_output|
+          assert_equal("single_fact", facter_output.stdout.chomp, "Incorrect custom fact value")
+        end
+      end
+    end
+  end
+end