cfacter 3.11.0.rc.20180314

data/ext/facter/facter/acceptance/tests/facts/partitions.rb

@@ -0,0 +1,37 @@
+test_name "C96148: verify partitions facts" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'osx' # no partitions on osx
+  confine :except, :platform => 'windows' # no partitions on windows
+  confine :except, :platform => 'solaris' # no partitions on solaris
+
+  require 'json'
+
+  possible_facts = [
+      ['backing_file', /^\/.*/],
+      ['filesystem', /\w/],
+      ['uuid', /^[-a-zA-Z0-9]+$/],
+      ['partuuid', /^[-a-f0-9]+$/],
+      ['mount', /^\/.*/],
+      ['label', /.*/],
+      ['partlabel', /\w+/],
+  ]
+
+  agents.each do |agent|
+    step("verify that partitions contain facts") do
+      on(agent, facter("--json partitions")) do |facter_output|
+        facter_results = JSON.parse(facter_output.stdout)
+        facter_results['partitions'].each_key do |partition_name|
+          partition_facts = facter_results['partitions'][partition_name]
+          assert_match(/\d+\.\d+ [TGMK]iB/, partition_facts['size'], "Expected partition '#{partition_name}' fact 'size' to match expression")
+          assert(partition_facts['size_bytes'] >= 0, "Expected partition '#{partition_name}' fact 'size_bytes' to be positive")
+          possible_facts.each do |fact, expression|
+            unless partition_facts[fact].nil?
+              assert_match(expression, partition_facts[fact], "Expected partition '#{partition_name}' fact '#{fact}' to match expression")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/facts/productname.rb

@@ -0,0 +1,15 @@
+test_name "C89604: verify productname fact" do
+  tag 'risk:low'
+
+  confine :except, :platform => 'aix' # not supported on
+  confine :except, :platform => 'huawei' # not supported on
+  confine :except, :platform => 'ppc64' # not supported on linux on powerpc
+
+  agents.each do |agent|
+    step("verify the fact productname") do
+      on(agent, facter("productname")) do |facter_result|
+        assert_match(/\w+/, facter_result.stdout.chomp, "Expected fact 'productname' to be set")
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/facts/ruby.rb

@@ -0,0 +1,59 @@
+test_name "C100305: The Ruby fact should resolve as expected in AIO" do
+  tag 'risk:high'
+
+#
+# This test is intended to ensure that the the ruby fact resolves
+# as expected in AIO across supported platforms.
+#
+  skip_test "Ruby fact test is confined to AIO" if @options[:type] != 'aio'
+
+  require 'json'
+  require 'facter/acceptance/base_fact_utils'
+  extend Facter::Acceptance::BaseFactUtils
+
+  agents.each do |agent|
+    step "Ensure the Ruby fact resolves as expected" do
+      case agent['platform']
+        when /windows/
+          ruby_platform = agent['ruby_arch'] == 'x64' ? 'x64-mingw32' : 'i386-mingw32'
+        when /osx/
+          ruby_platform = /x86_64-darwin[\d.]+/
+        when /aix/
+          ruby_platform = /powerpc-aix[\d.]+/
+        when /solaris/
+          if agent['platform'] =~ /sparc/
+            ruby_platform = /sparc-solaris[\d.]+/
+          else
+            ruby_platform = /i386-solaris[\d.]+/
+          end
+        when /cisco_ios_xr/
+          ruby_platform = /x86_64-linux/
+        when /huaweios/
+          ruby_platform = /powerpc-linux/
+        else
+          if agent['ruby_arch']
+            ruby_platform = agent['ruby_arch'] == 'x64' ? /(x86_64|powerpc64le|aarch64)-linux/ : /(i486|i686|s390x)-linux/
+          else
+            ruby_platform = agent['platform'] =~ /64/ ? /(x86_64|powerpc64le|aarch64)-linux/ : /(i486|i686|s390x)-linux/
+          end
+      end
+
+      ruby_version   = /2\.\d+\.\d+/
+      expected_facts = {
+          'ruby.platform' => ruby_platform,
+          'ruby.sitedir'  => /\/site_ruby/,
+          'ruby.version'  => ruby_version
+      }
+
+      step("verify that ruby structured fact contains facts") do
+        on(agent, facter("--json ruby")) 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
+end

data/ext/facter/facter/acceptance/tests/facts/validate_file_system_size_bytes.rb

@@ -0,0 +1,37 @@
+# This test verifies that the numbers for file systems sizes are positive from "facter" and "puppet facts"
+# This is a regression test for FACT-1578
+test_name "C100110: verify that file system sizes are positive" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'windows' # Windows does not list mount points as facts like Unix
+
+  require 'json'
+
+  agents.each do |agent|
+    step("verify that facter returns positive numbers for the mount points byte fields") do
+
+      on(agent, facter("--json")) do |facter_output|
+        facter_results = JSON.parse(facter_output.stdout)
+        facter_results['mountpoints'].each_key do |mount_key|
+          ['available_bytes', 'size_bytes', 'used_bytes'].each do |sub_key|
+            assert_operator(facter_results['mountpoints'][mount_key][sub_key], :>=, 0,
+                            "Expected the #{sub_key} from facter to be positive for #{mount_key}")
+          end
+        end
+      end
+    end
+
+    step("verify that puppet facts returns positive numbers for the mount points byte fields") do
+
+      on(agent, puppet("facts --render-as json")) do |puppet_facts|
+        puppet_results = JSON.parse(puppet_facts.stdout)
+        puppet_results['values']['mountpoints'].each_key do |mount_key|
+          ['available_bytes', 'size_bytes', 'used_bytes'].each do |sub_key|
+            assert_operator(puppet_results['values']['mountpoints'][mount_key][sub_key], :>=, 0,
+                            "Expected the #{sub_key} from puppet facts to be positive for #{mount_key}")
+          end
+        end
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/facts/verify_tmpfs_file_system.rb

@@ -0,0 +1,54 @@
+# This test is intended to demonstrate that mount resource can mount tmpfs file systems
+# and the mount facter mountpoints should show the mount as tmpfs
+test_name 'C98163: mountpoints fact should show mounts on tmpfs' do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+
+  confine :except, :platform => 'windows'
+  confine :except, :platform => /osx/ # See PUP-4823
+  confine :except, :platform => /solaris/ # See PUP-5201
+  confine :except, :platform => /aix/     # See PUP-6845
+  confine :except, :platform => /^eos-/ # Mount provider not supported on Arista EOS switches
+  confine :except, :platform => /^cisco_/ # See PUP-5826
+  confine :except, :platform => /^huawei/ # See PUP-6126
+
+  agents.each do |agent|
+    mount_point = '/tmp/mountdir'
+    manifest_dir = agent.tmpdir('tmpfs')
+    manifest = File.join(manifest_dir, 'mount_manifest.pp')
+    manifest_content = <<-FILE
+      mount {"#{mount_point}":
+        ensure  => mounted,
+        options => 'noexec',
+        fstype  => 'tmpfs',
+        device  => 'tmpfs',
+        atboot  => true,
+      }
+    FILE
+    on(agent, "mkdir -p #{mount_point}")
+    create_remote_file(agent, manifest, manifest_content)
+
+    teardown do
+      on(agent, "umount #{mount_point}")
+      on(agent, "rm -rf #{mount_point} #{manifest_dir}")
+    end
+
+    step "Apply the manifest to mount directory '#{mount_point}'" do
+      on(agent, puppet("apply #{manifest}"), :acceptable_exit_codes => [0,2]) do |puppet_apply|
+        assert_no_match(/Error/, puppet_apply.stdout, 'Unexpected error on stdout was detected!')
+        assert_no_match(/ERROR/, puppet_apply.stderr, 'Unexpected error on stderr was detected!')
+      end
+    end
+
+    step 'verify tmpfs mount point seen by facter' do
+      on(agent, facter("mountpoints.#{mount_point}")) do |facter_output|
+        assert_match(/filesystem\s+=>\s+\"tmpfs\"/, facter_output.stdout, 'filesystem is the wrong type')
+        assert_match(/device\s+=>\s+\"tmpfs\"/, facter_output.stdout, 'device is not a tmpfs')
+        assert_match(/noexec/, facter_output.stdout, 'expected to see noexec option')
+      end
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/load_libfacter.rb

@@ -0,0 +1,66 @@
+# Verify that we can load the facter the way that mco does based on the platform
+test_name 'C100161: Ruby can load libfacter without raising an error' do
+  tag 'risk:high'
+
+  require 'puppet/acceptance/common_utils'
+  extend Puppet::Acceptance::CommandUtils
+
+  def puppet_ruby_path_to_puppet_install_dir(puppet_ruby_path)
+    # find the "puppet" directory which should be the root of the install
+    puppet_dir = puppet_ruby_path
+    while File.basename(puppet_dir).downcase != 'puppet'
+      new_puppet_dir = File.dirname(puppet_dir)
+      if new_puppet_dir == puppet_dir
+        break
+      else
+        puppet_dir = new_puppet_dir
+      end
+    end
+    puppet_dir
+  end
+
+  agents.each do |agent|
+    # create a ruby program that will add a fact through Facter
+    fact_content = <<-EOM
+    require 'facter'
+    Facter.add('facter_loaded') do
+      setcode do
+        'FACTER_LOADED'
+      end
+    end
+
+    # print a value so that we know that facter loaded and is working
+    puts Facter.value('facter_loaded')
+    exit 0
+    EOM
+
+    fact_dir = agent.tmpdir('mco_test')
+    fact_program = File.join(fact_dir, 'loading_facter.rb')
+    create_remote_file(agent, fact_program, fact_content)
+
+    teardown do
+      on(agent, "rm -rf '#{fact_dir}'")
+    end
+
+    if agent['platform'] =~ /windows/
+      # on Windows we have to figure out where facter.rb is so we can include the path
+      # figure out the root of the Puppet installation
+      puppet_ruby_path = on(agent, "env PATH=\"#{agent['privatebindir']}:${PATH}\" which ruby").stdout.chomp
+      cygwin_puppet_root = puppet_ruby_path_to_puppet_install_dir(puppet_ruby_path)
+      puppet_root = on(agent, "cygpath -w '#{cygwin_puppet_root}'").stdout.chomp
+      # on Windows mco uses -I to include the path to the facter.rb as its not in the
+      # default $LOAD_PATH for Puppets Ruby
+      include_facter_lib = "-I '#{puppet_root}/facter/lib'"
+    else
+      # On Unix systems facter.rb is already in the $LOAD_PATH for Puppets Ruby for mco
+      include_facter_lib = ''
+    end
+
+    # Run Puppet's ruby and load facter.rb
+    # if we fail to load the .jar or .so, ruby will raise an error for us to detect
+    on(agent, "#{ruby_command(agent)} #{include_facter_lib} #{fact_program}") do |ruby_result|
+      assert_equal('FACTER_LOADED', ruby_result.stdout.chomp, 'Expected the output to be only the value the added fact')
+      assert_empty(ruby_result.stderr, 'Expected libfacter to load without any output on stderr')
+    end
+  end
+end

data/ext/facter/facter/acceptance/tests/no_errors_on_stderr.rb

@@ -0,0 +1,10 @@
+test_name 'C14514: Running facter should not output anything to stderr' do
+  tag 'risk:high'
+
+  agents.each do |agent|
+    on(agent, facter) do |facter_output|
+      assert_match(/hostname\s*=>\s*\S*/, facter_output.stdout, 'Hostname fact is missing')
+      assert_empty(facter_output.stderr, 'Facter should not have written to stderr')
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# This test is intended to ensure with --debug and --color, facter sends escape sequences to colorize the output
+test_name "C86545: --debug and --color command-line options should print DEBUG messages with color escape sequences" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'windows' # On windows we don't get an escape sequence to detect to color change
+
+  agents.each do |agent|
+    step "Agent #{agent}: retrieve debug info from stderr using --debug and --color option" do
+      # set the TERM type to be a color xterm to help ensure we emit the escape sequence to change the color
+      on(agent, facter('--debug --color'), :environment => { 'TERM' => 'xterm-256color' }) do |facter_output|
+        assert_match(/DEBUG/, facter_output.stderr, "Expected DEBUG information in stderr")
+        assert_match(/\e\[0;/, facter_output.stderr, "Expected to see an escape sequence in the output")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# This test is intended to verify that the config file location can be specified
+# via the `--config` flag on the command line.
+test_name "C100014: --config command-line option designates the location of the config file" do
+  tag 'risk:high'
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      config_dir = agent.tmpdir("config_dir")
+      config_file = File.join(config_dir, "facter.conf")
+      create_remote_file(agent, config_file, <<-FILE)
+      cli : {
+          debug : true
+      }
+      FILE
+
+      teardown do
+        on(agent, "rm -rf '#{config_dir}'", :acceptable_exit_codes => [0, 1])
+      end
+
+      step "setting --config should cause the config file to be loaded from the specified location" do
+        on(agent, facter("--config '#{config_file}'")) do |facter_output|
+          assert_match(/DEBUG/, facter_output.stderr, "Expected debug output on stderr")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# This test verifies that when a fact group is blocked in the config file
+# the corresponding facts do not resolve.
+test_name "C99972: facts can be blocked via a blocklist in the config file" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    step "Agent #{agent}: create config file" do
+      custom_conf_dir = agent.tmpdir("config_dir")
+      config_file = File.join(custom_conf_dir, "facter.conf")
+      create_remote_file(agent, config_file, <<-FILE)
+        cli : { debug : true }
+        facts : { blocklist : [ "file system", "EC2" ] }
+      FILE
+
+      teardown do
+        on(agent, "rm -rf '#{custom_conf_dir}'", :acceptable_exit_codes => [0, 1])
+      end
+
+      step "blocked facts should not be resolved" do
+        on(agent, facter("--config '#{config_file}'")) do |facter_output|
+          # every platform attempts to resolve at least EC2 facts
+          assert_match(/blocking collection of .+ facts/, facter_output.stderr, "Expected stderr to contain statement about blocking fact collection")
+
+          # on some platforms, file system facts are never resolved, so this will also be true in those cases
+          assert_no_match(/filesystems/, facter_output.stdout, "filesystems fact should have been blocked")
+          assert_no_match(/mountpoints/, facter_output.stdout, "mountpoints fact should have been blocked")
+          assert_no_match(/partitions/, facter_output.stdout, "partitions fact should have been blocked")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# This test verifies that when a fact group is blocked in the config file the
+# corresponding facts do not resolve when being run from the puppet facts command.
+test_name "C100036: when run from puppet facts, facts can be blocked via a list in the config file" do
+  tag 'risk:medium'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    step "facts should be blocked when Facter is run from Puppet with a configured blocklist" do
+      # 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
+
+      step "Agent #{agent}: create default config file" do
+        # create the directories
+        on(agent, "mkdir -p '#{facter_conf_default_dir}'")
+        create_remote_file(agent, facter_conf_default_path, <<-FILE)
+        facts : { blocklist : [ "file system", "EC2" ] }
+        FILE
+      end
+
+      step "blocked facts should not be resolved" do
+        on(agent, puppet("facts --debug")) do |puppet_facts_output|
+          # every platform attempts to resolve at least EC2 facts
+          assert_match(/blocking collection of .+ facts/, puppet_facts_output.stdout, "Expected stderr to contain statement about blocking fact collection")
+
+          # on some platforms, file system facts are never resolved, so this will also be true in those cases
+          assert_no_match(/filesystems/, puppet_facts_output.stdout, "filesystems fact should have been blocked")
+          assert_no_match(/mountpoints/, puppet_facts_output.stdout, "mountpoints fact should have been blocked")
+          assert_no_match(/partitions/, puppet_facts_output.stdout, "partitions fact should have been blocked")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# This test verifies that the custom-dir specified in the configuration file can be overridden by using
+# --custom-dir on the command line
+test_name "C100015: config custom-dir overridden by command line --custom-dir" do
+  tag 'risk:medium'
+
+  require 'json'
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  config_fact_content = <<EOM
+Facter.add('config_fact') do
+  setcode do
+    "config_value"
+  end
+end
+EOM
+
+  cli_fact_content = <<EOM
+Facter.add('cli_fact') do
+  setcode do
+    "cli_value"
+  end
+end
+EOM
+
+  agents.each do |agent|
+    step "Agent #{agent}: create 2 custom fact directories with facts and a config file pointing at 1 directory" do
+      custom_config_dir = agent.tmpdir('custom_dir')
+      custom_cli_dir = agent.tmpdir('cli_custom_dir')
+      custom_config_fact = File.join(custom_config_dir, 'custom_fact.rb')
+      custom_cli_fact = File.join(custom_cli_dir, 'custom_fact.rb')
+      create_remote_file(agent, custom_config_fact, config_fact_content)
+      create_remote_file(agent, custom_cli_fact, cli_fact_content)
+      config_dir = agent.tmpdir("config_dir")
+      config_file = File.join(config_dir, "facter.conf")
+      config_content = <<EOM
+global : {
+    custom-dir : "#{custom_config_dir}",
+}
+EOM
+      create_remote_file(agent, config_file, config_content)
+
+      teardown do
+        on(agent, "rm -rf '#{custom_config_dir}' '#{custom_cli_dir}' '#{config_dir}'")
+      end
+
+      step "Agent #{agent}: resolve a fact from the command line custom-dir and not the config file" do
+        on(agent, facter("--config '#{config_file}' --custom-dir '#{custom_cli_dir}' --json")) do |facter_output|
+          results = JSON.parse(facter_output.stdout)
+          assert_equal("cli_value", results['cli_fact'], "Incorrect custom fact value for cli_fact")
+          assert_nil(results['config_fact'], "Config fact should not resolve and be nil")
+        end
+      end
+    end
+  end
+end