facter 4.0.28

data/acceptance/lib/facter/acceptance/user_fact_utils.rb

@@ -0,0 +1,132 @@
+module Facter
+  module Acceptance
+    module UserFactUtils
+
+      # Determine paths for testing custom and external facts.
+      # Paths vary by platform.
+
+      # Retrieve the path of a non-standard directory for custom or external facts.
+      #
+      def get_user_fact_dir(platform, version)
+        if platform =~ /windows/
+          if version < 6.0
+            File.join('C:', 'Documents and Settings', 'All Users', 'Application Data', 'PuppetLabs', 'facter', 'custom')
+          else
+            File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'custom')
+          end
+        else
+          File.join('/', 'opt', 'puppetlabs', 'facter', 'custom')
+        end
+      end
+
+      # Retrieve the path of the standard facts.d directory.
+      #
+      def get_factsd_dir(platform, version)
+        if platform =~ /windows/
+          if version < 6.0
+            File.join('C:', 'Documents and Settings', 'All Users', 'Application Data', 'PuppetLabs', 'facter', 'facts.d')
+          else
+            File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'facts.d')
+          end
+        else
+          File.join('/', 'opt', 'puppetlabs', 'facter', 'facts.d')
+        end
+      end
+
+      # Retrieve the path of the standard cached facts directory.
+      #
+      def get_cached_facts_dir(platform, version)
+        if platform =~ /windows/
+          if version < 6.0
+            File.join('C:', 'Documents and Settings', 'All Users', 'Application Data', 'PuppetLabs', 'facter', 'cache', 'cached_facts')
+          else
+            File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'cache', 'cached_facts')
+          end
+        else
+          File.join('/', 'opt', 'puppetlabs', 'facter', 'cache', 'cached_facts')
+        end
+      end
+
+      # Retrieve the path of the facts.d directory in /etc/facter on Unix systems
+      #
+      def get_etc_factsd_dir(platform)
+        if platform =~ /windows/
+          raise "get_etc_factsd_dir: not a supported directory on Windows"
+        else
+          File.join('/', 'etc', 'facter', 'facts.d')
+        end
+      end
+
+      # Retrieve the path of the facts.d diretory in /etc/puppetlabs/facter on Unix systems
+      #
+      def get_etc_puppetlabs_factsd_dir(platform)
+        if platform =~ /windows/
+          raise "get_etc_puppetlabs_factsd_dir: not a supported directory on Windows"
+        else
+          File.join('/', 'etc', 'puppetlabs', 'facter', 'facts.d')
+        end
+      end
+
+      # Retrieve the extension to use for an external fact script.
+      # Windows uses '.bat' and everything else uses '.sh'
+      def get_external_fact_script_extension(platform)
+        if platform =~ /windows/
+          '.bat'
+        else
+          '.sh'
+        end
+      end
+
+      # Retrieve the path to default location of facter.conf file.
+      #
+      def get_default_fact_dir(platform, version)
+        if platform =~ /windows/
+          File.join('C:', 'ProgramData', 'PuppetLabs', 'facter', 'etc')
+        else
+          File.join('/', 'etc', 'puppetlabs', 'facter')
+        end
+      end
+
+      # Return the content for an external fact based on the platform supplied
+      #
+      def external_fact_content(platform, key='external_fact', value='test_value')
+        unix_content = <<EOM
+#!/bin/sh
+echo "#{key}=#{value}"
+EOM
+
+        win_content = <<EOM
+@echo off
+echo #{key}=#{value}
+EOM
+
+        if platform =~ /windows/
+          win_content
+        else
+          unix_content
+        end
+      end
+
+      # Return the content for a custom fact
+      #
+      def custom_fact_content(key='custom_fact', value='custom_value', *args)
+        <<-EOM
+  Facter.add('#{key}') do
+    setcode {'#{value}'}
+    #{args.empty? ? '' : args.join('\n')}
+  end
+        EOM
+      end
+
+      # Return the correct shell path for Unix system under test
+      #
+      def user_shell(agent)
+        if agent['platform'] =~ /aix/
+          '/usr/bin/bash'
+        else
+          '/bin/bash'
+        end
+      end
+    end
+  end
+end

data/acceptance/lib/helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+
+require 'beaker-puppet'

data/acceptance/lib/puppet/acceptance/common_utils.rb

@@ -0,0 +1,10 @@
+module Puppet
+  module Acceptance
+    module CommandUtils
+      def ruby_command(host)
+        "env PATH=\"#{host['privatebindir']}:${PATH}\" ruby"
+      end
+      module_function :ruby_command
+    end
+  end
+end

data/acceptance/lib/puppet/acceptance/git_utils.rb

@@ -0,0 +1,19 @@
+module Puppet
+  module Acceptance
+    module GitUtils
+      def lookup_in_env(env_variable_name, project_name, default)
+        project_specific_name = "#{project_name.upcase.gsub("-","_")}_#{env_variable_name}"
+        ENV[project_specific_name] || ENV[env_variable_name] || default
+      end
+
+      def build_giturl(project_name, git_fork = nil, git_server = nil)
+        git_fork ||= lookup_in_env('FORK', project_name, 'puppetlabs')
+        git_server ||= lookup_in_env('GIT_SERVER', project_name, 'github.com')
+        repo = (git_server == 'github.com') ?
+          "#{git_fork}/#{project_name}.git" :
+          "#{git_fork}-#{project_name}.git"
+        "git://#{git_server}/#{repo}"
+      end
+    end
+  end
+end

data/acceptance/lib/puppet/acceptance/install_utils.rb

@@ -0,0 +1,58 @@
+require 'open-uri'
+require 'open3'
+require 'uri'
+require 'puppet/acceptance/common_utils'
+
+module Puppet
+  module Acceptance
+    module InstallUtils
+      PLATFORM_PATTERNS = {
+        :redhat        => /fedora|el-|centos/,
+        :debian        => /debian|ubuntu/,
+        :debian_ruby18 => /debian|ubuntu-lucid|ubuntu-precise/,
+        :solaris       => /solaris/,
+        :windows       => /windows/,
+      }.freeze
+
+      # Installs packages on the hosts.
+      #
+      # @param hosts [Array<Host>] Array of hosts to install packages to.
+      # @param package_hash [Hash{Symbol=>Array<String,Array<String,String>>}]
+      #   Keys should be a symbol for a platform in PLATFORM_PATTERNS.  Values
+      #   should be an array of package names to install, or of two element
+      #   arrays where a[0] is the command we expect to find on the platform
+      #   and a[1] is the package name (when they are different).
+      # @param options [Hash{Symbol=>Boolean}]
+      # @option options [Boolean] :check_if_exists First check to see if
+      #   command is present before installing package.  (Default false)
+      # @return true
+      def install_packages_on(hosts, package_hash, options = {})
+        check_if_exists = options[:check_if_exists]
+        hosts = [hosts] unless hosts.kind_of?(Array)
+        hosts.each do |host|
+          package_hash.each do |platform_key,package_list|
+            if pattern = PLATFORM_PATTERNS[platform_key]
+              if pattern.match(host['platform'])
+                package_list.each do |cmd_pkg|
+                  if cmd_pkg.kind_of?(Array)
+                    command, package = cmd_pkg
+                  else
+                    command = package = cmd_pkg
+                  end
+                  if !check_if_exists || !host.check_for_package(command)
+                    host.logger.notify("Installing #{package}")
+                    additional_switches = '--allow-unauthenticated' if platform_key == :debian
+                    host.install_package(package, additional_switches)
+                  end
+                end
+              end
+            else
+              raise("Unknown platform '#{platform_key}' in package_hash")
+            end
+          end
+        end
+        return true
+      end
+    end
+  end
+end

data/acceptance/setup/aio/pre-suite/001_run_with_facter_ng.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require 'open3'
+require 'tmpdir'
+
+def create_facter_gem
+  temp_dir = Dir.mktmpdir
+  Dir.chdir(temp_dir) do
+    download_and_build_facter_ng
+
+    facter_repo_dir = Pathname.new("#{temp_dir}/facter-ng")
+    facter_gem_path = Dir.entries(facter_repo_dir).select { |file| file =~ /facter-ng-[0-9]+.[0-9]+.[0-9]+(.pre)?.gem/ }
+    File.join(facter_repo_dir, facter_gem_path)
+  end
+end
+
+def download_and_build_facter_ng
+  branch_name = ENV['FACTER_4_BRANCH']
+  puts "Cloning branch #{branch_name}"
+  Open3.capture2('echo $PATH')
+
+  Open3.capture2("git clone https://github.com/puppetlabs/facter-ng.git &&" \
+  'cd facter-ng &&' \
+  'git fetch &&' \
+  "git reset --hard origin/#{branch_name}")
+
+  Dir.chdir('facter-ng') do
+    puts "Latest commit on branch #{branch_name}"
+    output, _stderr = Open3.capture2('git log -1')
+    puts output
+
+    Open3.capture2('gem build agent/facter-ng.gemspec')
+  end
+end
+
+def install_facter_gem(agent, facter_gem_path)
+  home_dir = on(agent, 'pwd').stdout.chop
+  gem_c = gem_command(agent)
+
+  scp_to(agent, facter_gem_path, home_dir)
+
+  on(agent, "#{gem_c} uninstall facter-ng")
+  on(agent, "#{gem_c} install -f facter-ng-*.gem")
+end
+
+test_name 'Setup for Facter NG' do
+  windows_puppet_bin_path = '/cygdrive/c/Program\ Files/Puppet\ Labs/Puppet/bin'
+  linux_puppet_bin_path = '/opt/puppetlabs/puppet/bin'
+  set_facter_ng_command = 'puppet config set facterng true'
+
+  puts 'Setting run with facter ng if environment variable FACTER_NG is true.'
+  puts "FACTER_NG is #{ENV["FACTER_NG"]}."
+  puts "FACTER_NG branch is #{ENV['FACTER_4_BRANCH']}"
+
+  if ENV["FACTER_NG"] == 'true'
+    puts 'Cloning facter ng repository and creating gem file.'
+    facter_gem_path = create_facter_gem
+
+    agents.each do |agent|
+      puts 'Installing Facter NG on agent.'
+      install_facter_gem(agent, facter_gem_path)
+
+      puts 'Renaming facter to facter-original and facter-ng to facter.'
+      if agent['platform'] =~ /windows/
+        on(agent, "cmd /c #{set_facter_ng_command}")
+        on(agent, "cd #{windows_puppet_bin_path} && mv facter-ng.bat facter.bat")
+      else
+        on(agent, "#{set_facter_ng_command} ")
+        on(agent, "cd #{linux_puppet_bin_path} && mv facter-ng facter")
+      end
+
+      puts 'FACTER VERSION'
+      on(agent, "facter -v")
+    end
+  end
+end

data/acceptance/tests/custom_facts/cached_custom_fact.rb

@@ -0,0 +1,82 @@
+test_name 'ttls configured custom facts files creates cache file and reads cache file' do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  custom_fact_file = 'custom_facts.rb'
+  custom_fact_name  = 'random_custom_fact'
+  custom_fact_value = 'custom fact value'
+
+  fact_content = <<-CUSTOM_FACT
+  Facter.add(:#{custom_fact_name}) do
+    setcode do
+      "#{custom_fact_value}"
+    end
+  end
+  CUSTOM_FACT
+
+  cached_file_content = <<~CACHED_FILE
+    {
+      "#{custom_fact_name}": "#{custom_fact_value}"
+    }
+  CACHED_FILE
+
+  config_data = <<~FACTER_CONF
+    facts : {
+      ttls : [
+          { "cached-custom-facts" : 3 days }
+      ]
+    }
+    fact-groups : {
+      cached-custom-facts : ["#{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_file}'")
+    end
+
+    step "should log that it creates cache file and it caches custom facts found in facter.conf" do
+      on(agent, facter("#{custom_fact_name} --debug", environment: env)) do |facter_result|
+        assert_equal(custom_fact_value, facter_result.stdout.chomp, "#{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" 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.chomp, cat_output.stdout, 'Expected cached custom fact file to contain fact information')
+      end
+    end
+
+    step 'should read from the cached file for a custom fact that has been cached' do
+      on(agent, facter("#{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/conflicts_with_builtin_fact.rb

@@ -0,0 +1,106 @@
+test_name 'Facter should appropriately resolve a custom fact when it conflicts with a builtin fact' do
+  tag 'risk:medium'
+
+  def create_custom_fact_on(host, custom_fact_dir, fact_file_name, fact)
+    fact_file_contents = <<-CUSTOM_FACT
+Facter.add(:#{fact[:name]}) do
+  has_weight #{fact[:weight]}
+  setcode do
+    #{fact[:value]}
+  end
+end
+CUSTOM_FACT
+
+    fact_file_path = File.join(custom_fact_dir, fact_file_name) 
+    create_remote_file(host, fact_file_path, fact_file_contents)
+  end
+
+  def clear_custom_facts_on(host, custom_fact_dir)
+    step "Clean-up the previous test's custom facts" do
+      on(agent, "rm -f #{custom_fact_dir}/*")
+    end
+  end
+
+  agents.each do |agent|
+    custom_fact_dir = agent.tmpdir('facter')
+    teardown do
+      on(agent, "rm -rf '#{custom_fact_dir}'")
+    end
+
+    fact_name = 'timezone'
+    builtin_value = on(agent, facter('timezone')).stdout.chomp
+
+    step "Verify that Facter uses the custom fact's value when its weight is > 0" do
+      custom_fact_value = "custom_timezone"
+      create_custom_fact_on(
+        agent,
+        custom_fact_dir,
+        'custom_timezone.rb',
+        name: fact_name,
+        weight: 10,
+        value: "'#{custom_fact_value}'"
+      )
+
+      on(agent, facter("--custom-dir=#{custom_fact_dir} timezone")) do |result|
+        assert_match(/#{custom_fact_value}/, result.stdout.chomp, "Facter does not use the custom fact's value when its weight is > 0")
+      end
+    end
+
+    clear_custom_facts_on(agent, custom_fact_dir)
+
+    step "Verify that Facter uses the builtin fact's value when all conflicting custom facts fail to resolve" do
+      [ 'timezone_one.rb', 'timezone_two.rb'].each do |fact_file|
+        create_custom_fact_on(
+          agent,
+          custom_fact_dir,
+          fact_file,
+          { name: fact_name, weight: 10, value: nil }
+        )
+      end
+
+      on(agent, facter("--custom-dir=#{custom_fact_dir} timezone")) do |result|
+        assert_match(/#{builtin_value}/, result.stdout.chomp, "Facter does not use the builtin fact's value when all conflicting custom facts fail to resolve")
+      end
+    end
+
+    step "Verify that Facter gives precedence to the builtin fact over zero weight custom facts" do
+      step "when all custom facts have zero weight" do
+        {
+          'timezone_one.rb' => "'timezone_one'",
+          'timezone_two.rb' => "'timezone_two'"
+        }.each do |fact_file, fact_value|
+          create_custom_fact_on(
+            agent,
+            custom_fact_dir,
+            fact_file,
+            { name: fact_name, weight: 0, value: fact_value }
+          )
+        end
+
+        on(agent, facter("--custom-dir=#{custom_fact_dir} timezone")) do |result|
+          assert_match(/#{builtin_value}/, result.stdout.chomp, "Facter does not give precedence to the builtin fact when all custom facts have zero weight")
+        end
+      end
+
+      clear_custom_facts_on(agent, custom_fact_dir)
+
+      step "when some custom facts have zero weight" do
+        {
+          'timezone_one.rb' => { weight: 10, value: nil },
+          'timezone_two.rb' => { weight: 0, value: "'timezone_two'" }
+        }.each do |fact_file, fact|
+          create_custom_fact_on(
+            agent,
+            custom_fact_dir,
+            fact_file,
+            fact.merge(name: fact_name)
+          )
+        end
+
+        on(agent, facter("--custom-dir=#{custom_fact_dir} timezone")) do |result|
+          assert_match(/#{builtin_value}/, result.stdout.chomp, "Facter does not give precedence to the builtin fact when only some custom facts have zero weight")
+        end
+      end
+    end
+  end
+end