puppet 4.0.0 → 4.5.0

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

@@ -91,12 +91,44 @@ describe 'Lexer2' do
     "true"     => :BOOLEAN,
     "in"       => :IN,
     "unless"   => :UNLESS,
+    "private"  => :PRIVATE,
+    "type"     => :TYPE,
+    "attr"     => :ATTR,
   }.each do |string, name|
     it "should lex a keyword from '#{string}'" do
       expect(tokens_scanned_from(string)).to match_tokens2(name)
     end
   end
 
+  context 'when app_management is off (by default)' do
+    {
+      "application"  => :APPLICATION_R,
+      "consumes"     => :CONSUMES_R,
+      "produces"     => :PRODUCES_R,
+      "site"         => :SITE_R,
+    }.each do |string, name|
+      it "should lex a (future reserved) keyword from '#{string}'" do
+        expect(tokens_scanned_from(string)).to match_tokens2(name)
+      end
+    end
+  end
+
+  context 'when app_managment is (turned) on' do
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
+
+    {
+      "application"  => :APPLICATION,
+      "consumes"     => :CONSUMES,
+      "produces"     => :PRODUCES,
+      "site"         => :SITE,
+    }.each do |string, name|
+      it "should lex a keyword from '#{string}'" do
+        expect(tokens_scanned_from(string)).to match_tokens2(name)
+      end
+    end
+  end
+
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do
@@ -234,6 +266,19 @@ describe 'Lexer2' do
     '"a${y::_x}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
                       [:VARIABLE, 'y::_x',  {:line => 1, :pos=>5, :length=>5 }],
                       [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
+
+    '"a${_x[1]}"' => [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:LBRACK,   '[',   {:line => 1, :pos=>7, :length=>1 }],
+                      [:NUMBER,   '1',   {:line => 1, :pos=>8, :length=>1 }],
+                      [:RBRACK,   ']',   {:line => 1, :pos=>9, :length=>1 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>11, :length=>1 }]],
+
+    '"a${_x.foo}"'=> [[:DQPRE,    'a',   {:line => 1, :pos=>1, :length=>4 }],
+                      [:VARIABLE, '_x',  {:line => 1, :pos=>5, :length=>2 }],
+                      [:DOT,      '.',   {:line => 1, :pos=>7, :length=>1 }],
+                      [:NAME,     'foo', {:line => 1, :pos=>8, :length=>3 }],
+                      [:DQPOST,   '',    {:line => 1, :pos=>12, :length=>1 }]],
   }.each do |source, expected|
     it "should lex an interpolated variable 'x' from #{source}" do
       expect(tokens_scanned_from(source)).to match_tokens2(*expected)
@@ -277,13 +322,19 @@ describe 'Lexer2' do
     end
   end
 
+  it 'detects unterminated multiline comment' do
+    expect { tokens_scanned_from("/* not terminated\nmultiline\ncomment") }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+      expect(e.issue_code).to be(Puppet::Pops::Issues::UNCLOSED_MLCOMMENT.issue_code)
+    }
+  end
+
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [: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, "- /./"],
@@ -361,6 +412,75 @@ describe 'Lexer2' do
         [:DQPOST, " After"]
         )
     end
+
+    context 'with bad syntax' do
+      def expect_issue(code, issue)
+        expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+          expect(e.issue_code).to be(issue.issue_code)
+        }
+      end
+
+      it 'detects and reports HEREDOC_UNCLOSED_PARENTHESIS' do
+        code = <<-CODE
+        @(END:syntax/t
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_UNCLOSED_PARENTHESIS)
+      end
+
+      it 'detects and reports HEREDOC_WITHOUT_END_TAGGED_LINE' do
+        code = <<-CODE
+        @(END:syntax/t)
+        Text
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_END_TAGGED_LINE)
+      end
+
+      it 'detects and reports HEREDOC_INVALID_ESCAPE' do
+        code = <<-CODE
+        @(END:syntax/x)
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_ESCAPE)
+      end
+
+      it 'detects and reports HEREDOC_INVALID_SYNTAX' do
+        code = <<-CODE
+        @(END:syntax/t/p)
+        Text
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_INVALID_SYNTAX)
+      end
+
+      it 'detects and reports HEREDOC_WITHOUT_TEXT' do
+        code = '@(END:syntax/t)'
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_WITHOUT_TEXT)
+      end
+
+      it 'detects and reports HEREDOC_MULTIPLE_AT_ESCAPES' do
+        code = <<-CODE
+        @(END:syntax/tst)
+        Tex\\tt\\n
+        |- END
+        CODE
+        expect_issue(code, Puppet::Pops::Issues::HEREDOC_MULTIPLE_AT_ESCAPES)
+      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
@@ -372,6 +492,30 @@ describe 'Lexer2' do
        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"
+      CODE
+      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 '['
@@ -448,7 +592,7 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "just text\n"]
+      [:RENDER_STRING, "      just text\n"]
       )
     end
 
@@ -464,7 +608,39 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "just text\n"]
+      [:RENDER_STRING, "      just text\n"]
+      )
+    end
+
+    it 'epp comments strips left whitespace when preceding is right trim' do
+      code = <<-CODE
+      This is <% $x=10 -%>
+      space-before-me-but-not-after   <%# This is an epp comment %>
+      just text
+      CODE
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "      space-before-me-but-not-after\n      just text\n"]
+      )
+    end
+
+    it 'epp comments strips left whitespace on same line when preceding is not right trim' do
+      code = <<-CODE
+      This is <% $x=10 %>
+      <%# This is an epp comment -%>
+      just text
+      CODE
+      expect(epp_tokens_scanned_from(code)).to match_tokens2(
+      :EPP_START,
+      [:RENDER_STRING, "      This is "],
+      [:VARIABLE, "x"],
+      :EQUALS,
+      [:NUMBER, "10"],
+      [:RENDER_STRING, "\n      just text\n"]
       )
     end
 
@@ -479,9 +655,153 @@ describe 'Lexer2' do
       [:VARIABLE, "x"],
       :EQUALS,
       [:NUMBER, "10"],
-      [:RENDER_STRING, "<% this is escaped epp %>\n"]
+      [:RENDER_STRING, "      <% this is escaped epp %>\n"]
       )
     end
+
+    context 'with bad epp syntax' do
+      def expect_issue(code, issue)
+        expect { epp_tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+          expect(e.issue_code).to be(issue.issue_code)
+        }
+      end
+
+      it 'detects and reports EPP_UNBALANCED_TAG' do
+        expect_issue('<% asf', Puppet::Pops::Issues::EPP_UNBALANCED_TAG)
+      end
+
+      it 'detects and reports EPP_UNBALANCED_COMMENT' do
+        expect_issue('<%# asf', Puppet::Pops::Issues::EPP_UNBALANCED_COMMENT)
+      end
+
+      it 'detects and reports EPP_UNBALANCED_EXPRESSION' do
+        expect_issue('asf <%', Puppet::Pops::Issues::EPP_UNBALANCED_EXPRESSION)
+      end
+    end
+  end
+
+  context 'when parsing bad code' do
+    def expect_issue(code, issue)
+      expect { tokens_scanned_from(code) }.to raise_error(Puppet::ParseErrorWithIssue) do |e|
+        expect(e.issue_code).to be(issue.issue_code)
+      end
+    end
+
+    it 'detects and reports issue ILLEGAL_CLASS_REFERENCE' do
+      expect_issue('A::3', Puppet::Pops::Issues::ILLEGAL_CLASS_REFERENCE)
+    end
+
+    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE' do
+      expect_issue('::A::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_CLASS_REFERENCE)
+    end
+
+    it 'detects and reports issue ILLEGAL_FULLY_QUALIFIED_NAME' do
+      expect_issue('::a::3', Puppet::Pops::Issues::ILLEGAL_FULLY_QUALIFIED_NAME)
+    end
+
+    it 'detects and reports issue ILLEGAL_NUMBER' do
+     expect_issue('3g', Puppet::Pops::Issues::ILLEGAL_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_HEX_NUMBER' do
+      expect_issue('0x3g', Puppet::Pops::Issues::INVALID_HEX_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_OCTAL_NUMBER' do
+      expect_issue('038', Puppet::Pops::Issues::INVALID_OCTAL_NUMBER)
+    end
+
+    it 'detects and reports issue INVALID_DECIMAL_NUMBER' do
+      expect_issue('4.3g', Puppet::Pops::Issues::INVALID_DECIMAL_NUMBER)
+    end
+
+    it 'detects and reports issue NO_INPUT_TO_LEXER' do
+      expect { Puppet::Pops::Parser::Lexer2.new.fullscan }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+        expect(e.issue_code).to be(Puppet::Pops::Issues::NO_INPUT_TO_LEXER.issue_code)
+      }
+    end
+
+    it 'detects and reports issue UNCLOSED_QUOTE' 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

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

@@ -0,0 +1,35 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe "egrammar parsing of 'application'" do
+  include ParserRspecHelper
+
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
+
+  it "an empty body" do
+    expect(dump(parse("application foo { }"))).to eq("(application foo () ())")
+  end
+
+  it "an empty body" do
+    prog = <<-EPROG
+application foo {
+  db { one:
+    password => 'secret'
+  }
+}
+EPROG
+    expect(dump(parse(prog))).to eq( [
+"(application foo () (block",
+"  (resource db",
+"    (one",
+"      (password => 'secret')))", "))" ].join("\n"))
+  end
+
+  it "accepts parameters" do
+    s = "application foo($p1 = 'yo', $p2) { }"
+    expect(dump(parse(s))).to eq("(application foo ((= p1 'yo') p2) ())")
+  end
+end

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

@@ -168,6 +168,25 @@ describe "egrammar parsing basic expressions" do
       expect(parse("[]").current.body.length).to eq(2)
       expect(parse("[ ]").current.body.length).to eq(3)
     end
+
+    {
+      'keyword' => %w(type function),
+      'reserved word' => %w(application site produces consumes)
+    }.each_pair do |word_type, words|
+      words.each do |word|
+        it "allows the #{word_type} '#{word}' in a list" do
+          expect(dump(parse("$a = [#{word}]"))).to(eq("(= $a ([] '#{word}'))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a key in a hash" do
+          expect(dump(parse("$a = {#{word}=>'x'}"))).to(eq("(= $a ({} ('#{word}' 'x')))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a value in a hash" do
+          expect(dump(parse("$a = {'x'=>#{word}}"))).to(eq("(= $a ({} ('x' '#{word}')))"))
+        end
+      end
+    end
   end
 
   context "When parsing indexed access" do
@@ -175,6 +194,10 @@ describe "egrammar parsing basic expressions" do
       expect(dump(parse("$a = $b[2]"))).to eq("(= $a (slice $b 2))")
     end
 
+    it "$a = $b[2,]" do
+      expect(dump(parse("$a = $b[2,]"))).to eq("(= $a (slice $b 2))")
+    end
+
     it "$a = [1, 2, 3][2]" do
       expect(dump(parse("$a = [1,2,3][2]"))).to eq("(= $a (slice ([] 1 2 3) 2))")
     end

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

@@ -26,6 +26,10 @@ describe "egrammar parsing function calls" do
         expect(dump(parse("foo(bar)"))).to eq("(invoke foo bar)")
       end
 
+      it "notice {a=>2}" do
+        expect(dump(parse("notice {a => 2}"))).to eq("(invoke notice ({} ('a' 2)))")
+      end
+
       it "foo(bar,)" do
         expect(dump(parse("foo(bar,)"))).to eq("(invoke foo bar)")
       end
@@ -37,6 +41,10 @@ describe "egrammar parsing function calls" do
       it "notice fqdn_rand(30)" do
         expect(dump(parse("notice fqdn_rand(30)"))).to eq('(invoke notice (call fqdn_rand 30))')
       end
+
+      it "notice type(42)" do
+        expect(dump(parse("notice type(42)"))).to eq('(invoke notice (call type 42))')
+      end
     end
 
     context "in nested scopes" do

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

@@ -0,0 +1,40 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe "egrammar parsing of capability mappings" do
+  include ParserRspecHelper
+
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
+
+  context "when parsing 'produces'" do
+    it "the ast contains produces and attributes" do
+      prog = "Foo produces Sql { name => value }"
+      ast = "(produces Foo Sql ((name => value)))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "optional end comma is allowed" do
+      prog = "Foo produces Sql { name => value, }"
+      ast = "(produces Foo Sql ((name => value)))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+  end
+
+  context "when parsing 'consumes'" do
+    it "the ast contains consumes and attributes" do
+      prog = "Foo consumes Sql { name => value }"
+      ast = "(consumes Foo Sql ((name => value)))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "optional end comma is allowed" do
+      prog = "Foo consumes Sql { name => value, }"
+      ast = "(consumes Foo Sql ((name => value)))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+  end
+end

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

@@ -71,6 +71,32 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it "parses interpolated heredoc expression containing escapes" do
+    src = <<-CODE
+    @("END")
+    Hello \\$name
+    |- END
+    CODE
+    expect(dump(parse(src))).to eq([
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n"))
+  end
+
+  it "parses interpolated heredoc expression containing escapes when escaping other things than $" do
+    src = <<-CODE
+    @("END"/t)
+    Hello \\$name
+    |- END
+    CODE
+    expect(dump(parse(src))).to eq([
+      "(@()",
+      "  (sublocated (cat 'Hello \\' (str $name) ''))",
+      ")"
+    ].join("\n"))
+  end
+
   it "parses with escaped newlines without preceding whitespace" do
     src = <<-CODE
     @(END/L)

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

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe "egrammar parsing of site expression" do
+  include ParserRspecHelper
+
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
+
+  context "when parsing 'site'" do
+    it "an empty body is allowed" do
+      prog = "site { }"
+      ast = "(site ())"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "a body with one expression is allowed" do
+      prog = "site { $x = 1 }"
+      ast = "(site (block\n  (= $x 1)\n))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+
+    it "a body with more than one expression is allowed" do
+      prog = "site { $x = 1 $y = 2}"
+      ast = "(site (block\n  (= $x 1)\n  (= $y 2)\n))"
+      expect(dump(parse(prog))).to eq(ast)
+    end
+  end
+
+  context 'When parsing collections containing application management specific keywords' do
+    %w(application site produces consumes).each do |keyword|
+      it "allows the keyword '#{keyword}' in a list" do
+        expect(dump(parse("$a = [#{keyword}]"))).to(eq("(= $a ([] '#{keyword}'))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a key in a hash" do
+        expect(dump(parse("$a = {#{keyword}=>'x'}"))).to(eq("(= $a ({} ('#{keyword}' 'x')))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a value in a hash" do
+        expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
+      end
+    end
+  end
+end

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

@@ -4,8 +4,14 @@ require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
 
 module ParserRspecHelper
   include FactoryRspecHelper
+
   def parse(code)
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)
   end
+
+  def parse_epp(code)
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.parse_string(code)
+  end
 end

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

@@ -31,6 +31,16 @@ describe Puppet::Pops::Parser::Parser do
     expect(adapter.length).to eq(0)
   end
 
+  it "multi byte characters in a comment are counted as individual bytes" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("# \u{0400}comment\n").current
+    expect(model.class).to eq(Puppet::Pops::Model::Program)
+    expect(model.body.class).to eq(Puppet::Pops::Model::Nop)
+    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
+    expect(adapter.offset).to eq(12)
+    expect(adapter.length).to eq(0)
+  end
+
   it "should raise an error with position information when error is raised from within parser" do
     parser = Puppet::Pops::Parser::Parser.new()
     the_error = nil
@@ -44,4 +54,22 @@ describe Puppet::Pops::Parser::Parser do
     expect(the_error.line).to eq(1)
     expect(the_error.pos).to eq(6)
   end
+
+  it "should raise an error with position information when error is raised on token" do
+    parser = Puppet::Pops::Parser::Parser.new()
+    the_error = nil
+    begin
+      parser.parse_string(<<-EOF, 'fakefile.pp')
+class whoops($a,$b,$c) {
+  $d = "oh noes",  "b"
+}
+      EOF
+    rescue Puppet::ParseError => e
+      the_error = e
+    end
+    expect(the_error).to be_a(Puppet::ParseError)
+    expect(the_error.file).to eq('fakefile.pp')
+    expect(the_error.line).to eq(2)
+    expect(the_error.pos).to eq(17)
+  end
 end