puppet 5.4.0 → 5.5.0

data/spec/unit/pops/evaluator/runtime3_converter_spec.rb

@@ -31,22 +31,18 @@ describe 'when converting to 3.x' do
   end
 
   it 'converts the symbol :undef to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
   end
 
   it 'converts the nil to the undef value' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
   end
 
   it 'does not convert a symbol nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
   end
 
   it 'converts nil to :undef when nested in an array' do
-    v = SemanticPuppet::Version.parse('1.0.0')
     expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
   end
 

data/spec/unit/pops/factory_rspec_helper.rb

@@ -59,7 +59,7 @@ module FactoryRspecHelper
   end
 
   def unindent x
-    (x.gsub /^#{x[/\A\s*/]}/, '').chomp
+    x.gsub(/^#{x[/\A\s*/]}/, '').chomp
   end
   factory ||= Puppet::Pops::Model::Factory
 end

data/spec/unit/pops/factory_spec.rb

@@ -191,7 +191,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle 'just a string'" do
       model = string('blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
     end
@@ -199,7 +199,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression in the middle" do
       model = string('blah blah', TEXT(literal(1)+literal(2)), 'blah blah').model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 3
+      expect(model.segments.size).to eq(3)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -211,7 +211,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle one expression at the end" do
       model = string('blah blah', TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::LiteralString)
       expect(model.segments[0].value).to eq("blah blah")
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)
@@ -221,7 +221,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle only one expression" do
       model = string(TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 1
+      expect(model.segments.size).to eq(1)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
     end
@@ -229,7 +229,7 @@ describe Puppet::Pops::Model::Factory do
     it "should handle several expressions" do
       model = string(TEXT(literal(1)+literal(2)), TEXT(literal(1)+literal(2))).model
       expect(model.class).to eq(Puppet::Pops::Model::ConcatenatedString)
-      model.segments.size == 2
+      expect(model.segments.size).to eq(2)
       expect(model.segments[0].class).to eq(Puppet::Pops::Model::TextExpression)
       expect(model.segments[0].expr.class).to eq(Puppet::Pops::Model::ArithmeticExpression)
       expect(model.segments[1].class).to eq(Puppet::Pops::Model::TextExpression)

data/spec/unit/pops/issues_spec.rb

@@ -34,24 +34,25 @@ describe "Puppet::Pops::IssueReporter" do
     stub("positioned_#{number}", :line => number, :pos => number)
   end
 
-  def diagnostic(severity,  number)
+  def diagnostic(severity,  number, args)
     Puppet::Pops::Validation::Diagnostic.new(
       severity,
       Puppet::Pops::Issues::Issue.new(number) { "#{severity}#{number}" },
       "#{severity}file",
-      fake_positioned(number))
+      fake_positioned(number),
+      args)
   end
 
-  def warning(number)
-    diagnostic(:warning, number)
+  def warning(number, args = {})
+    diagnostic(:warning, number, args)
   end
 
-  def deprecation(number)
-    diagnostic(:deprecation, number)
+  def deprecation(number, args = {})
+    diagnostic(:deprecation, number, args)
   end
 
-  def error(number)
-    diagnostic(:error, number)
+  def error(number, args = {})
+    diagnostic(:error, number, args)
   end
 
   context "given warnings" do
@@ -98,6 +99,13 @@ describe "Puppet::Pops::IssueReporter" do
       Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
+
+    it "includes diagnostic arguments in logged entry" do
+      acceptor.accept( warning(2, :n => 'a') )
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning2/), :arguments => {:n => 'a'}))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
   end
 
   context "given errors" do
@@ -175,6 +183,13 @@ describe "Puppet::Pops::IssueReporter" do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
     end
+
+    it "includes diagnostic arguments in raised error" do
+      acceptor.accept( error(1, :n => 'a') )
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseErrorWithIssue, /error1/) { |ex| expect(ex.arguments).to eq(:n => 'a')}
+    end
   end
 
   context "given both" do

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -194,7 +194,7 @@ describe 'loaders' do
 
     def compile_and_get_notifications(code)
       Puppet[:code] = code
-      catalog = block_given? ? compiler.compile { |catalog| yield(compiler.topscope); catalog } : compiler.compile
+      catalog = block_given? ? compiler.compile { |c| yield(compiler.topscope); c } : compiler.compile
       catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
     end
 
@@ -271,7 +271,7 @@ describe 'loaders' do
           File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
-          expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
+          expect { compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
         end
       end
     end
@@ -534,6 +534,20 @@ describe 'loaders' do
               },
               'metadata.json' => sprintf(metadata_json, 'c', '')
             },
+            'd' => {
+              'types' => {
+                'init_typeset.pp' => <<-PUPPET.unindent,
+                  type D = TypeSet[{
+                    pcore_version => '1.0.0',
+                    types => {
+                      P => Object[{}],
+                      O => Object[{ parent => P }]
+                    }
+                  }]
+                  PUPPET
+              },
+              'metadata.json' => sprintf(metadata_json, 'd', '')
+            }
           }
         }
       end
@@ -624,6 +638,14 @@ describe 'loaders' do
         expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
         expect(type.resolved_type).to be_a(Puppet::Pops::Types::PFloatType)
       end
+
+      it 'loads an object type from a typeset that references another type defined in the same typeset' do
+        l = Puppet::Pops::Loaders.find_loader('d').private_loader
+        p = Puppet::Pops::Types::TypeParser.singleton
+        type = p.parse('D::O', l)
+        expect(type).to be_a(Puppet::Pops::Types::PObjectType)
+        expect(type.resolved_parent).to be_a(Puppet::Pops::Types::PObjectType)
+      end
     end
   end
 

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -91,7 +91,7 @@ describe 'the static loader' do
   end
 
   context 'without init_runtime3 initialization' do
-    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
+    let(:loader) { Puppet::Pops::Loader::StaticLoader.new() }
 
     it 'does not provide access to resource types built into puppet' do
       expect(loader.load(:type, 'file')).to be_nil

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

@@ -25,6 +25,11 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
       found = sub_lookup(name, lookup_invocation, segments, found) unless segments.empty?
       @interpolator.interpolate(found, lookup_invocation, true)
     end
+
+    # ignore requests for lookup options when testing interpolation
+    def lookup_lookup_options(_, _)
+      nil
+    end
   end
 
   let(:interpolator) { Class.new { include Lookup::Interpolation }.new }

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

@@ -119,6 +119,62 @@ describe 'The lookup API' do
     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)')

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

@@ -0,0 +1,53 @@
+#! /usr/bin/env ruby
+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
+  end
+
+  def lit(value)
+    value.is_a?(PN) ? value : PN::Literal.new(value)
+  end
+end
+end
+end
+

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

@@ -7,13 +7,13 @@ module EgrammarLexer2Spec
   def tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
-    tokens = lexer.fullscan[0..-2]
+    lexer.fullscan[0..-2]
   end
 
   def epp_tokens_scanned_from(s)
     lexer = Puppet::Pops::Parser::Lexer2.new
     lexer.string = s
-    tokens = lexer.fullscan_epp[0..-2]
+    lexer.fullscan_epp[0..-2]
   end
 end
 
@@ -540,6 +540,15 @@ describe 'Lexer2' do
         expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_TEXT)
       end
 
+      it 'detects and reports HEREDOC_EMPTY_ENDTAG' do
+        code = <<-CODE
+        @("")
+        Text
+        |-END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_EMPTY_ENDTAG)
+      end
+
       it 'detects and reports HEREDOC_MULTIPLE_AT_ESCAPES' do
         code = <<-CODE
         @(END:syntax/tst)
@@ -867,8 +876,8 @@ describe Puppet::Pops::Parser::Lexer2 do
   # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
   # Runes (may show up as garbage if font is not available): ᚠᛇᚻ᛫ᛒᛦᚦ᛫ᚠᚱᚩᚠᚢᚱ᛫ᚠᛁᚱᚪ᛫ᚷᛖᚻᚹᛦᛚᚳᚢᛗ
   let (:rune_utf8) {
-    "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2"
-    "\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA"
+    "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2" +
+    "\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA" +
     "\u16B3\u16A2\u16D7"
   }
 
@@ -893,7 +902,7 @@ describe Puppet::Pops::Parser::Lexer2 do
         manifest = file_containing('manifest.pp', manifest_code)
 
         expect {
-          lexed_file = described_class.new.lex_file(manifest)
+          described_class.new.lex_file(manifest)
         }.to raise_error(Puppet::ParseErrorWithIssue,
           'Illegal UTF-8 Byte Order mark at beginning of input: [EF BB BF] - remove these from the puppet source')
     end

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

@@ -234,7 +234,7 @@ describe "egrammar parsing basic expressions" do
 
   context 'When parsing type aliases' do
     it 'type A = B' do
-      expect(dump(parse('type A = B'))).to eq('(type-alias A b)')
+      expect(dump(parse('type A = B'))).to eq('(type-alias A B)')
     end
 
     it 'type A = B[]' do
@@ -246,19 +246,19 @@ describe "egrammar parsing basic expressions" do
     end
 
     it 'type A = B[C]' do
-      expect(dump(parse('type A = B[C]'))).to eq('(type-alias A (slice b c))')
+      expect(dump(parse('type A = B[C]'))).to eq('(type-alias A (slice B C))')
     end
 
     it 'type A = B[C,]' do
-      expect(dump(parse('type A = B[C,]'))).to eq('(type-alias A (slice b c))')
+      expect(dump(parse('type A = B[C,]'))).to eq('(type-alias A (slice B C))')
     end
 
     it 'type A = B[C,D]' do
-      expect(dump(parse('type A = B[C,D]'))).to eq('(type-alias A (slice b (c d)))')
+      expect(dump(parse('type A = B[C,D]'))).to eq('(type-alias A (slice B (C D)))')
     end
 
     it 'type A = B[C,D,]' do
-      expect(dump(parse('type A = B[C,D,]'))).to eq('(type-alias A (slice b (c d)))')
+      expect(dump(parse('type A = B[C,D,]'))).to eq('(type-alias A (slice B (C D)))')
     end
   end
 
@@ -339,11 +339,11 @@ describe "egrammar parsing basic expressions" do
 
   context "When parsing string interpolation" do
     it "should interpolate a bare word as a variable name, \"${var}\"" do
-      expect(dump(parse("$a = \"$var\""))).to eq("(= $a (cat '' (str $var) ''))")
+      expect(dump(parse("$a = \"$var\""))).to eq("(= $a (cat (str $var)))")
     end
 
     it "should interpolate a variable in a text expression, \"${$var}\"" do
-      expect(dump(parse("$a = \"${$var}\""))).to eq("(= $a (cat '' (str $var) ''))")
+      expect(dump(parse("$a = \"${$var}\""))).to eq("(= $a (cat (str $var)))")
     end
 
     it "should interpolate a variable, \"yo${var}yo\"" do
@@ -372,11 +372,11 @@ describe "egrammar parsing basic expressions" do
     end
 
     it "should interpolate interpolated expressions with a variable, \"yo${\"$var\"}yo\"" do
-      expect(dump(parse("$a = \"yo${\"$var\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat '' (str $var) '')) 'yo'))")
+      expect(dump(parse("$a = \"yo${\"$var\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat (str $var))) 'yo'))")
     end
 
     it "should interpolate interpolated expressions with an expression, \"yo${\"${$var+2}\"}yo\"" do
-      expect(dump(parse("$a = \"yo${\"${$var+2}\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat '' (str (+ $var 2)) '')) 'yo'))")
+      expect(dump(parse("$a = \"yo${\"${$var+2}\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat (str (+ $var 2)))) 'yo'))")
     end
   end
 end

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

@@ -138,7 +138,7 @@ describe "egrammar parsing function calls" do
     end
 
     it 'notice Hash.assert_type(a => 42)' do
-      expect(dump(parse('notice Hash.assert_type(a => 42)'))).to eq('(invoke notice (call-method (. hash assert_type) ({} (a 42))))')
+      expect(dump(parse('notice Hash.assert_type(a => 42)'))).to eq('(invoke notice (call-method (. Hash assert_type) ({} (a 42))))')
     end
 
     it "notice 42.type(detailed)" do