puppet 7.28.0-x64-mingw32 → 7.29.0-x64-mingw32

data/spec/unit/pops/lookup/lookup_spec.rb

@@ -1,375 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/files'
-require 'puppet/pops'
-require 'deep_merge/core'
-
-module Puppet::Pops
-module Lookup
-describe 'The lookup API' do
-  include PuppetSpec::Files
-
-  let(:env_name) { 'spec' }
-  let(:code_dir) { Puppet[:environmentpath] }
-  let(:env_dir) { File.join(code_dir, env_name) }
-  let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
-  let(:node) { Puppet::Node.new('test', :environment => env) }
-  let(:compiler) { Puppet::Parser::Compiler.new(node) }
-  let(:pal_compiler) { Puppet::Pal::ScriptCompiler.new(compiler) }
-  let(:scope) { compiler.topscope }
-  let(:invocation) { Invocation.new(scope) }
-
-  let(:code_dir_content) do
-    {
-      'hiera.yaml' => <<-YAML.unindent,
-        version: 5
-        YAML
-      'data' => {
-        'common.yaml' => <<-YAML.unindent
-          a: a (from global)
-          d: d (from global)
-          mod::e: mod::e (from global)
-          YAML
-      }
-    }
-  end
-
-  let(:env_content) do
-    {
-      'hiera.yaml' => <<-YAML.unindent,
-        version: 5
-        YAML
-      'data' => {
-        'common.yaml' => <<-YAML.unindent
-          b: b (from environment)
-          d: d (from environment)
-          mod::f: mod::f (from environment)
-          YAML
-      }
-    }
-  end
-
-  let(:mod_content) do
-    {
-      'hiera.yaml' => <<-YAML.unindent,
-        version: 5
-        YAML
-      'data' => {
-        'common.yaml' => <<-YAML.unindent
-          mod::c: mod::c (from module)
-          mod::e: mod::e (from module)
-          mod::f: mod::f (from module)
-          mod::g:
-            :symbol: symbol key value
-            key: string key value
-            6: integer key value
-            -4: negative integer key value
-            2.7: float key value
-            '6': string integer key value
-          YAML
-      }
-    }
-  end
-
-  let(:populated_env_dir) do
-    all_content = code_dir_content.merge(env_name => env_content.merge('modules' => { 'mod' => mod_content }))
-    dir_contained_in(code_dir, all_content)
-    all_content.keys.each { |key| PuppetSpec::Files.record_tmp(File.join(code_dir, key)) }
-    env_dir
-  end
-
-  before(:each) do
-    Puppet[:hiera_config] = File.join(code_dir, 'hiera.yaml')
-    Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
-  end
-
-  after(:each) do
-    Puppet.pop_context
-  end
-
-  context 'when doing automatic parameter lookup' do
-
-    let(:mod_content) do
-      {
-        'hiera.yaml' => <<-YAML.unindent,
-          version: 5
-          YAML
-        'data' => {
-          'common.yaml' => <<-YAML.unindent
-            mod::x: mod::x (from module)
-            YAML
-        },
-        'manifests' => {
-           'init.pp' => <<-PUPPET.unindent
-             class mod($x) {
-               notify { $x: }
-             }
-             PUPPET
-        }
-      }
-    end
-    let(:logs) { [] }
-    let(:debugs) { logs.select { |log| log.level == :debug }.map { |log| log.message } }
-
-    it 'includes APL in explain output when debug is enabled' do
-      Puppet[:log_level] = 'debug'
-      Puppet[:code] = 'include mod'
-      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-        compiler.compile
-      end
-      expect(debugs).to include(/Found key: "mod::x" value: "mod::x \(from module\)"/)
-    end
-  end
-
-  context 'when hiera YAML data is corrupt' do
-    let(:mod_content) do
-      {
-        'hiera.yaml' => 'version: 5',
-        'data' => {
-          'common.yaml' => <<-YAML.unindent
-            ---
-            #mod::classes:
-              - cls1
-              - cls2
-              
-            mod::somevar: 1
-            YAML
-        },
-      }
-    end
-    let(:msg) { /file does not contain a valid yaml hash/ }
-
-    %w(off warning).each do |strict|
-      it "logs a warning when --strict is '#{strict}'" do
-        Puppet[:strict] = strict
-        logs = []
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Lookup.lookup('mod::somevar', nil, nil, true, nil, invocation)).to be_nil
-        end
-        expect(logs.map(&:message)).to contain_exactly(msg)
-      end
-    end
-
-    it 'fails when --strict is "error"' do
-      Puppet[:strict] = 'error'
-      expect { Lookup.lookup('mod::somevar', nil, nil, true, nil, invocation) }.to raise_error(msg)
-    end
-  end
-
-  context 'when hiera YAML data is empty' do
-    let(:mod_content) do
-      {
-        'hiera.yaml' => 'version: 5',
-        'data' => { 'common.yaml' => '' },
-      }
-    end
-    let(:msg) { /file does not contain a valid yaml hash/ }
-
-    %w(off warning error).each do |strict|
-      it "logs a warning when --strict is '#{strict}'" do
-        Puppet[:strict] = strict
-        logs = []
-        Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
-          expect(Lookup.lookup('mod::somevar', nil, nil, true, nil, invocation)).to be_nil
-        end
-        expect(logs.map(&:message)).to contain_exactly(msg)
-      end
-    end
-  end
-
-  context 'when doing lookup' do
-    it 'finds data in global layer' do
-      expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
-    end
-
-    it 'finds data in environment layer' do
-      expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
-    end
-
-    it 'global layer wins over environment layer' do
-      expect(Lookup.lookup('d', nil, 'not found', true, nil, invocation)).to eql('d (from global)')
-    end
-
-    it 'finds data in module layer' do
-      expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
-    end
-
-    it 'global layer wins over module layer' do
-      expect(Lookup.lookup('mod::e', nil, 'not found', true, nil, invocation)).to eql('mod::e (from global)')
-    end
-
-    it 'environment layer wins over module layer' do
-      expect(Lookup.lookup('mod::f', nil, 'not found', true, nil, invocation)).to eql('mod::f (from environment)')
-    end
-
-    it 'returns the correct types for hash keys' do
-      expect(Lookup.lookup('mod::g', nil, 'not found', true, nil, invocation)).to eql(
-	      {
-          'symbol' => 'symbol key value',
-		      'key' => 'string key value',
-		      6 => 'integer key value',
-          -4 => 'negative integer key value',
-		      2.7 => 'float key value',
-          '6' => 'string integer key value'
-	      }
-      )
-    end
-
-    it 'can navigate a hash with an integer key using a dotted key' do
-      expect(Lookup.lookup('mod::g.6', nil, 'not found', true, nil, invocation)).to eql('integer key value')
-    end
-
-    it 'can navigate a hash with a negative integer key using a dotted key' do
-      expect(Lookup.lookup('mod::g.-4', nil, 'not found', true, nil, invocation)).to eql('negative integer key value')
-    end
-
-    it 'can navigate a hash with an string integer key using a dotted key with quoted integer' do
-      expect(Lookup.lookup("mod::g.'6'", nil, 'not found', true, nil, invocation)).to eql('string integer key value')
-    end
-
-    context "with 'global_only' set to true in the invocation" do
-      let(:invocation) { Invocation.new(scope).set_global_only }
-
-      it 'finds data in global layer' do
-        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
-      end
-
-      it 'does not find data in environment layer' do
-        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
-      end
-
-      it 'does not find data in module layer' do
-        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
-      end
-    end
-
-    context "with 'global_only' set to true in the lookup adapter" do
-      it 'finds data in global layer' do
-        invocation.lookup_adapter.set_global_only
-        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
-      end
-
-      it 'does not find data in environment layer' do
-        invocation.lookup_adapter.set_global_only
-        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('not found')
-      end
-
-      it 'does not find data in module layer' do
-        invocation.lookup_adapter.set_global_only
-        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('not found')
-      end
-    end
-
-    context 'with subclassed lookup adpater' do
-      let(:other_dir) { tmpdir('other') }
-      let(:other_dir_content) do
-        {
-          'hiera.yaml' => <<-YAML.unindent,
-            version: 5
-            hierarchy:
-              - name: Common
-                path: common.yaml
-              - name: More
-                path: more.yaml
-            YAML
-          'data' => {
-            'common.yaml' => <<-YAML.unindent,
-              a: a (from other global)
-              d: d (from other global)
-              mixed_adapter_hash:
-                a:
-                  ab: value a.ab (from other common global)
-                  ad: value a.ad (from other common global)
-              mod::e: mod::e (from other global)
-              lookup_options:
-                mixed_adapter_hash:
-                  merge: deep
-              YAML
-            'more.yaml' => <<-YAML.unindent
-              mixed_adapter_hash:
-                a:
-                  aa: value a.aa (from other more global)
-                  ac: value a.ac (from other more global)
-              YAML
-          }
-        }
-      end
-
-      let(:populated_other_dir) do
-        dir_contained_in(other_dir, other_dir_content)
-        other_dir
-      end
-
-      before(:each) do
-        eval(<<-RUBY.unindent)
-        class SpecialLookupAdapter < LookupAdapter
-           def initialize(compiler)
-             super
-             set_global_only
-             set_global_hiera_config_path(File.join('#{populated_other_dir}', 'hiera.yaml'))
-           end
-        end
-        RUBY
-      end
-
-      after(:each) do
-        Puppet::Pops::Lookup.send(:remove_const, :SpecialLookupAdapter)
-      end
-
-      let(:other_invocation) { Invocation.new(scope, EMPTY_HASH, EMPTY_HASH, nil, SpecialLookupAdapter) }
-
-      it 'finds different data in global layer' do
-        expect(Lookup.lookup('a', nil, nil, false, nil, other_invocation)).to eql('a (from other global)')
-        expect(Lookup.lookup('a', nil, nil, false, nil, invocation)).to eql('a (from global)')
-      end
-
-      it 'does not find data in environment layer' do
-        expect(Lookup.lookup('b', nil, 'not found', true, nil, other_invocation)).to eql('not found')
-        expect(Lookup.lookup('b', nil, 'not found', true, nil, invocation)).to eql('b (from environment)')
-      end
-
-      it 'does not find data in module layer' do
-        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, other_invocation)).to eql('not found')
-        expect(Lookup.lookup('mod::c', nil, 'not found', true, nil, invocation)).to eql('mod::c (from module)')
-      end
-
-      it 'resolves lookup options using the custom adapter' do
-        expect(Lookup.lookup('mixed_adapter_hash', nil, 'not found', true, nil, other_invocation)).to eql(
-          {
-            'a' => {
-              'aa' => 'value a.aa (from other more global)',
-              'ab' => 'value a.ab (from other common global)',
-              'ac' => 'value a.ac (from other more global)',
-              'ad' => 'value a.ad (from other common global)'
-            }
-          }
-        )
-      end
-    end
-  end
-
-  context 'when using plan_hierarchy' do
-    let(:code_dir_content) do
-      {
-        'hiera.yaml' => <<-YAML.unindent,
-        version: 5
-        plan_hierarchy:
-          - path: foo.yaml
-            name: Common
-        YAML
-        'data' => {
-          'foo.yaml' => <<-YAML.unindent
-          pop: star
-          YAML
-        }
-      }
-    end
-
-    it 'uses plan_hierarchy when using ScriptCompiler' do
-      Puppet.override(pal_compiler: pal_compiler) do
-        expect(Lookup.lookup('pop', nil, nil, true, nil, invocation)).to eq('star')
-      end
-    end
-  end
-end
-end
-end

data/spec/unit/pops/merge_strategy_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-module Puppet::Pops
-describe 'MergeStrategy' do
-  context 'deep merge' do
-    it 'does not mutate the source of a merge' do
-      a = { 'a' => { 'b' => 'va' }, 'c' => 2 }
-      b = { 'a' => { 'b' => 'vb' }, 'b' => 3}
-      c = MergeStrategy.strategy(:deep).merge(a, b);
-      expect(a).to eql({ 'a' => { 'b' => 'va' }, 'c' => 2 })
-      expect(b).to eql({ 'a' => { 'b' => 'vb' }, 'b' => 3 })
-      expect(c).to eql({ 'a' => { 'b' => 'va' }, 'b' => 3, 'c' => 2 })
-    end
-  end
-end
-end

data/spec/unit/pops/migration_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/pops'
-require 'puppet/pops/evaluator/evaluator_impl'
-require 'puppet/loaders'
-require 'puppet_spec/pops'
-require 'puppet_spec/scope'
-require 'puppet/parser/e4_parser_adapter'
-
-describe 'Puppet::Pops::MigrationMigrationChecker' do
-  include PuppetSpec::Pops
-  include PuppetSpec::Scope
-  before(:each) do
-    Puppet[:strict_variables] = true
-
-    # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
-    require 'puppet_x'
-
-    # Tests needs a known configuration of node/scope/compiler since it parses and evaluates
-    # snippets as the compiler will evaluate them, butwithout the overhead of compiling a complete
-    # catalog for each tested expression.
-    #
-    @parser  = Puppet::Pops::Parser::EvaluatingParser.new
-    @node = Puppet::Node.new('node.example.com')
-    @node.environment = Puppet::Node::Environment.create(:testing, [])
-    @compiler = Puppet::Parser::Compiler.new(@node)
-    @scope = Puppet::Parser::Scope.new(@compiler)
-    @scope.source = Puppet::Resource::Type.new(:node, 'node.example.com')
-    @scope.parent = @compiler.topscope
-  end
-
-  let(:scope) { @scope }
-
-  describe "when there is no MigrationChecker in the PuppetContext" do
-    it "a null implementation of the MigrationChecker gets created (once per impl that needs one)" do
-      migration_checker = Puppet::Pops::Migration::MigrationChecker.new()
-      expect(Puppet::Pops::Migration::MigrationChecker).to receive(:new).at_least(:once).and_return(migration_checker)
-      expect(Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__)).to eq(1)
-    end
-  end
-
-  describe "when there is a MigrationChecker in the Puppet Context" do
-    it "does not create any MigrationChecker instances when parsing and evaluating" do
-      migration_checker = double()
-      expect(Puppet::Pops::Migration::MigrationChecker).not_to receive(:new)
-      Puppet.override({:migration_checker => migration_checker}, "test-context") do
-        Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
-      end
-    end
-  end
-end

data/spec/unit/pops/model/model_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-describe Puppet::Pops::Model do
-  it "should be possible to create an instance of a model object" do
-    nop = Puppet::Pops::Model::Nop.new(Puppet::Pops::Parser::Locator.locator('code', 'file'), 0, 0)
-    expect(nop.class).to eq(Puppet::Pops::Model::Nop)
-  end
-end
-
-describe Puppet::Pops::Model::Factory do
-  Factory = Puppet::Pops::Model::Factory
-  Model = Puppet::Pops::Model
-
-  it "construct an arithmetic expression" do
-    x = Factory.literal(10) + Factory.literal(20)
-    expect(x.is_a?(Factory)).to eq(true)
-    model = x.model
-    expect(model.is_a?(Model::ArithmeticExpression)).to eq(true)
-    expect(model.operator).to eq('+')
-    expect(model.left_expr.class).to eq(Model::LiteralInteger)
-    expect(model.right_expr.class).to eq(Model::LiteralInteger)
-    expect(model.left_expr.value).to eq(10)
-    expect(model.right_expr.value).to eq(20)
-  end
-
-  it "should be easy to compare using a model tree dumper" do
-    x = Factory.literal(10) + Factory.literal(20)
-    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ 10 20)")
-  end
-
-  it "builder should apply precedence" do
-    x = Factory.literal(2) * Factory.literal(10) + Factory.literal(20)
-    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ (* 2 10) 20)")
-  end
-
-describe "should be describable with labels"
-  it 'describes a PlanDefinition as "Plan Definition"' do
-    expect(Puppet::Pops::Model::ModelLabelProvider.new.label(Factory.PLAN('test', [], nil))).to eq("Plan Definition")
-  end
-end

data/spec/unit/pops/model/pn_transformer_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-require 'puppet/pops/pn'
-
-module Puppet::Pops
-module Model
-
-describe 'Puppet::Pops::Model::PNTransformer' do
-  def call(name, *elements)
-    PN::Call.new(name, *elements.map { |e| lit(e) })
-  end
-
-  context 'transforms the expression' do
-    it '"\'hello\'" into the corresponding literal' do
-      x = Factory.literal('hello')
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(lit('hello'))
-    end
-
-    it '"32" into into the corresponding literal' do
-      x = Factory.literal(32)
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(lit(32))
-    end
-
-    it '"true" into into the corresponding literal' do
-      x = Factory.literal(true)
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(lit(true))
-    end
-
-    it '"10 + 20" into (+ 10 20)' do
-      x = Factory.literal(10) + Factory.literal(20)
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(call('+', 10, 20))
-    end
-
-    it '"[10, 20]" into into (array 10 20)' do
-      x = Factory.literal([10, 20])
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(call('array', 10, 20))
-    end
-
-    it '"{a => 1, b => 2}" into into (hash (=> ("a" 1)) (=> ("b" 2)))' do
-      x = Factory.HASH([Factory.KEY_ENTRY(Factory.literal('a'), Factory.literal(1)), Factory.KEY_ENTRY(Factory.literal('b'), Factory.literal(2))])
-      expect(Puppet::Pops::Model::PNTransformer.transform(x.model)).to eq(
-        call('hash', call('=>', 'a', 1), call('=>', 'b', 2)))
-    end
-
-    it 'replaces empty/nil body with a Nop' do
-      expect(Puppet::Pops::Model::PNTransformer.transform(nil)).to eq(call('nop'))
-    end
-  end
-
-  def lit(value)
-    value.is_a?(PN) ? value : PN::Literal.new(value)
-  end
-end
-end
-end
-

data/spec/unit/pops/parser/epp_parser_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
-
-module EppParserRspecHelper
-  include FactoryRspecHelper
-  def parse(code)
-    parser = Puppet::Pops::Parser::EppParser.new()
-    parser.parse_string(code)
-  end
-end
-
-describe "epp parser" do
-  include EppParserRspecHelper
-
-  it "should instantiate an epp parser" do
-    parser = Puppet::Pops::Parser::EppParser.new()
-    expect(parser.class).to eq(Puppet::Pops::Parser::EppParser)
-  end
-
-  it "should parse a code string and return a program with epp" do
-    parser = Puppet::Pops::Parser::EppParser.new()
-    model = parser.parse_string("Nothing to see here, move along...").model
-    expect(model.class).to eq(Puppet::Pops::Model::Program)
-    expect(model.body.class).to eq(Puppet::Pops::Model::LambdaExpression)
-    expect(model.body.body.class).to eq(Puppet::Pops::Model::EppExpression)
-  end
-
-  context "when facing bad input it reports" do
-    it "unbalanced tags" do
-      expect { dump(parse("<% missing end tag")) }.to raise_error(/Unbalanced/)
-    end
-
-    it "abrupt end" do
-      expect { dump(parse("dum di dum di dum <%")) }.to raise_error(/Unbalanced/)
-    end
-
-    it "nested epp tags" do
-      expect { dump(parse("<% $a = 10 <% $b = 20 %>%>")) }.to raise_error(/Syntax error/)
-    end
-
-    it "nested epp expression tags" do
-      expect { dump(parse("<%= 1+1 <%= 2+2 %>%>")) }.to raise_error(/Syntax error/)
-    end
-
-    it "rendering sequence of expressions" do
-      expect { dump(parse("<%= 1 2 3 %>")) }.to raise_error(/Syntax error/)
-    end
-  end
-
-  context "handles parsing of" do
-    it "text (and nothing else)" do
-      expect(dump(parse("Hello World"))).to eq([
-        "(lambda (epp (block",
-        "  (render-s 'Hello World')",
-        ")))"].join("\n"))
-    end
-
-    it "template parameters" do
-      expect(dump(parse("<%|$x|%>Hello World"))).to eq([
-        "(lambda (parameters x) (epp (block",
-        "  (render-s 'Hello World')",
-        ")))"].join("\n"))
-    end
-
-    it "template parameters with default" do
-      expect(dump(parse("<%|$x='cigar'|%>Hello World"))).to eq([
-        "(lambda (parameters (= x 'cigar')) (epp (block",
-        "  (render-s 'Hello World')",
-        ")))"].join("\n"))
-    end
-
-    it "template parameters with and without default" do
-      expect(dump(parse("<%|$x='cigar', $y|%>Hello World"))).to eq([
-        "(lambda (parameters (= x 'cigar') y) (epp (block",
-        "  (render-s 'Hello World')",
-        ")))"].join("\n"))
-    end
-
-    it "template parameters + additional setup" do
-      expect(dump(parse("<%|$x| $y = 10 %>Hello World"))).to eq([ 
-        "(lambda (parameters x) (epp (block",
-        "  (= $y 10)",
-        "  (render-s 'Hello World')",
-        ")))"].join("\n"))
-    end
-
-    it "comments" do
-      expect(dump(parse("<%#($x='cigar', $y)%>Hello World"))).to eq([
-        "(lambda (epp (block",
-        "  (render-s 'Hello World')",
-        ")))"
-        ].join("\n"))
-    end
-
-    it "verbatim epp tags" do
-      expect(dump(parse("<%% contemplating %%>Hello World"))).to eq([
-        "(lambda (epp (block",
-        "  (render-s '<% contemplating %>Hello World')",
-        ")))"
-        ].join("\n"))
-    end
-
-    it "expressions" do
-      expect(dump(parse("We all live in <%= 3.14 - 2.14 %> world"))).to eq([
-        "(lambda (epp (block",
-        "  (render-s 'We all live in ')",
-        "  (render (- 3.14 2.14))",
-        "  (render-s ' world')",
-        ")))"
-      ].join("\n"))
-    end
-  end
-end