facter 4.0.26 → 4.0.28

data/acceptance/tests/external_facts/external_fact_stderr_messages_output_to_stderr.rb

@@ -0,0 +1,49 @@
+test_name "C64315: external facts that print messages to stderr should be seen on stderr" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    factsd = get_factsd_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    ext = get_external_fact_script_extension(agent['platform'])
+    ext_fact = File.join(factsd, "external_fact#{ext}")
+
+    if agent['platform'] =~ /windows/
+      content = <<EOM
+echo "SCRIPT STDERR" >&2
+echo "test=value"
+EOM
+    else
+      content = <<EOM
+#!/bin/sh
+echo "SCRIPT STDERR" >&2
+echo "test=value"
+EOM
+    end
+
+    teardown do
+      on(agent, "rm -f '#{ext_fact}'")
+    end
+
+    step "Agent #{agent}: create facts.d directory and fact" do
+      on(agent, "mkdir -p '#{factsd}'")
+      create_remote_file(agent, ext_fact, content)
+      on(agent, "chmod +x '#{ext_fact}'")
+    end
+
+    step "Agent #{agent}: external fact stderr messages should appear on stderr from facter" do
+      on(agent, facter) do |facter_output|
+        assert_match(/WARN.*SCRIPT STDERR/, facter_output.stderr,
+                     "Expected facter to output a warning message with the stderr string from the external fact")
+      end
+    end
+
+    step "Agent #{agent}: external fact stderr messages should appear on stderr from puppet facts" do
+      on(agent, puppet("facts")) do |puppet_output|
+        assert_match(/Warning.*SCRIPT STDERR/, puppet_output.stderr,
+                     "Expected puppet facts to output a warning message with the stderr string from the external fact")
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/external_facts_only_run_once.rb

@@ -0,0 +1,43 @@
+test_name "C14892: external facts should only be run once" do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    factsd = get_factsd_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    ext = get_external_fact_script_extension(agent['platform'])
+    ext_fact = File.join(factsd, "external_fact#{ext}")
+
+    if agent['platform'] =~ /windows/
+      content = <<EOM
+echo "SCRIPT CALLED" >&2
+echo "test=value"
+EOM
+    else
+      content = <<EOM
+#!/bin/sh
+echo "SCRIPT CALLED" >&2
+echo "test=value"
+EOM
+    end
+
+    teardown do
+      on(agent, "rm -f '#{ext_fact}'")
+    end
+
+    step "Agent #{agent}: create facts.d directory and fact" do
+      on(agent, "mkdir -p '#{factsd}'")
+      create_remote_file(agent, ext_fact, content)
+      on(agent, "chmod +x '#{ext_fact}'")
+    end
+
+    step "Agent #{agent}: ensure the fact is only executed once" do
+      on(agent, facter) do |facter_output|
+        lines = facter_output.stderr.split('\n')
+        times = lines.count { |line| line =~ /SCRIPT CALLED/ }
+        assert_equal(1, times, "External fact should only execute once: #{facter_output.stderr}")
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/fact_directory_precedence.rb

@@ -0,0 +1,109 @@
+# Verify that facter uses the new AIO default paths for external facts
+#
+# On Unix/Linux/OS X, there are three directories:
+#     /opt/puppetlabs/facter/facts.d/
+#     /etc/puppetlabs/facter/facts.d/
+#     /etc/facter/facts.d/
+test_name "C59201: Fact directory precedence and resolution order for facts" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'windows' # windows only supports 1 directory instead of 3 on unix
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+# Generate an external fact dynamically
+  def ext_fact(value='BASIC')
+    "test: '#{value}'"
+  end
+
+  agents.each do |agent|
+    # The directories that facter processes facts
+    os_version = on(agent, facter('kernelmajversion')).stdout.chomp.to_f
+    factsd_dir = get_factsd_dir(agent['platform'], os_version)
+    etc_factsd_dir = get_etc_factsd_dir(agent['platform'])
+    etc_puppetlabs_factsd_dir = get_etc_puppetlabs_factsd_dir(agent['platform'])
+    factsd_path = "#{factsd_dir}/test.yaml"
+    etc_factsd_path = "#{etc_factsd_dir}/test.yaml"
+    etc_puppetlabs_factsd_path = "#{etc_puppetlabs_factsd_dir}/test.yaml"
+
+    teardown do
+      on(agent, "rm -rf '#{factsd_dir}' '#{etc_factsd_dir}' '#{etc_puppetlabs_factsd_dir}'")
+    end
+
+    # ensure the fact directory we want to use exists
+    step "Agent #{agent}: create facts directory (#{etc_puppetlabs_factsd_dir})" do
+      on(agent, "rm -rf '#{etc_puppetlabs_factsd_dir}'")
+      on(agent, "mkdir -p '#{etc_puppetlabs_factsd_dir}'")
+    end
+
+    # A fact in the etc_puppetlabs_factsd_dir directory should resolve to the fact
+    step "Agent #{agent}: create and resolve a custom fact in #{etc_puppetlabs_factsd_dir}" do
+      create_remote_file(agent, etc_puppetlabs_factsd_path, ext_fact('etc_puppetlabs_path'))
+      on(agent, facter("test")) do |facter_output|
+        assert_match(/etc_puppetlabs_path/, facter_output.stdout, "Fact from #{etc_puppetlabs_factsd_dir} did not resolve correctly")
+      end
+    end
+
+    # remove the fact
+    step "Agent #{agent}: remove the fact in #{etc_puppetlabs_factsd_dir}" do
+      on(agent, "rm -f '#{etc_puppetlabs_factsd_path}'")
+    end
+
+    # ensure the fact directory we want to use exists
+    step "Agent #{agent}: create facts directory (#{etc_factsd_dir})" do
+      on(agent, "rm -rf '#{etc_factsd_dir}'")
+      on(agent, "mkdir -p '#{etc_factsd_dir}'")
+    end
+
+    # A fact in the etc_factsd_dir directory should resolve to the fact
+    step "Agent #{agent}: create and resolve a custom fact in #{etc_factsd_dir}" do
+      create_remote_file(agent, etc_factsd_path, ext_fact('etc_path'))
+      on(agent, facter("test")) do |facter_output|
+        assert_match(/etc_path/, facter_output.stdout, "Fact from #{etc_factsd_dir} did not resolve correctly")
+      end
+    end
+
+    # remove the fact
+    step "Agent #{agent}: remove the fact in #{etc_factsd_dir}" do
+      on(agent, "rm -f '#{etc_factsd_path}'")
+    end
+
+    # ensure the fact directory we want to use exists
+    step "Agent #{agent}: create facts directory (#{factsd_dir})" do
+      on(agent, "rm -rf '#{factsd_dir}'")
+      on(agent, "mkdir -p '#{factsd_dir}'")
+    end
+
+    # A fact in the factsd_dir directory should resolve to the fact
+    step "Agent #{agent}: create and resolve a custom fact in #{factsd_dir}" do
+      create_remote_file(agent, factsd_path, ext_fact('default_factsd'))
+      on(agent, facter("test")) do |facter_output|
+        assert_match(/default_factsd/, facter_output.stdout, "Fact from #{factsd_dir} did not resolve correctly")
+      end
+    end
+
+    # remove the fact
+    step "Agent #{agent}: remove the fact in #{factsd_dir}" do
+      on(agent, "rm -f '#{factsd_path}'")
+    end
+
+    # A fact in the etc_factsd_dir directory should take precedence over the same fact in factsd_dir
+    step "Agent #{agent}: create and resolve 2 facts of the same name between #{factsd_dir} and #{etc_factsd_dir}" do
+      create_remote_file(agent, factsd_path, ext_fact('BASE'))
+      create_remote_file(agent, etc_factsd_path, ext_fact('ETC_FACTS'))
+      on(agent, facter("test")) do |facter_output|
+        assert_match(/ETC_FACTS/, facter_output.stdout, "Fact from #{etc_factsd_dir} should take precedence over #{factsd_dir}")
+      end
+    end
+
+    # A fact in the etc_puppetlabs_factsd_dir should take precedence over the same fact in etc_factsd_dir
+    step "Agent #{agent}: create and resolve 2 facts of the same name between #{etc_factsd_dir} and #{etc_puppetlabs_factsd_dir}" do
+      create_remote_file(agent, etc_factsd_path, ext_fact('ETC_FACTS'))
+      create_remote_file(agent, etc_puppetlabs_factsd_path, ext_fact('ETC_PUPPETLABS_FACTS'))
+      on(agent, facter("test")) do |facter_output|
+        assert_match(/ETC_PUPPETLABS_FACTS/, facter_output.stdout, "Fact from #{etc_puppetlabs_factsd_dir} should take precedence over #{etc_factsd_dir}")
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/handle_same_filename_in_different_dirs.rb

@@ -0,0 +1,59 @@
+# Verify how facter handles same external facts filename in different directories:
+#
+#     - in case ttl not enabled, will accept same filename in two external directories
+#     - in case ttl enabled on filename, will throw error and exit 1
+#
+
+test_name 'Should handle same filename in two external directories only if ttl is not enabled' do
+  tag 'risk:high'
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  agents.each do |agent|
+    fact1 = 'fact1'
+    fact2 = 'fact2'
+    fact1_value = 'fact1_value'
+    fact2_value = 'fact2_value'
+    external_filename = 'text.yaml'
+    external_dir1 = agent.tmpdir('external_dir')
+    external_fact_file1 = File.join(external_dir1, external_filename)
+    external_dir2 = agent.tmpdir('external_dir')
+    external_fact_file2 = File.join(external_dir2, external_filename)
+    create_remote_file(agent, external_fact_file1, "#{fact1}: #{fact1_value}")
+    create_remote_file(agent, external_fact_file2, "#{fact2}: #{fact2_value}")
+
+    config_dir = get_default_fact_dir(agent['platform'], on(agent, facter('kernelmajversion')).stdout.chomp.to_f)
+    config_file = File.join(config_dir, 'facter.conf')
+
+    teardown do
+      on(agent, "rm -rf '#{external_dir1}' '#{external_dir2}' '#{config_file}'")
+    end
+
+    step 'works if ttl is not enabled' do
+      on(agent, facter("--external-dir '#{external_dir1}' --external-dir '#{external_dir2}' --debug #{fact1} #{fact2}")) do |facter_output|
+        assert_match(/#{fact1} => #{fact1_value}/, stdout, 'Expected fact to match first fact')
+        assert_match(/#{fact2} => #{fact2_value}/, stdout, 'Expected fact to match second fact')
+      end
+    end
+
+    step 'does not work if ttl is enabled' do
+      config = <<EOM
+facts : {
+    ttls : [
+        { "#{external_filename}" : 30 days }
+    ]
+}
+EOM
+      on(agent, "mkdir -p '#{config_dir}'")
+      create_remote_file(agent, config_file, config)
+      on(agent, facter("--external-dir '#{external_dir1}' --external-dir '#{external_dir2}' --debug #{fact1} #{fact2}"), :acceptable_exit_codes => 1) do |facter_output|
+        assert_match(/ERROR.*Caching is enabled for group "#{external_filename}" while there are at least two external facts files with the same filename/, stderr, 'Expected error message')
+        assert_match(/#{fact1} => #{fact1_value}/, stdout, 'Expected fact to match first fact')
+        assert_not_match(/#{fact2} => #{fact2_value}/, stdout, 'Expected fact not to match second fact')
+      end
+    end
+
+
+  end
+end

data/acceptance/tests/external_facts/non_root_users_default_external_fact_directory.rb

@@ -0,0 +1,142 @@
+# verify that facter run as a non-root user honor facts in the users home directory:
+# ~/.facter/facts.d
+# ~/.puppetlabs/opt/facter/facts.d
+test_name "C64580: Non-root default user external facts directory is searched for facts" do
+  tag 'risk:high'
+
+  confine :except, :platform => 'aix' # bug FACT-1586
+
+  confine :except, :platform => 'windows' # this test currently only supported on unix systems FACT-1647
+  confine :except, :platform => 'osx' # does not support managehome
+  confine :except, :platform => 'solaris' # does not work with managehome on solaris boxes
+  confine :except, :platform => 'eos-' # does not support user creation ARISTA-37
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  # Generate an external fact dynamically
+  def ext_user_fact(value='BASIC')
+    "test: '#{value}'"
+  end
+
+  # Retrieve a specific user's home directory $HOME/.facter
+  #
+  def get_user_facter_dir(user_home, platform)
+    File.join(user_home, '.facter')
+  end
+
+  # Retrieve a specific user's home facts directory $HOME/.facter/facts.d
+  #
+  def get_user_facts_dir(user_home, platform)
+    File.join(get_user_facter_dir(user_home, platform), 'facts.d')
+  end
+
+  # Retreive a specific user's home puppetlabs directory $HOME/.puppetlabs
+  #
+  def get_user_puppetlabs_dir(user_home, platform)
+    File.join(user_home, '.puppetlabs')
+  end
+
+  # Retreive a specific user's home puppetlabs facts directory $HOME/.puppetlabs/opt/facter/facts.d
+  #
+  def get_user_puppetlabs_facts_dir(user_home, platform)
+    File.join(get_user_puppetlabs_dir(user_home, platform), 'opt', 'facter', 'facts.d')
+  end
+
+  # retrieve the user's home directory for a host and user
+  #
+  def get_home_dir(host, user_name)
+    home_dir = nil
+    on host, puppet_resource('user', user_name) do |result|
+      home_dir = result.stdout.match(/home\s*=>\s*'([^']+)'/m)[1]
+    end
+    home_dir
+  end
+
+  agents.each do |agent|
+    non_root_user = "nonroot"
+
+    step "Agent #{agent}: create a #{non_root_user} to run facter with" do
+      on(agent, "puppet resource user #{non_root_user} ensure=present managehome=true shell='#{user_shell(agent)}'")
+    end
+
+    user_home = get_home_dir(agent, non_root_user)
+
+    # The directories that facter processes facts for a user from
+    user_base_facts_dir = get_user_facter_dir(user_home, agent['platform'])
+    user_facts_dir = get_user_facts_dir(user_home, agent['platform'])
+    user_facts_path = "#{user_facts_dir}/test.yaml"
+
+    user_base_puppetlabs_dir = get_user_puppetlabs_dir(user_home, agent['platform'])
+    user_puppetlabs_facts_dir = get_user_puppetlabs_facts_dir(user_home, agent['platform'])
+    user_puppetlabs_facts_path = "#{user_puppetlabs_facts_dir}/test.yaml"
+
+    step "Agent #{agent}: figure out facter program location"
+    facter_path = on(agent, "which facter").stdout.chomp
+
+    teardown do
+      on(agent, "rm -rf '#{user_base_facts_dir}' '#{user_base_puppetlabs_dir}'")
+      on(agent, puppet("resource user #{non_root_user} ensure=absent managehome=true"))
+    end
+
+    step "Agent #{agent}: create facts directory (#{user_facts_dir})" do
+      on(agent, "rm -rf '#{user_facts_dir}'")
+      on(agent, "mkdir -p '#{user_facts_dir}'")
+    end
+
+    step "Agent #{agent}: create and resolve a custom fact in #{user_facts_dir}" do
+      create_remote_file(agent, user_facts_path, ext_user_fact('USER_TEST_FACTER'))
+    end
+
+    step "Agent #{agent}: chown and chmod the facts to the user #{non_root_user}" do
+      on(agent, "chown -R #{non_root_user} '#{user_base_facts_dir}'")
+      on(agent, "chmod -R a+rx '#{user_base_facts_dir}'")
+    end
+
+    step "Agent #{agent}: run facter as #{non_root_user} and make sure we get the fact" do
+      on(agent, %Q[su #{non_root_user} -c "'#{facter_path}' test"]) do |facter_result|
+        assert_match(/USER_TEST_FACTER/, facter_result.stdout, "Fact from #{user_facts_dir} did not resolve correctly")
+      end
+    end
+
+    step "Agent #{agent}: remove #{user_facts_path}" do
+      on(agent, "rm -rf '#{user_facts_path}'")
+    end
+
+    step "Agent #{agent}: create facts directory (#{user_puppetlabs_facts_dir})" do
+      on(agent, "rm -rf '#{user_puppetlabs_facts_dir}'")
+      on(agent, "mkdir -p '#{user_puppetlabs_facts_dir}'")
+    end
+
+    step "Agent #{agent}: create and resolve a custom fact in #{user_puppetlabs_facts_dir}" do
+      create_remote_file(agent, user_puppetlabs_facts_path, ext_user_fact('USER_TEST_PUPPETLABS'))
+    end
+
+    step "Agent #{agent}: chown and chmod the facts to the user #{non_root_user}" do
+      on(agent, "chown -R #{non_root_user} '#{user_base_puppetlabs_dir}'")
+      on(agent, "chmod -R a+rx '#{user_base_puppetlabs_dir}'")
+    end
+
+    step "Agent #{agent}: run facter as #{non_root_user} and make sure we get the fact" do
+      on(agent, %Q[su #{non_root_user} -c "'#{facter_path}' test"]) do |facter_result|
+        assert_match(/USER_TEST_PUPPETLABS/, facter_result.stdout, "Fact from #{user_puppetlabs_facts_dir} did not resolve correctly")
+      end
+    end
+
+    step "Agent #{agent}: create and resolve a custom fact in #{user_puppetlabs_facts_dir}" do
+      create_remote_file(agent, user_facts_path, ext_user_fact('USER_PRECEDENCE_FACTER'))
+      create_remote_file(agent, user_puppetlabs_facts_path, ext_user_fact('USER_PRECEDENCE_PUPPETLABS'))
+    end
+
+    step "Agent #{agent}: chown and chmod the facts to the user #{non_root_user}" do
+      on(agent, "chown -R #{non_root_user} '#{user_base_facts_dir}' '#{user_base_puppetlabs_dir}'")
+      on(agent, "chmod -R a+rx '#{user_base_facts_dir}' '#{user_base_puppetlabs_dir}'")
+    end
+
+    step "Agent #{agent}: run facter as #{non_root_user} and .facter will take precedence over .puppetlabs" do
+      on(agent, %Q[su #{non_root_user} -c "'#{facter_path}' test"]) do |facter_result|
+        assert_match(/USER_PRECEDENCE_FACTER/, facter_result.stdout, "Fact from #{user_puppetlabs_facts_dir} did not resolve correctly")
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/root_uses_default_external_fact_dir.rb

@@ -0,0 +1,34 @@
+# facter resolves facts from the default facts.d directory
+# on Unix this can be 3 directories (See fact_directory_precedence.rb)
+# Unix - /opt/puppetlabs/facter/facts.d/
+# Windows - C:\ProgramData\PuppetLabs\facter\facts.d\
+test_name "C87571: facter resolves facts in the 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)
+    fact_file = File.join(factsd, "external_fact_1#{ext}")
+    content = external_fact_content(agent['platform'], 'external_fact', 'external_value')
+
+    teardown do
+      on(agent, "rm -f '#{fact_file}'")
+    end
+
+    step "Agent #{agent}: setup default external facts directory and fact" do
+      on(agent, "mkdir -p '#{factsd}'")
+      create_remote_file(agent, fact_file, content)
+      on(agent, "chmod +x '#{fact_file}'")
+    end
+
+    step "agent #{agent}: resolve the external fact" do
+      on(agent, facter('external_fact')) do |facter_output|
+        assert_equal('external_value', facter_output.stdout.chomp, 'Expected to resolve the external_fact')
+      end
+    end
+  end
+end

data/acceptance/tests/external_facts/structured_executable_facts.rb

@@ -0,0 +1,139 @@
+# This test is intended to demonstrate that executable external facts can return
+# YAML or JSON data, in addition to plain key-value pairs. If the output cannot be
+# parsed as YAML, it will fall back to key-value pair parsing, and only fail if
+# this is also invalid.
+test_name "executable external facts can return structured data" do
+
+  require 'facter/acceptance/user_fact_utils'
+  extend Facter::Acceptance::UserFactUtils
+
+  unix_fact_yaml = <<EOM
+#!/bin/sh
+echo "yaml_fact: [ 'one', 'two', 'three' ]"
+EOM
+
+  unix_fact_json = <<EOM
+#!/bin/sh
+echo "{ json_fact: { element: 1 } }"
+EOM
+
+  unix_fact_kv = <<EOM
+#!/bin/sh
+echo "kv_fact=one"
+EOM
+
+  unix_fact_bad = <<EOM
+#!/bin/sh
+echo "bad_fact : : not, json"
+EOM
+
+  win_fact_yaml = <<EOM
+@echo off
+echo yaml_fact: [ 'one', 'two', 'three' ]
+EOM
+
+  win_fact_json = <<EOM
+@echo off
+echo { json_fact: { element: 1 } }
+EOM
+
+  win_fact_kv = <<EOM
+@echo off
+echo kv_fact=one
+EOM
+
+  win_fact_bad = <<EOM
+@echo off
+echo bad_fact : : not, json
+EOM
+
+  yaml_structured_output = <<EOM
+[
+  "one",
+  "two",
+  "three"
+]
+EOM
+
+  json_structured_output = <<EOM
+{
+  element => 1
+}
+EOM
+
+  kv_output = 'one'
+
+  agents.each do |agent|
+    os_version = on(agent, facter('kernelmajversion')).stdout.chomp.to_f
+    factsd = get_factsd_dir(agent['platform'], os_version)
+    ext = get_external_fact_script_extension(agent['platform'])
+
+    if agent['platform'] =~ /windows/
+      yaml_content = win_fact_yaml
+      json_content = win_fact_json
+      kv_content = win_fact_kv
+      bad_fact_content = win_fact_bad
+    else
+      yaml_content = unix_fact_yaml
+      json_content = unix_fact_json
+      kv_content = unix_fact_kv
+      bad_fact_content = unix_fact_bad
+    end
+
+    step "Agent #{agent}: setup default external facts directory (facts.d)" do
+      on(agent, "mkdir -p '#{factsd}'")
+    end
+
+    teardown do
+      on(agent, "rm -rf '#{factsd}'")
+    end
+
+    step "Agent #{agent}: create an executable yaml fact in default facts.d" do
+      yaml_fact = File.join(factsd, "yaml_fact#{ext}")
+      create_remote_file(agent, yaml_fact, yaml_content)
+      on(agent, "chmod +x '#{yaml_fact}'")
+
+      step "YAML output should produce a structured fact" do
+        on(agent, facter("yaml_fact")) do
+          assert_match(/#{yaml_structured_output}/, stdout, "Expected properly structured fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create an executable json fact in default facts.d" do
+      json_fact = File.join(factsd, "json_fact#{ext}")
+      create_remote_file(agent, json_fact, json_content)
+      on(agent, "chmod +x '#{json_fact}'")
+
+      step "JSON output should produce a structured fact" do
+        on(agent, facter("json_fact")) do
+          assert_match(/#{json_structured_output}/, stdout, "Expected properly structured fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create an executable key-value fact in default facts.d" do
+      kv_fact = File.join(factsd, "kv_fact#{ext}")
+      create_remote_file(agent, kv_fact, kv_content)
+      on(agent, "chmod +x '#{kv_fact}'")
+
+      step "output that is neither yaml nor json should not produce a structured fact" do
+        on(agent, facter("kv_fact")) do
+          assert_match(/#{kv_output}/, stdout, "Expected a simple key-value fact")
+        end
+      end
+    end
+
+    step "Agent #{agent}: create a malformed executable fact in default facts.d" do
+      bad_fact = File.join(factsd, "bad_fact#{ext}")
+      create_remote_file(agent, bad_fact, bad_fact_content)
+      on(agent, "chmod +x '#{bad_fact}'")
+
+      step "should error when output is not in a supported format" do
+        on(agent, facter("bad_fact --debug")) do
+          assert_match(/Could not parse executable fact/, stderr, "Expected parsing the malformed fact to fail")
+        end
+      end
+    end
+  end
+end