puppet 4.0.0 → 5.0.0

data/spec/unit/context/trusted_information_spec.rb

@@ -47,6 +47,8 @@ describe Puppet::Context::TrustedInformation do
         '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
         '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
       })
+      expect(trusted.hostname).to eq('cert name')
+      expect(trusted.domain).to be_nil
     end
 
     it "is remote but lacks certificate information when it is authenticated" do
@@ -69,6 +71,8 @@ describe Puppet::Context::TrustedInformation do
       expect(trusted.authenticated).to eq('local')
       expect(trusted.certname).to eq('cert name')
       expect(trusted.extensions).to eq({})
+      expect(trusted.hostname).to eq('cert name')
+      expect(trusted.domain).to be_nil
     end
 
     it "is authenticated local with no clientcert when there is no node" do
@@ -77,6 +81,8 @@ describe Puppet::Context::TrustedInformation do
       expect(trusted.authenticated).to eq('local')
       expect(trusted.certname).to be_nil
       expect(trusted.extensions).to eq({})
+      expect(trusted.hostname).to be_nil
+      expect(trusted.domain).to be_nil
     end
   end
 
@@ -89,7 +95,24 @@ describe Puppet::Context::TrustedInformation do
       'extensions' => {
         '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
         '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
-      }
+      },
+      'hostname' => 'cert name',
+      'domain' => nil
+    })
+  end
+
+  it "extracts domain and hostname from certname" do
+    trusted = Puppet::Context::TrustedInformation.remote(true, 'hostname.domain.long', cert)
+
+    expect(trusted.to_h).to eq({
+      'authenticated' => 'remote',
+      'certname' => 'hostname.domain.long',
+      'extensions' => {
+        '1.3.6.1.4.1.34380.1.2.1' => 'CSR specific info',
+        '1.3.6.1.4.1.34380.1.2.2' => 'more CSR specific info',
+      },
+      'hostname' => 'hostname',
+      'domain' => 'domain.long'
     })
   end
 

data/spec/unit/daemon_spec.rb

@@ -45,15 +45,24 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
   end
 
   describe "when setting signal traps" do
-    signals = {:INT => :stop, :TERM => :stop }
-    signals.update({:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}) unless Puppet.features.microsoft_windows?
-    signals.each do |signal, method|
-      it "should log and call #{method} when it receives #{signal}" do
-        Signal.expects(:trap).with(signal).yields
+    [:INT, :TERM].each do |signal|
+      it "logs a notice and exits when sent #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; exiting")
+        daemon.expects(:stop)
 
-        Puppet.expects(:notice)
+        daemon.set_signal_traps
+      end
+    end
+
+    {:HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
+      it "logs a notice and remembers to call #{method} when it receives #{signal}" do
+        Signal.stubs(:trap).with(signal).yields
+        Puppet.expects(:notice).with("Caught #{signal}; storing #{method}")
 
         daemon.set_signal_traps
+
+        expect(daemon.signals).to eq([method])
       end
     end
   end
@@ -176,7 +185,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should do nothing if the agent is running" do
-      agent.expects(:running?).returns true
+      agent.expects(:run).with({:splay => false}).raises Puppet::LockError, 'Failed to aquire lock'
+      Puppet.expects(:notice).with('Not triggering already-running agent')
 
       daemon.agent = agent
 
@@ -184,8 +194,8 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should run the agent if one is available and it is not running" do
-      agent.expects(:running?).returns false
       agent.expects(:run).with({:splay => false})
+      Puppet.expects(:notice).with('Not triggering already-running agent').never
 
       daemon.agent = agent
 

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -38,15 +38,42 @@ describe "when using function data provider" do
   # The result should be that the data set in the environment wins over those set in the
   # module.
   #
-  it 'it gets data from module and environment functions and combines them with env having higher precedence' do
+  it 'gets data from module and environment functions and combines them with env having higher precedence' do
     Puppet[:code] = 'include abc'
     node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
     compiler = Puppet::Parser::Compiler.new(node)
     catalog = compiler.compile()
+    resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]", "Notify[env_test2-ipl]"]
+    expect(resources_in(catalog)).to include(*resources_created_in_fixture)
+  end
+
+  it 'gets data from module having a puppet function delivering module data' do
+    Puppet[:code] = 'include xyz'
+    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
+    compiler = Puppet::Parser::Compiler.new(node)
+    catalog = compiler.compile()
     resources_created_in_fixture = ["Notify[env_test1]", "Notify[env_test2]", "Notify[module_test3]"]
     expect(resources_in(catalog)).to include(*resources_created_in_fixture)
   end
 
+  it 'gets data from puppet function delivering environment data' do
+    Puppet[:code] = <<-CODE
+      function environment::data() {
+        { 'cls::test1' => 'env_puppet1',
+          'cls::test2' => 'env_puppet2'
+        }
+      }
+      class cls ($test1, $test2) {
+        notify { $test1: }
+        notify { $test2: }
+      }
+      include cls
+    CODE
+    node = Puppet::Node.new('testnode', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'production')
+    catalog = Puppet::Parser::Compiler.new(node).compile
+    expect(resources_in(catalog)).to include('Notify[env_puppet1]', 'Notify[env_puppet2]')
+  end
+
   it 'raises an error if the environment data function does not return a hash' do
     Puppet[:code] = 'include abc'
     # find the loaders to patch with faulty function
@@ -63,7 +90,7 @@ describe "when using function data provider" do
     env_loader.add_entry(:function, 'environment::data', f.new(compiler.topscope, env_loader), nil)
     expect do
       compiler.compile()
-    end.to raise_error(/Expected 'environment::data' function to return a Hash/)
+    end.to raise_error(/Value returned from deprecated API function 'environment::data' has wrong type/)
   end
 
   it 'raises an error if the module data function does not return a hash' do
@@ -82,7 +109,7 @@ describe "when using function data provider" do
     module_loader.add_entry(:function, 'abc::data', f.new(compiler.topscope, module_loader), nil)
     expect do
       compiler.compile()
-    end.to raise_error(/Expected 'abc::data' function to return a Hash/)
+    end.to raise_error(/Value returned from deprecated API function 'abc::data' has wrong type/)
   end
 
   def parent_fixture(dir_name)

data/spec/unit/data_providers/hiera_data_provider_spec.rb

@@ -0,0 +1,361 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+describe "when using a hiera data provider" do
+  include PuppetSpec::Compiler
+
+  # There is a fully configured 'sample' environment in fixtures at this location
+  let(:environmentpath) { parent_fixture('environments') }
+
+  let(:facts) { Puppet::Node::Facts.new("facts", {}) }
+
+  around(:each) do |example|
+    # Initialize settings to get a full compile as close as possible to a real
+    # environment load
+    Puppet.settings.initialize_global_settings
+    # Initialize loaders based on the environmentpath. It does not work to
+    # just set the setting environmentpath for some reason - this achieves the same:
+    # - first a loader is created, loading directory environments from the fixture (there is
+    # one environment, 'sample', which will be loaded since the node references this
+    # environment by name).
+    # - secondly, the created env loader is set as 'environments' in the puppet context.
+    #
+    loader = Puppet::Environments::Directories.new(environmentpath, [])
+    Puppet.override(:environments => loader) do
+      example.run
+    end
+  end
+
+  def compile_and_get_notifications(environment, code = nil)
+    extract_notifications(compile(environment, code))
+  end
+
+  def compile(environment, code = nil)
+    Puppet[:code] = code if code
+    node = Puppet::Node.new("testnode", :facts => facts, :environment => environment)
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['domain'] = 'example.com'
+    block_given? ? compiler.compile { |catalog| yield(compiler); catalog } : compiler.compile
+  end
+
+  def extract_notifications(catalog)
+    catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+  end
+
+  it 'uses default configuration for environment and module data' do
+    resources = compile_and_get_notifications('hiera_defaults')
+    expect(resources).to include('module data param_a is 100, param default is 200, env data param_c is 300')
+  end
+
+  it 'reads hiera.yaml in environment root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_env_config')
+    expect(resources).to include("env data param_a is 10, env data param_b is 20, env data param_c is 30, env data param_d is 40, env data param_e is 50, env data param_yaml_utf8 is \u16EB\u16D2\u16E6, env data param_json_utf8 is \u16A0\u16C7\u16BB")
+  end
+
+  it 'reads hiera.yaml in module root and configures multiple json and yaml providers' do
+    resources = compile_and_get_notifications('hiera_module_config')
+    expect(resources).to include('module data param_a is 100, module data param_b is 200, module data param_c is 300, module data param_d is 400, module data param_e is 500')
+  end
+
+  it 'keeps lookup_options in one module separate from lookup_options in another' do
+    resources1 = compile('hiera_modules', 'include one').resources.select {|r| r.ref.start_with?('Class[One]')}
+    resources2 = compile('hiera_modules', 'include two').resources.select {|r| r.ref.start_with?('Class[One]')}
+    expect(resources1).to eq(resources2)
+  end
+
+  it 'does not perform merge of values declared in environment and module when resolving parameters' do
+    resources = compile_and_get_notifications('hiera_misc')
+    expect(resources).to include('env 1, ')
+  end
+
+  it 'performs hash merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::test::param, Hash[String,String], hash) notify{"${r[key1]}, ${r[key2]}":}')
+    expect(resources).to include('env 1, module 2')
+  end
+
+  it 'performs unique merge of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', '$r = lookup(one::array, Array[String], unique) notify{"${r}":}')
+    expect(resources.size).to eq(1)
+    expect(resources[0][1..-2].split(', ')).to contain_exactly('first', 'second', 'third', 'fourth')
+  end
+
+  it 'performs merge found in lookup_options in environment of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::lopts_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it 'performs merge found in lookup_options in module of values declared in environment and module' do
+    resources = compile_and_get_notifications('hiera_misc', 'include one::loptsm_test')
+    expect(resources.size).to eq(1)
+    expect(resources[0]).to eq('A, B, C, MA, MB, MC')
+  end
+
+  it "will not find 'lookup_options' as a regular value" do
+    expect { compile_and_get_notifications('hiera_misc', '$r = lookup("lookup_options")') }.to raise_error(Puppet::DataBinding::LookupError, /did not find a value/)
+  end
+
+  it 'does find unqualified keys in the environment' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey1):}')
+    expect(resources).to include('Some value')
+  end
+
+  it 'does not find unqualified keys in the module' do
+    expect do
+      compile_and_get_notifications('hiera_misc', 'notify{lookup(ukey2):}')
+    end.to raise_error(Puppet::ParseError, /did not find a value for the name 'ukey2'/)
+  end
+
+  it 'can use interpolation lookup method "alias"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_alias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'can use interpolation lookup method "lookup"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_lookup):}')
+    expect(resources).to include('Value from interpolation with lookup')
+  end
+
+  it 'can use interpolation lookup method "hiera"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_hiera):}')
+    expect(resources).to include('Value from interpolation with hiera')
+  end
+
+  it 'can use interpolation lookup method "literal"' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_literal):}')
+    expect(resources).to include('Value from interpolation with literal')
+  end
+
+  it 'can use interpolation lookup method "scope"' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_scope = "with scope" notify{lookup(km_scope):}')
+    expect(resources).to include('Value from interpolation with scope')
+  end
+
+  it 'can use interpolation using default lookup method (scope)' do
+    resources = compile_and_get_notifications('hiera_misc', '$target_default = "with default" notify{lookup(km_default):}')
+    expect(resources).to include('Value from interpolation with default')
+  end
+
+  it 'performs lookup using qualified expressions in interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', "$os = { name => 'Fedora' } notify{lookup(km_qualified):}")
+    expect(resources).to include('Value from qualified interpolation OS = Fedora')
+  end
+
+  it 'can have multiple interpolate expressions in one value' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_multi):}')
+    expect(resources).to include('cluster/%{::cluster}/%{role}')
+  end
+
+  it 'performs single quoted interpolation' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(km_sqalias):}')
+    expect(resources).to include('Value from interpolation with alias')
+  end
+
+  it 'uses compiler lifecycle for caching' do
+    Puppet[:code] = 'notify{lookup(one::my_var):}'
+    node = Puppet::Node.new('testnode', :facts => facts, :environment => 'hiera_module_config')
+
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['my_fact'] = 'server1'
+    expect(extract_notifications(compiler.compile)).to include('server1')
+
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.topscope['my_fact'] = 'server2'
+    expect(extract_notifications(compiler.compile)).to include('server2')
+
+    compiler = Puppet::Parser::Compiler.new(node)
+    expect(extract_notifications(compiler.compile)).to include('In name.yaml')
+  end
+
+  it 'traps endless interpolate recursion' do
+    expect do
+      compile_and_get_notifications('hiera_misc', '$r1 = "%{r2}" $r2 = "%{r1}" notify{lookup(recursive):}')
+    end.to raise_error(Puppet::DataBinding::RecursiveLookupError, /detected in \[recursive, scope:r1, scope:r2\]/)
+  end
+
+  it 'does not consider use of same key in the lookup and scope namespaces as recursion' do
+    resources = compile_and_get_notifications('hiera_misc', 'notify{lookup(domain):}')
+    expect(resources).to include('-- example.com --')
+  end
+
+  it 'traps bad alias declarations' do
+    expect do
+      compile_and_get_notifications('hiera_misc', "$r1 = 'Alias within string %{alias(\"r2\")}' $r2 = '%{r1}' notify{lookup(recursive):}")
+    end.to raise_error(Puppet::DataBinding::LookupError, /'alias' interpolation is only permitted if the expression is equal to the entire string/)
+  end
+
+  it 'reports syntax errors for JSON files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_json')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  it 'reports syntax errors for YAML files' do
+    expect do
+      compile_and_get_notifications('hiera_bad_syntax_yaml')
+    end.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse \(#{environmentpath}[^)]+\):/)
+  end
+
+  describe 'when using explain' do
+    it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        value = Puppet::Pops::Lookup.lookup('km_scope', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.explain).to include(<<-EOS)
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: "common.yaml"
+        Interpolation on "Value from interpolation %{scope("target_scope")}"
+          Global Scope
+            Found key: "target_scope" value: "with scope"
+        Found key: "km_scope" value: "Value from interpolation with scope"
+          EOS
+      end
+    end
+
+    it 'will report that merge options was found in the lookup_options hash' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, true)
+        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.explain).to include("Using merge options from \"lookup_options\" hash")
+      end
+    end
+
+    it 'will report lookup_options details in combination with details of found value' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true))
+        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.explain).to eq(<<EOS)
+Searching for "lookup_options"
+  Global Data Provider (hiera configuration version 5)
+    No such key: "lookup_options"
+  Environment Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::lopts_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Module "one" Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::loptsm_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Merge strategy hash
+    Global and Environment
+      Found key: "lookup_options" value: {
+        "one::lopts_test::hash" => {
+          "merge" => "deep"
+        }
+      }
+    Module one
+      Found key: "lookup_options" value: {
+        "one::loptsm_test::hash" => {
+          "merge" => "deep"
+        }
+      }
+    Merged result: {
+      "one::loptsm_test::hash" => {
+        "merge" => "deep"
+      },
+      "one::lopts_test::hash" => {
+        "merge" => "deep"
+      }
+    }
+Using merge options from "lookup_options" hash
+Searching for "one::loptsm_test::hash"
+  Merge strategy deep
+    Global Data Provider (hiera configuration version 5)
+      No such key: "one::loptsm_test::hash"
+    Environment Data Provider (hiera configuration version 5)
+      Hierarchy entry "Common"
+        Path "#{environmentpath}/hiera_misc/data/common.yaml"
+          Original path: "common.yaml"
+          Found key: "one::loptsm_test::hash" value: {
+            "a" => "A",
+            "b" => "B",
+            "m" => {
+              "ma" => "MA",
+              "mb" => "MB"
+            }
+          }
+    Module "one" Data Provider (hiera configuration version 5)
+      Hierarchy entry "Common"
+        Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+          Original path: "common.yaml"
+          Found key: "one::loptsm_test::hash" value: {
+            "a" => "A",
+            "c" => "C",
+            "m" => {
+              "ma" => "MA",
+              "mc" => "MC"
+            }
+          }
+    Merged result: {
+      "a" => "A",
+      "c" => "C",
+      "m" => {
+        "ma" => "MA",
+        "mc" => "MC",
+        "mb" => "MB"
+      },
+      "b" => "B"
+    }
+EOS
+      end
+    end
+
+    it 'will report config path (original and resolved), data path (original and resolved), and interpolation (before and after)' do
+      compile('hiera_misc', '$target_scope = "with scope"') do |compiler|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(compiler.topscope, {}, {}, Puppet::Pops::Lookup::Explainer.new(true, true))
+        value = Puppet::Pops::Lookup.lookup('one::loptsm_test::hash', nil, nil, nil, nil, lookup_invocation)
+        expect(lookup_invocation.explainer.explain).to eq(<<EOS)
+Merge strategy hash
+  Global Data Provider (hiera configuration version 5)
+    No such key: "lookup_options"
+  Environment Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::lopts_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Module "one" Data Provider (hiera configuration version 5)
+    Hierarchy entry "Common"
+      Path "#{environmentpath}/hiera_misc/modules/one/data/common.yaml"
+        Original path: "common.yaml"
+        Found key: "lookup_options" value: {
+          "one::loptsm_test::hash" => {
+            "merge" => "deep"
+          }
+        }
+  Merged result: {
+    "one::loptsm_test::hash" => {
+      "merge" => "deep"
+    },
+    "one::lopts_test::hash" => {
+      "merge" => "deep"
+    }
+  }
+EOS
+      end
+    end
+  end
+
+  def parent_fixture(dir_name)
+    File.absolute_path(File.join(my_fixture_dir(), "../#{dir_name}"))
+  end
+
+  def resources_in(catalog)
+    catalog.resources.map(&:ref)
+  end
+
+end

data/spec/unit/defaults_spec.rb

@@ -42,33 +42,50 @@ describe "Defaults" do
     end
   end
 
-  describe 'cfacter' do
+  describe 'strict' do
+    it 'should accept the valid value :off' do
+      expect {Puppet.settings[:strict] = 'off'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :warning' do
+      expect {Puppet.settings[:strict] = 'warning'}.to_not raise_exception
+    end
+
+    it 'should accept the valid value :error' do
+      expect {Puppet.settings[:strict] = 'error'}.to_not raise_exception
+    end
 
-    before :each do
-      Facter.reset
+    it 'should fail if given an invalid value' do
+      expect {Puppet.settings[:strict] = 'ignore'}.to raise_exception(/Invalid value 'ignore' for parameter strict\./)
     end
+  end
 
-    it 'should default to false' do
-      expect(Puppet.settings[:cfacter]).to be_falsey
+  describe 'supported_checksum_types' do
+    it 'should default to md5,sha256' do
+      expect(Puppet.settings[:supported_checksum_types]).to eq(['md5', 'sha256'])
     end
 
-    it 'should raise an error if cfacter is not installed' do
-      Puppet.features.stubs(:cfacter?).returns false
-      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'cfacter version 0.2.0 or later is not installed.'
+    it 'should raise an error on an unsupported checksum type' do
+      expect { Puppet.settings[:supported_checksum_types] = ['md5', 'foo'] }.to raise_exception ArgumentError, 'Unrecognized checksum types ["foo"] are not supported. Valid values are ["md5", "md5lite", "sha256", "sha256lite", "sha1", "sha1lite", "mtime", "ctime"].'
     end
 
-    it 'should raise an error if facter has already evaluated facts' do
-      Facter[:facterversion]
-      Puppet.features.stubs(:cfacter?).returns true
-      expect { Puppet.settings[:cfacter] = true }.to raise_exception ArgumentError, 'facter has already evaluated facts.'
+    it 'should not raise an error on setting a valid list of checksum types' do
+      Puppet.settings[:supported_checksum_types] = ['sha256', 'md5lite', 'mtime']
+      expect(Puppet.settings[:supported_checksum_types]).to eq(['sha256', 'md5lite', 'mtime'])
     end
+  end
 
-    it 'should initialize cfacter when set to true' do
-      Puppet.features.stubs(:cfacter?).returns true
-      CFacter = mock
-      CFacter.stubs(:initialize)
-      Puppet.settings[:cfacter] = true
+  describe 'server vs server_list' do
+    it 'should warn when both settings are set in code' do
+      Puppet.expects(:deprecation_warning).with('Attempted to set both server and server_list. Server setting will not be used.', :SERVER_DUPLICATION)
+      Puppet.settings[:server] = 'test_server'
+      Puppet.settings[:server_list] = ['one', 'two']
     end
 
+    it 'should warn when both settings are set by command line' do
+      Puppet.expects(:deprecation_warning).with('Attempted to set both server and server_list. Server setting will not be used.', :SERVER_DUPLICATION)
+      Puppet.settings.handlearg("--server_list", "one,two")
+      Puppet.settings.handlearg("--server", "test_server")
+    end
   end
 end