puppet 8.4.0-universal-darwin → 8.5.0-universal-darwin

data/spec/unit/data_providers/function_data_provider_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe "when using function data provider" do
-  include PuppetSpec::Compiler
-
-  # There is a fully configured environment in fixtures in this location
-  let(:environmentpath) { parent_fixture('environments') }
-
-  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 such environment, 'production', 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
-
-  # The environment configured in the fixture has one module called 'abc'. Its class abc, includes
-  # a class called 'def'. This class has three parameters test1, test2, and test3 and it creates
-  # three notify with name set to the value of the three parameters.
-  #
-  # Since the abc class does not provide any parameter values to its def class, it attempts to
-  # get them from data lookup. The fixture has an environment that is configured to load data from
-  # a function called environment::data, this data sets test1, and test2.
-  # The module 'abc' is configured to get data by calling the function abc::data(), this function
-  # returns data for all three parameters test1-test3, now with the prefix 'module'.
-  #
-  # The result should be that the data set in the environment wins over those set in the
-  # module.
-  #
-  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
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
-
-    compiler = Puppet::Parser::Compiler.new(node)
-    loaders = compiler.loaders()
-    env_loader = loaders.private_environment_loader()
-    f = Puppet::Functions.create_function('environment::data') do
-      def data()
-        'this is not a hash'
-      end
-    end
-    env_loader.add_entry(:function, 'environment::data', f.new(compiler.topscope, env_loader), nil)
-    expect do
-      compiler.compile()
-    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
-    Puppet[:code] = 'include abc'
-    # find the loaders to patch with faulty function
-    node = Puppet::Node.new("testnode", :facts => Puppet::Node::Facts.new("facts", {}), :environment => 'production')
-
-    compiler = Puppet::Parser::Compiler.new(node)
-    loaders = compiler.loaders()
-    module_loader = loaders.public_loader_for_module('abc')
-    f = Puppet::Functions.create_function('abc::data') do
-      def data()
-        'this is not a hash'
-      end
-    end
-    module_loader.add_entry(:function, 'abc::data', f.new(compiler.topscope, module_loader), nil)
-    expect do
-      compiler.compile()
-    end.to raise_error(/Value returned from deprecated API function 'abc::data' has wrong type/)
-  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/data_providers/hiera_data_provider_spec.rb

@@ -1,362 +0,0 @@
-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'
-    compiler.topscope['my_fact'] = 'server3'
-    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)
-    compiler.topscope['my_fact'] = 'server3'
-    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)
-        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)
-        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))
-        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))
-        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