facter 4.0.26 → 4.0.28

data/acceptance/tests/custom_facts/custom_fact_with_10001_weight_overrides_external_fact.rb

@@ -0,0 +1,30 @@
+test_name "C100153: custom fact with weight of >= 10001 overrides an external fact" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  fact_name = 'test'
+  # Use a static external fact
+  ext_fact = "#{fact_name}: 'EXTERNAL'"
+
+  agents.each do |agent|
+    facts_dir = agent.tmpdir('facts.d')
+    ext_fact_path = "#{facts_dir}/test.yaml"
+    cust_fact_path = "#{facts_dir}/test.rb"
+    create_remote_file(agent, ext_fact_path, ext_fact)
+    create_remote_file(agent, cust_fact_path, custom_fact_content(fact_name, 'CUSTOM', "has_weight 10001"))
+
+    teardown do
+      on(agent, "rm -rf '#{facts_dir}'")
+    end
+
+    # Custom fact with weight >= 10001 should override an external fact
+    step "Agent #{agent}: resolve a custom fact with weight of 10001 overriding the external fact" do
+      on(agent, facter("--external-dir=#{facts_dir} --custom-dir=#{facts_dir} test")) do |facter_output|
+        assert_equal("CUSTOM", facter_output.stdout.chomp)
+      end
+    end
+  end
+end
+

data/acceptance/tests/custom_facts/expand_command.rb

@@ -0,0 +1,30 @@
+test_name 'FACT-2054: Custom facts that execute a shell command should expand it' do
+  tag 'risk:high'
+
+  confine :to, :platform => /el-7/
+
+  content = <<-EOM
+    Facter.add(:foo) do
+      setcode do
+        Facter::Core::Execution.execute("cd /opt/puppetlabs && pwd")
+      end
+    end
+  EOM
+
+  agents.each do |agent|
+    fact_dir = agent.tmpdir('facter')
+    fact_file = File.join(fact_dir, 'test_facts.rb')
+    create_remote_file(agent, fact_file, content)
+    env = {'FACTERLIB' => fact_dir}
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+    end
+
+    step "Agent: Verify that command is expanded" do
+      on(agent, facter('foo', :environment => env)) do |facter_result|
+        refute_equal('/opt/puppetlabs', facter_result.stdout.chomp, 'command was not expanded')
+      end
+    end
+  end
+end

data/acceptance/tests/custom_facts/having_multiple_facts_in_one_file.rb

@@ -0,0 +1,40 @@
+test_name 'C14893: Facter should handle multiple facts in a single file' do
+  tag 'risk:high'
+
+  fact_content = <<-EOM
+    Facter.add(:test_fact1) do
+      setcode do
+        "test fact 1"
+      end
+    end
+
+    Facter.add(:test_fact2) do
+      setcode do
+        "test fact 2"
+      end
+    end
+  EOM
+
+  agents.each do |agent|
+    fact_dir = agent.tmpdir('facter')
+    fact_file = File.join(fact_dir, 'test_facts.rb')
+    create_remote_file(agent, fact_file, fact_content)
+    env = {'FACTERLIB' => fact_dir}
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+    end
+
+    step "Agent: Verify test_fact1 from #{fact_file}" do
+      on(agent, facter('test_fact1', :environment => env)) do |facter_result|
+        assert_equal('test fact 1', facter_result.stdout.chomp, 'test_fact1 is not the correct value')
+      end
+    end
+
+    step "Agent: Verify test_fact2 from #{fact_file}" do
+      on(agent, facter('test_fact2', :environment => env)) do |facter_result|
+        assert_equal('test fact 2', facter_result.stdout.chomp, 'test_fact2 is not the correct value')
+      end
+    end
+  end
+end

data/acceptance/tests/custom_facts/not_expand_command.rb

@@ -0,0 +1,30 @@
+test_name 'FACT-2054: Custom facts that execute a shell command should not expand it' do
+  tag 'risk:high'
+
+confine :to, :platform => /el-7/
+
+  content = <<-EOM
+    Facter.add(:foo) do
+      setcode do
+        Facter::Core::Execution.execute("cd /opt/puppetlabs && pwd", {:expand => false})
+      end
+    end
+  EOM
+
+  agents.each do |agent|
+    fact_dir = agent.tmpdir('facter')
+    fact_file = File.join(fact_dir, 'test_facts.rb')
+    create_remote_file(agent, fact_file, content)
+    env = {'FACTERLIB' => fact_dir}
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+    end
+
+    step "Agent: Verify that command is not expanded" do
+      on(agent, facter('foo', :environment => env)) do |facter_result|
+        assert_equal('/opt/puppetlabs', facter_result.stdout.chomp, 'command was expanded')
+      end
+    end
+  end
+end

data/acceptance/tests/custom_facts/using_win32ole_should_not_hang.rb

@@ -0,0 +1,33 @@
+test_name 'C92060: Custom facts should not hang Facter when using win32ole' do
+  tag 'risk:high'
+
+  confine :to, :platform => /windows/
+  require 'timeout'
+
+  content = <<-EOM
+    Facter.add('custom_fact') do
+      setcode do
+        require 'win32ole'
+        locator = WIN32OLE.new('WbemScripting.SWbemLocator')
+        locator.ConnectServer('', "root/CIMV2", '', '', nil, nil, nil, nil).to_s
+      end
+    end
+  EOM
+
+  agents.each do |agent|
+    custom_dir  = agent.tmpdir('arbitrary_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
+
+    # Test is assumed to have hung if it takes longer than 5 seconds.
+    Timeout::timeout(5) do
+      on agent, facter('--custom-dir', custom_dir, 'custom_fact') do |facter_result|
+        assert_match(/#<WIN32OLE:0x[0-9a-f]+>/, facter_result.stdout.chomp, 'Custom fact output does not match expected output')
+      end
+    end
+  end
+end

data/acceptance/tests/custom_facts/weighted_cached_custom_facts.rb

@@ -0,0 +1,94 @@
+test_name 'ttls configured weighted custom facts files creates cache file and reads cache file depending on weight' do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  custom_fact_file = 'custom_facts.rb'
+  duplicate_custom_fact_name  = 'random_custom_fact'
+  custom_fact_value = 'custom fact value with weight:'
+
+  fact_content = <<-CUSTOM_FACT
+  Facter.add(:#{duplicate_custom_fact_name}) do
+    has_weight 90
+    setcode do
+      "#{custom_fact_value} 90"
+    end
+  end
+  Facter.add(:#{duplicate_custom_fact_name}) do
+    has_weight 100
+    setcode do
+      "#{custom_fact_value} 100"
+    end
+  end
+  Facter.add(:#{duplicate_custom_fact_name}) do
+    has_weight 110
+    setcode do
+      "#{custom_fact_value} 110"
+    end
+  end
+  CUSTOM_FACT
+
+  cached_file_content_highest_weight = <<~CACHED_FILE
+    {
+      "#{duplicate_custom_fact_name}": "#{custom_fact_value} 110"
+    }
+  CACHED_FILE
+
+  config_data = <<~FACTER_CONF
+    facts : {
+      ttls : [
+          { "cached-custom-facts" : 3 days }
+      ]
+    }
+    fact-groups : {
+      cached-custom-facts : [ "#{duplicate_custom_fact_name}" ]
+    }
+  FACTER_CONF
+
+  agents.each do |agent|
+    cache_folder = get_cached_facts_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    fact_dir = agent.tmpdir('facter')
+    env = { 'FACTERLIB' => fact_dir }
+    config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    config_file = File.join(config_dir, 'facter.conf')
+
+    step "Agent #{agent}: create config file" do
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config_data)
+      fact_file = File.join(fact_dir, custom_fact_file)
+      create_remote_file(agent, fact_file, fact_content)
+    end
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+      on(agent, "rm -rf #{cache_folder}/*")
+      on(agent, "rm -rf #{config_dir}/facter.conf")
+    end
+
+    step "should log that it creates cache file and it caches custom facts found in facter.conf with the highest weight" do
+      on(agent, facter("#{duplicate_custom_fact_name} --debug", environment: env)) do |facter_result|
+        assert_equal(custom_fact_value + " 110", facter_result.stdout.chomp, "#{duplicate_custom_fact_name} value changed")
+        assert_match(/facts cache file expired\/missing/, facter_result.stderr,
+                     'Expected debug message to state that custom facts cache file is missing or expired')
+        assert_match(/Saving cached custom facts to ".+"|caching values for cached-custom-facts facts/, facter_result.stderr,
+                     'Expected debug message to state that custom facts will be cached')
+      end
+    end
+
+    step "should create a cached-custom-facts cache file that containt fact information from the highest weight fact" do
+      result = agent.file_exist?("#{cache_folder}/cached-custom-facts")
+      assert_equal(true, result)
+      on(agent, "cat #{cache_folder}/cached-custom-facts", acceptable_exit_codes: [0]) do |cat_output|
+        assert_match(cached_file_content_highest_weight.chomp, cat_output.stdout, 'Expected cached custom fact file to contain fact information from the highest weight fact')
+      end
+    end
+
+    step 'should read from the cached file for a custom fact that has been cached' do
+      on(agent, facter("#{duplicate_custom_fact_name} --debug", environment: env)) do |facter_result|
+        assert_match(/Loading cached custom facts from file ".+"|loading cached values for cached-custom-facts facts/, facter_result.stderr,
+                     'Expected debug message to state that cached custom facts are read from file')
+      end
+    end
+  end
+end

data/acceptance/tests/custom_facts/windows_not_expand_command.rb

@@ -0,0 +1,30 @@
+test_name 'FACT-2054: Execute on Windows with expand => false should raise an error' do
+  tag 'risk:high'
+
+  confine :to, :platform => /windows/
+
+  content = <<-EOM
+    Facter.add(:foo) do
+      setcode do
+        Facter::Core::Execution.execute("cmd", {:expand => false})
+      end
+    end
+  EOM
+
+  agents.each do |agent|
+    fact_dir = agent.tmpdir('facter')
+    fact_file = File.join(fact_dir, 'test_facts.rb')
+    create_remote_file(agent, fact_file, content)
+    env = {'FACTERLIB' => fact_dir}
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+    end
+
+    step "Agent: Verify that exception is raised" do
+      on(agent, facter('foo', :environment => env), :acceptable_exit_codes => [0, 1]) do |output|
+        assert_match(/Unsupported argument on Windows/, output.stderr, '{:expand => false} on Windows should raise error')
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/env_var_overrides_external_fact.rb

@@ -0,0 +1,46 @@
+test_name 'C100537: FACTER_ env var should override external fact' do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    fact_name      = 'external_fact'
+    fact_value     = 'from_script'
+    override_value = 'override_fact'
+    external_dir   = agent.tmpdir('facts.d')
+    fact_file      = File.join(external_dir,
+                               "#{fact_name}#{get_external_fact_script_extension(agent['platform'])}")
+
+    teardown do
+      on(agent, "rm -rf '#{external_dir}'")
+    end
+
+    step "Agent #{agent}: setup external fact" do
+      on(agent, "mkdir -p '#{external_dir}'")
+      create_remote_file(agent,
+                         fact_file,
+                         external_fact_content(agent['platform'], fact_name, fact_value))
+      on(agent, "chmod +x '#{fact_file}'")
+    end
+
+    step "Agent: #{agent}: ensure external fact resolves correctly" do
+      on(agent, facter("--external-dir '#{external_dir}' #{fact_name}")) do |facter_output|
+        assert_equal(fact_value,
+                     facter_output.stdout.chomp,
+                     'Expected external fact to resolve as defined in script')
+      end
+    end
+
+    step "Agent #{agent}: the fact value from FACTER_ env var should override the external fact value" do
+      on(agent, facter("--external-dir '#{external_dir}' #{fact_name}",
+                       :environment => { "FACTER_#{fact_name}" => override_value })) do |facter_output|
+        assert_equal(override_value,
+                     facter_output.stdout.chomp,
+                     'Expected `FACTER_` fact value to override external fact')
+      end
+    end
+
+  end
+
+end

data/acceptance/tests/external_facts/external_dir_overrides_default_external_fact.rb

@@ -0,0 +1,34 @@
+test_name "C100154: --external-dir fact overrides fact in 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)
+    external_dir = agent.tmpdir('facts.d')
+    fact_file = File.join(factsd, "external_fact#{ext}")
+    content = external_fact_content(agent['platform'], 'external_fact', 'value')
+    override_fact_file = File.join(external_dir, "external_fact#{ext}")
+    override_content = external_fact_content(agent['platform'], 'external_fact', 'OVERRIDE_value')
+
+    teardown do
+      on(agent, "rm -f '#{fact_file}' '#{override_fact_file}'")
+    end
+
+    step "Agent #{agent}: setup default external facts directories and the test facts" do
+      on(agent, "mkdir -p '#{factsd}'")
+      create_remote_file(agent, fact_file, content)
+      create_remote_file(agent, override_fact_file, override_content)
+      on(agent, "chmod +x '#{fact_file}' '#{override_fact_file}'")
+    end
+
+    step "Agent #{agent}: the fact value from the custom external dir should override that of facts.d" do
+      on(agent, facter("--external-dir '#{external_dir}' external_fact")) do |facter_output|
+        assert_equal('OVERRIDE_value', facter_output.stdout.chomp, 'Expected to resolve override version of the external_fact')
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/external_fact_overrides_custom_fact.rb

@@ -0,0 +1,29 @@
+test_name "C100150: external fact overrides custom fact without a weight" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  fact_name = 'test'
+  # Use a static external fact
+  ext_fact = "#{fact_name}: 'EXTERNAL'"
+
+  agents.each do |agent|
+    facts_dir = agent.tmpdir('facts.d')
+    ext_fact_path = "#{facts_dir}/test.yaml"
+    cust_fact_path = "#{facts_dir}/test.rb"
+    create_remote_file(agent, cust_fact_path, custom_fact_content(fact_name, 'CUSTOM'))
+    create_remote_file(agent, ext_fact_path, ext_fact)
+
+    teardown do
+      on(agent, "rm -rf '#{facts_dir}'")
+    end
+
+    step "Agent #{agent}: resolve an external fact over a custom fact" do
+      on(agent, facter("--external-dir=#{facts_dir} --custom-dir=#{facts_dir} #{fact_name}")) do |facter_output|
+        assert_equal("EXTERNAL", facter_output.stdout.chomp)
+      end
+    end
+  end
+end
+

data/acceptance/tests/external_facts/external_fact_overrides_custom_fact_with_10000_weight_or_less.rb

@@ -0,0 +1,30 @@
+test_name "C100151: external fact overrides a custom fact of weight 10000 or less" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  fact_name = 'test'
+  # Use a static external fact
+  ext_fact = "#{fact_name}: 'EXTERNAL'"
+
+  agents.each do |agent|
+    facts_dir = agent.tmpdir('facts.d')
+    ext_fact_path = "#{facts_dir}/test.yaml"
+    cust_fact_path = "#{facts_dir}/test.rb"
+    create_remote_file(agent, ext_fact_path, ext_fact)
+    create_remote_file(agent, cust_fact_path, custom_fact_content(fact_name, 'CUSTOM', "has_weight 10000"))
+
+    teardown do
+      on(agent, "rm -rf '#{facts_dir}'")
+    end
+
+    # Custom fact with weight <= 10000 should give precedence to the EXTERNAL fact
+    step "Agent #{agent}: resolve an external fact over the custom fact with a weight of 10000" do
+      on(agent, facter("--external-dir=#{facts_dir} --custom-dir=#{facts_dir} #{fact_name}")) do |facter_output|
+        assert_equal("EXTERNAL", facter_output.stdout.chomp)
+      end
+    end
+  end
+end
+

data/acceptance/tests/external_facts/external_fact_overrides_custom_fact_with_confine.rb

@@ -0,0 +1,35 @@
+test_name "C100152: external fact overrides a custom fact with a confine" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  fact_name = "test"
+  # Use a static external fact
+  ext_fact = "#{fact_name}: 'EXTERNAL'"
+
+  agents.each do |agent|
+    # Shared directory for external and custom facts
+    facts_dir = agent.tmpdir('facts.d')
+    ext_fact_path = "#{facts_dir}/test.yaml"
+    cust_fact_path = "#{facts_dir}/test.rb"
+    create_remote_file(agent, ext_fact_path, ext_fact)
+
+    agent_kernel = on(agent, facter('kernel')).stdout.chomp
+    create_remote_file(agent, cust_fact_path,
+                       custom_fact_content(fact_name, 'CUSTOM', "confine :kernel=>'#{agent_kernel}'"))
+
+    teardown do
+      on(agent, "rm -rf '#{facts_dir}'")
+    end
+
+    # External fact should take precedence over a custom fact with a confine
+    # (from FACT-1413)
+    step "Agent #{agent}: resolve external fact over a custom fact with a confine" do
+      on(agent, facter("--external-dir=#{facts_dir} --custom-dir=#{facts_dir} test")) do |facter_output|
+        assert_equal("EXTERNAL", facter_output.stdout.chomp)
+      end
+    end
+  end
+end
+