puppet 4.1.0 → 4.10.0

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -43,7 +43,7 @@ describe "when using function data provider" do
     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]"]
+    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
 
@@ -56,6 +56,24 @@ describe "when using function data provider" do
     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
@@ -72,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
@@ -91,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

@@ -71,4 +71,51 @@ describe "Defaults" do
     end
 
   end
+
+  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
+
+    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
+
+  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 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 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
+
+  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

data/spec/unit/environments_spec.rb

@@ -121,6 +121,7 @@ describe Puppet::Environments do
 manifest=#{manifestdir}
 modulepath=#{modulepath.join(File::PATH_SEPARATOR)}
 config_version=/some/script
+static_catalogs=false
         EOF
       end
 
@@ -156,6 +157,17 @@ config_version=/some/script
         end
       end
 
+      it "reads static_catalogs setting" do
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script')).
+            with_static_catalogs(false)
+        end
+      end
+
       it "accepts an empty environment.conf without warning" do
         content = nil
 
@@ -176,7 +188,8 @@ config_version=/some/script
           expect(loader.get("env1")).to environment(:env1).
             with_manifest("#{FS.path_string(envdir)}/env1/manifests").
             with_modulepath(["#{FS.path_string(envdir)}/env1/modules", global_path_location]).
-            with_config_version(nil)
+            with_config_version(nil).
+            with_static_catalogs(true)
         end
 
         expect(@logs).to be_empty
@@ -386,6 +399,7 @@ config_version=$vardir/random/scripts
       expect(conf.modulepath).to eq('')
       expect(conf.manifest).to eq(:no_manifest)
       expect(conf.config_version).to be_nil
+      expect(conf.static_catalogs).to eq(true)
     end
 
     it "returns nil if you request a configuration from an env that doesn't exist" do
@@ -547,7 +561,8 @@ config_version=$vardir/random/scripts
         (!@manifest || @manifest == env.manifest) &&
         (!@modulepath || @modulepath == env.modulepath) &&
         (!@full_modulepath || @full_modulepath == env.full_modulepath) &&
-        (!@config_version || @config_version == env.config_version)
+        (!@config_version || @config_version == env.config_version) &&
+        (!@static_catalogs || @static_catalogs == env.static_catalogs?)
     end
 
     chain :with_manifest do |manifest|
@@ -566,16 +581,21 @@ config_version=$vardir/random/scripts
       @config_version = config_version
     end
 
+    chain :with_static_catalogs do |static_catalogs|
+      @static_catalogs = static_catalogs
+    end
+
     description do
       "environment #{expected}" +
         (@manifest ? " with manifest #{@manifest}" : "") +
         (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "") +
         (@full_modulepath ? " with full_modulepath [#{@full_modulepath.join(', ')}]" : "") +
-        (@config_version ? " with config_version #{@config_version}" : "")
+        (@config_version ? " with config_version #{@config_version}" : "") +
+        (@static_catalogs ? " with static_catalogs #{@static_catalogs}" : "")
     end
 
     failure_message do |env|
-      "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
+      "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}>, static_catalogs = #{env.static_catalogs?} to be #{description}"
     end
   end
 
@@ -642,6 +662,8 @@ config_version=$vardir/random/scripts
     end
 
     def expired?(env_name)
+      # make expired? idempotent
+      return true if @expired_envs.include? (env_name)
       @expired_envs << env_name
       @expiration_sequence.pop
     end