puppet 4.3.2 → 4.4.0

data/spec/unit/parser/scope_spec.rb

@@ -158,7 +158,7 @@ describe Puppet::Parser::Scope do
       expect { @scope[:foo] = 12 }.to raise_error(Puppet::ParseError, /Scope variable name .* not a string/)
     end
 
-    it "should return nil for unset variables" do
+    it "should return nil for unset variables when --strict variables is not in effect" do
       expect(@scope["var"]).to be_nil
     end
 
@@ -208,6 +208,26 @@ describe Puppet::Parser::Scope do
       expect(@scope).not_to be_include("var")
     end
 
+    it "warns and return nil for non found unqualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["santa_clause"]).to be_nil
+    end
+
+    it "warns once for a non found variable" do
+      Puppet.expects(:warning).once
+      expect([@scope["santa_claus"],@scope["santa_claus"]]).to eq([nil, nil])
+    end
+
+    it "warns and return nil for non found qualified variable" do
+      Puppet.expects(:warn_once)
+      expect(@scope["north_pole::santa_clause"]).to be_nil
+    end
+
+    it "does not warn when a numeric variable is missing - they always exist" do
+      Puppet.expects(:warn_once).never
+      expect(@scope["1"]).to be_nil
+    end
+
     describe "and the variable is qualified" do
       before :each do
         @known_resource_types = @scope.known_resource_types
@@ -266,17 +286,16 @@ describe Puppet::Parser::Scope do
 
       it "should warn and return nil for qualified variables whose classes have not been evaluated" do
         klass = newclass("other::deep::klass")
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should warn and return nil for qualified variables whose classes do not exist" do
-        @scope.expects(:warning)
+        Puppet.expects(:warn_once)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
       it "should return nil when asked for a non-string qualified variable from a class that does not exist" do
-        @scope.stubs(:warning)
         expect(@scope["other::deep::klass::var"]).to be_nil
       end
 
@@ -489,17 +508,15 @@ describe Puppet::Parser::Scope do
         expect(@scope.include?("1")).to be_falsey
       end
 
-      describe "when calling unset_ephemeral_var with a level" do
+      describe "when using a guarded scope" do
         it "should remove ephemeral scopes up to this level" do
           @scope.set_match_data({1 => :value1})
           @scope.new_ephemeral
           @scope.set_match_data({1 => :value2})
-          level = @scope.ephemeral_level()
-          @scope.new_ephemeral
-          @scope.set_match_data({1 => :value3})
-
-          @scope.unset_ephemeral_var(level)
-
+          @scope.with_guarded_scope do
+            @scope.new_ephemeral
+            @scope.set_match_data({1 => :value3})
+          end
           expect(@scope["1"]).to eq(:value2)
         end
       end

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

@@ -120,7 +120,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces an Integer[1]' do
       expr = fqr('Integer')[1]
-      expect(evaluate(expr)).to eql(range(1,1))
+      expect(evaluate(expr)).to eql(range(1,:default))
     end
 
     it 'gives an error for Integer[from, <from]' do
@@ -146,12 +146,12 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     it 'produces a Float[1.0]' do
       expr = fqr('Float')[1.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'produces a Float[1]' do
       expr = fqr('Float')[1]
-      expect(evaluate(expr)).to eql(float_range(1.0,1.0))
+      expect(evaluate(expr)).to eql(float_range(1.0,:default))
     end
 
     it 'gives an error for Float[from, <from]' do

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

@@ -86,6 +86,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       it "'1.0' < 1.1 == true" do
         expect{evaluate(literal('1.0') <  literal(1.1))}.to raise_error(/String < Float/)
       end
+      it "undef < 1.1 == true" do
+        expect{evaluate(literal(nil) <  literal(1.1))}.to raise_error(/Undef Value < Float/)
+      end
     end
 
     context "of regular expressions" do

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

@@ -598,6 +598,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(result).to include(['b', 20])
     end
 
+    it "should create an array from an Iterator" do
+      expect(parser.evaluate_string(scope, '[1,2,3].reverse_each', __FILE__).is_a?(Array)).to be(false)
+      result = parser.evaluate_string(scope, '*[1,2,3].reverse_each', __FILE__)
+      expect(result).to eql([3,2,1])
+    end
   end
 
   context "When evaluator performs [] operations" do
@@ -861,7 +866,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         # NOTE: these meta-esque parameters are not recognized as such
         "notify { id: message=>explicit} Notify[id][title]"   => /does not have a parameter called 'title'/,
         "notify { id: message=>explicit} Notify[id]['type']"   => /does not have a parameter called 'type'/,
-        "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/
+        "notify { id: message=>explicit } Notify[id]{message=>override}" => /'message' is already set on Notify\[id\]/,
+        "notify { id: message => 'once', message => 'twice' }" => /'message' has already been set/
       }.each do |source, result|
         it "should parse '#{source}' and raise error matching #{result}" do
           expect { parser.evaluate_string(scope, source, __FILE__)}.to raise_error(result)

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

@@ -55,10 +55,10 @@ module EvaluatorRspecHelper
     result = evaluator.evaluate(in_top_scope.current, top_scope)
     if in_local_scope
       # This is really bad in 3.x scope
-      elevel = top_scope.ephemeral_level
-      top_scope.new_ephemeral(true)
-      result = evaluator.evaluate(in_local_scope.current, top_scope)
-      top_scope.unset_ephemeral_var(elevel)
+      top_scope.with_guarded_scope do
+        top_scope.new_ephemeral(true)
+        result = evaluator.evaluate(in_local_scope.current, top_scope)
+      end
     end
     if in_top_scope_again
       result = evaluator.evaluate(in_top_scope_again.current, top_scope)

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/json_strict_literal_evaluator'
+
+describe "Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator" do
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+  let(:leval)  {  Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new }
+
+  { "1"       => 1,
+    "3.14"    => 3.14,
+    "true"    => true,
+    "false"   => false,
+    "'1'"     => '1',
+    "'a'"     => 'a',
+    '"a"'     => 'a',
+    'a'       => 'a',
+    'a::b'    => 'a::b',
+    'undef'   => nil,
+
+    # collections
+    '[1,2,3]'     => [1,2,3],
+    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
+    '[undef]'     => [nil],
+    '{a=>undef}'  => { 'a' => nil }
+
+  }.each do |source, result|
+    it "evaluates '#{source}' to #{result}" do
+      expect(leval.literal(parser.parse_string(source))).to eq(result)
+    end
+  end
+
+  [ '1+1', 
+    'File',
+    '[1,2, 1+2]',
+    '{a=>1+1}', 
+    'Integer[1]', 
+    '"x$y"', 
+    '"x${y}z"'
+  ].each do |source|
+    it "throws :not_literal for non literal expression '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+
+  [ 'default', 
+    '/.*/', 
+    '{1=>100}', 
+    '{undef => 10}',
+    '{default => 10}',
+    '{/.*/ => 10}',
+    '{"ok" => {1 => 100}}',
+    '[default]',
+    '[[default]]',
+    '[/.*/]',
+    '[[/.*/]]',
+    '[{1 => 100}]',
+  ].each do |source|
+    it "throws :not_literal for values not representable as pure JSON '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+end

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

@@ -16,4 +16,10 @@ describe 'when converting to 3.x' do
     converted = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
     expect(converted).to eql(['class', 'kermit'])
   end
+
+  it "errors on attempts to convert an 'Iterator'" do
+    expect {
+      Puppet::Pops::Evaluator::Runtime3Converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
+    }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
+  end
 end

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

@@ -53,6 +53,59 @@ describe 'dependency loader' do
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
+
+    describe "when parsing files from disk" do
+
+      # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+      # characters chosen since they will not parse on Windows with codepage 437 or 1252
+      # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+      let (:node) { Puppet::Node.new('node') }
+      let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # ᚠᛇᚻ
+      let (:code_utf8) do <<-CODE
+Puppet::Functions.create_function('testmodule::foo') {
+  def foo
+    return \"#{rune_utf8}\"
+  end
+}
+      CODE
+      end
+
+      context 'when loading files from disk' do
+        it 'should always read files as UTF-8' do
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => code_utf8
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+
+        it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
+          bom = "\uFEFF"
+
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => "#{bom}#{code_utf8}"
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+      end
+    end
   end
 
   def loader_for(name, dir)

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

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/compiler'
 
 require 'puppet/pops'
 require 'puppet/loaders'
@@ -25,6 +26,7 @@ end
 
 describe 'loaders' do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
   let(:module_without_lib) { File.join(config_dir('module_no_lib'), 'modules') }
@@ -205,8 +207,49 @@ describe 'loaders' do
         end
       end
     end
-  end
 
+    it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference an autoloaded type alias from another module when no metadata is present" do
+      Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference a type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(Usee::One, 1)
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(User::WithUseeZero, [0])
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(User::WithUseeOne, [1])
+        notice(ok)
+      CODE
+    end
+  end
 
   context 'when loading from a module without metadata' do
     it 'loads a ruby function with a qualified name' do

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

@@ -339,9 +339,9 @@ describe 'Lexer2' do
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
     "("  => [:LPAREN, "( /./"],
-    "["  => [:LISTSTART, "[ /./"],
-    "["  => [[:NAME, :LBRACK], "a[ /./"],
-    "["  => [[:NAME, :LISTSTART], "a [ /./"],
+    "[ (liststart)"             => [:LISTSTART, "[ /./"],
+    "[ (LBRACK)"                => [[:NAME, :LBRACK], "a[ /./"],
+    "[ (liststart after name)"  => [[:NAME, :LISTSTART], "a [ /./"],
     "{"  => [:LBRACE, "{ /./"],
     "+"  => [:PLUS, "+ /./"],
     "-"  => [:MINUS, "- /./"],
@@ -477,6 +477,18 @@ describe 'Lexer2' do
       end
     end
   end
+  context 'when not given multi byte characters' do
+    it 'produces byte offsets for tokens' do
+      code = <<-"CODE"
+1 2\n3
+      CODE
+      expect(tokens_scanned_from(code)).to match_tokens2(
+        [:NUMBER, '1', {:line => 1, :offset => 0, :length=>1}],
+        [:NUMBER, '2', {:line => 1, :offset => 2, :length=>1}],
+        [:NUMBER, '3', {:line => 2, :offset => 4, :length=>1}]
+      )
+    end
+  end
 
   context 'when dealing with multi byte characters' do
     it 'should support unicode characters' do
@@ -486,6 +498,7 @@ describe 'Lexer2' do
       # >= Ruby 1.9.3 reports \u
        expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u2713y"])
     end
+
     it 'should support unicode characters in long form' do
       code = <<-CODE
       "x\\u{1f452}y"
@@ -493,6 +506,23 @@ describe 'Lexer2' do
       expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u{1f452}y"])
     end
 
+    it 'produces byte offsets that counts each byte in a comment' do
+      code = <<-"CODE"
+      # \u{0400}\na
+      CODE
+      expect(tokens_scanned_from(code.strip)).to match_tokens2([:NAME, 'a', {:line => 2, :offset => 5, :length=>1}])
+    end
+
+    it 'produces byte offsets that counts each byte in value token' do
+      code = <<-"CODE"
+      '\u{0400}'\na
+      CODE
+      expect(tokens_scanned_from(code.strip)).to match_tokens2(
+        [:STRING, "\u{400}", {:line => 1, :offset => 0, :length=>4}],
+        [:NAME, 'a', {:line => 2, :offset => 5, :length=>1}]
+      )
+    end
+
     it 'should not select LISTSTART token when preceded by multibyte chars' do
       # This test is sensitive to the number of multibyte characters and position of the expressions
       # within the string - it is designed to fail if the position is calculated on the byte offset of the '['
@@ -702,4 +732,83 @@ describe 'Lexer2' do
       expect_issue('"asd', Puppet::Pops::Issues::UNCLOSED_QUOTE)
     end
   end
+
+  context 'when dealing with non UTF-8 and Byte Order Marks (BOMs)' do
+      {
+      'UTF_8'      => [0xEF, 0xBB, 0xBF],
+      'UTF_16_1'   => [0xFE, 0xFF],
+      'UTF_16_2'   => [0xFF, 0xFE],
+      'UTF_32_1'   => [0x00, 0x00, 0xFE, 0xFF],
+      'UTF_32_2'   => [0xFF, 0xFE, 0x00, 0x00],
+      'UTF_1'      => [0xF7, 0x64, 0x4C],
+      'UTF_EBCDIC' => [0xDD, 0x73, 0x66, 0x73],
+      'SCSU'       => [0x0E, 0xFE, 0xFF],
+      'BOCU'       => [0xFB, 0xEE, 0x28],
+      'GB_18030'   => [0x84, 0x31, 0x95, 0x33]
+      }.each do |key, bytes|
+        it "errors on the byte order mark for #{key} '[#{bytes.map() {|b| '%X' % b}.join(' ')}]'" do
+          format_name = key.split('_')[0,2].join('-')
+          bytes_str = "\\[#{bytes.map {|b| '%X' % b}.join(' ')}\\]"
+          fix =  " - remove these from the puppet source"
+          expect {
+            tokens_scanned_from(bytes.pack('C*'))
+          }.to raise_error(Puppet::ParseErrorWithIssue,
+            /Illegal #{format_name} .* at beginning of input: #{bytes_str}#{fix}/)
+        end
+
+       it "can use a possibly 'broken' UTF-16 string without problems for #{key}" do
+         format_name = key.split('_')[0,2].join('-')
+         string = bytes.pack('C*').force_encoding('UTF-16')
+         bytes_str = "\\[#{string.bytes.map {|b| '%X' % b}.join(' ')}\\]"
+         fix =  " - remove these from the puppet source"
+         expect {
+           tokens_scanned_from(string)
+         }.to raise_error(Puppet::ParseErrorWithIssue,
+           /Illegal #{format_name} .* at beginning of input: #{bytes_str}#{fix}/)
+       end
+    end
+  end
+end
+
+describe Puppet::Pops::Parser::Lexer2 do
+
+  include PuppetSpec::Files
+
+  # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+  # characters chosen since they will not parse on Windows with codepage 437 or 1252
+  # 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"
+    "\u16B3\u16A2\u16D7"
+  }
+
+  context 'when lexing files from disk' do
+    it 'should always read files as UTF-8' do
+      if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+        raise 'This test must be run in a codepage other than 65001 to validate behavior'
+      end
+
+      manifest_code = "notify { '#{rune_utf8}': }"
+      manifest = file_containing('manifest.pp', manifest_code)
+      lexed_file = described_class.new.lex_file(manifest)
+
+      expect(lexed_file.string.encoding).to eq(Encoding::UTF_8)
+      expect(lexed_file.string).to eq(manifest_code)
+    end
+
+    it 'currently errors when the UTF-8 BOM (Byte Order Mark) is present when lexing files' do
+      bom = "\uFEFF"
+
+        manifest_code = "#{bom}notify { '#{rune_utf8}': }"
+        manifest = file_containing('manifest.pp', manifest_code)
+
+        expect {
+          lexed_file = 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
+  end
+
 end