puppet 4.0.0 → 4.1.0

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

@@ -46,7 +46,7 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
       end
 
       it "can not change a variable value in same scope" do
-        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable a/)
+        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable '\$a'/)
       end
 
       context "access to numeric variables" do

data/spec/unit/pops/issues_spec.rb

@@ -62,19 +62,19 @@ describe "Puppet::Pops::IssueReporter" do
     end
 
     it "emits warnings if told to emit them" do
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit warnings if not told to emit them" do
-      Puppet.expects(:warning).never
+      Puppet::Log.expects(:create).never
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, {})
     end
 
     it "emits no warnings if :max_warnings is 0" do
       acceptor.accept( warning(2) )
       Puppet[:max_warnings] = 0
-      Puppet.expects(:warning).once.with(regexp_matches(/deprecation1/))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
@@ -82,20 +82,20 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( warning(2) )
       acceptor.accept( warning(3) )
       Puppet[:max_warnings] = 1
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit more deprecations warnings than the max deprecation warnings" do
       acceptor.accept( deprecation(2) )
       Puppet[:max_deprecations] = 0
-      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      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 "does not emit deprecation warnings, but does emit regular warnings if disable_warnings includes deprecations" do
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      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
   end
@@ -103,7 +103,7 @@ describe "Puppet::Pops::IssueReporter" do
   context "given errors" do
     it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
       end.to raise_error(Puppet::ParseError, 'special')
@@ -111,7 +111,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "prefixes :message if a single error is raised" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /special error1/)
@@ -119,7 +119,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "logs nothing and raises immediately if there is only one error" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -129,7 +129,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:max_errors] = 0
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -138,7 +138,7 @@ describe "Puppet::Pops::IssueReporter" do
     it "logs the :message if there is more than one allowed error" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
-      Puppet.expects(:err).times(3).with(regexp_matches(/error1|error2|special/))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2|special/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -149,7 +149,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 2
-      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -160,7 +160,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 4
-      Puppet.expects(:err).times(3).with(regexp_matches(/error[123]/))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -170,7 +170,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -186,8 +186,8 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(3) )
       acceptor.accept( deprecation(1) )
       Puppet[:max_errors] = 2
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
-      Puppet.expects(:err).times(2).with(regexp_matches(/error[123]/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
       end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)

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

@@ -27,6 +27,7 @@ describe 'loaders' do
   include PuppetSpec::Files
 
   let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
+  let(:module_without_lib) { File.join(config_dir('module_no_lib'), 'modules') }
   let(:mix_4x_and_3x_functions) { config_dir('mix_4x_and_3x_functions') }
   let(:module_with_metadata) { File.join(config_dir('single_module'), 'modules') }
   let(:dependent_modules_with_metadata) { config_dir('dependent_modules_with_metadata') }
@@ -49,70 +50,138 @@ describe 'loaders' do
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
   end
 
-  it 'can load a function using a qualified or unqualified name from a module with metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
-    modulea_loader = loaders.public_loader_for_module('modulea')
+  context 'when loading from a module' do
+    it 'loads a ruby function using a qualified or unqualified name' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    unqualified_function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
-    qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
+      unqualified_function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
 
-    expect(unqualified_function).to be_a(Puppet::Functions::Function)
-    expect(qualified_function).to be_a(Puppet::Functions::Function)
-    expect(unqualified_function.class.name).to eq('rb_func_a')
-    expect(qualified_function.class.name).to eq('modulea::rb_func_a')
-  end
+      expect(unqualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(unqualified_function.class.name).to eq('rb_func_a')
+      expect(qualified_function.class.name).to eq('modulea::rb_func_a')
+    end
 
-  it 'can load a function with a qualified name from module without metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+    it 'loads a puppet function using a qualified name in module' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    moduleb_loader = loaders.public_loader_for_module('moduleb')
-    function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::hello')).value
 
-    expect(function).to be_a(Puppet::Functions::Function)
-    expect(function.class.name).to eq('moduleb::rb_func_b')
-  end
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::hello')
+    end
 
-  it 'cannot load an unqualified function from a module without metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+    it 'loads a puppet function from a module without a lib directory' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_lib))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    moduleb_loader = loaders.public_loader_for_module('moduleb')
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::hello')).value
 
-    expect(moduleb_loader.load_typed(typed_name(:function, 'rb_func_b'))).to be_nil
-  end
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::hello')
+    end
 
-  it 'makes all other modules visible to a module without metadata' do
-    env = environment_for(module_with_metadata, module_without_metadata)
-    loaders = Puppet::Pops::Loaders.new(env)
+    it 'loads a puppet function in a sub namespace of module' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    moduleb_loader = loaders.private_loader_for_module('moduleb')
-    function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::subspace::hello')).value
 
-    expect(function.call({})).to eql("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::subspace::hello')
+    end
+
+    it 'loader does not add namespace if not given' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+
+      moduleb_loader = loaders.public_loader_for_module('moduleb')
+
+      expect(moduleb_loader.load_typed(typed_name(:function, 'rb_func_b'))).to be_nil
+    end
+
+    it 'loader allows loading a function more than once' do
+      env = environment_for(dependent_modules_with_metadata)
+      loaders = Puppet::Pops::Loaders.new(env)
+
+      moduleb_loader = loaders.private_loader_for_module('user')
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
+      expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
+      expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+    end
+  end
+
+  context 'when loading from a module with metadata' do
+    it 'all dependent modules are visible' do
+      env = environment_for(dependent_modules_with_metadata)
+      loaders = Puppet::Pops::Loaders.new(env)
+
+      moduleb_loader = loaders.private_loader_for_module('user')
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
+      expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+    end
   end
 
-  it 'makes dependent modules visible to a module with metadata' do
-    env = environment_for(dependent_modules_with_metadata)
-    loaders = Puppet::Pops::Loaders.new(env)
+  context 'when loading from a module without metadata' do
+    it 'loads a ruby function with a qualified name' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
 
-    moduleb_loader = loaders.private_loader_for_module('user')
-    function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
+      moduleb_loader = loaders.public_loader_for_module('moduleb')
+      function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+
+      expect(function).to be_a(Puppet::Functions::Function)
+      expect(function.class.name).to eq('moduleb::rb_func_b')
+    end
 
-    expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+
+    it 'all other modules are visible' do
+      env = environment_for(module_with_metadata, module_without_metadata)
+      loaders = Puppet::Pops::Loaders.new(env)
+
+      moduleb_loader = loaders.private_loader_for_module('moduleb')
+      function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+
+      expect(function.call({})).to eql("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
+    end
   end
 
-  context 'with scope' do
+  context 'when calling' do
     let(:env) { environment_for(mix_4x_and_3x_functions) }
     let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
     let(:loader) { Puppet::Pops::Loaders.new(env).private_loader_for_module('user') }
 
-    it 'can call 3x function in dependent module from a 4x function' do
+    it 'a 3x function in dependent module can be called from a 4x function' do
       Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
         function = loader.load_typed(typed_name(:function, 'user::caller')).value
         expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
       end
     end
 
-    it 'can call 3x function and propagate caller scope from a 4x function' do
+    it 'a 3x function in dependent module can be called from a puppet function' do
+      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
+        function = loader.load_typed(typed_name(:function, 'user::puppetcaller')).value
+        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
+      end
+    end
+
+    it 'a 4x function can be called from a puppet function' do
+      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
+        function = loader.load_typed(typed_name(:function, 'user::puppetcaller4')).value
+        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
+      end
+    end
+    it 'a puppet function can be called from a 4x function' do
+      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
+        function = loader.load_typed(typed_name(:function, 'user::callingpuppet')).value
+        expect(function.call(scope)).to eql("Did you call to say you love me?")
+      end
+    end
+
+    it 'a 3x function can be called with caller scope propagated from a 4x function' do
       Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
         function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
         expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
@@ -120,17 +189,6 @@ describe 'loaders' do
     end
   end
 
-  it 'can load a function more than once from modules' do
-    env = environment_for(dependent_modules_with_metadata)
-    loaders = Puppet::Pops::Loaders.new(env)
-
-    moduleb_loader = loaders.private_loader_for_module('user')
-    function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
-    expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
-
-    function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
-    expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
-  end
 
   def environment_for(*module_paths)
     Puppet::Node::Environment.create(:'*test*', module_paths)

data/spec/unit/pops/migration_spec.rb

@@ -0,0 +1,53 @@
+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()
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).at_least_once.returns(migration_checker)
+      expect(Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "1", __FILE__)).to eq(1)
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
+    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 = mock()
+      Puppet::Pops::Migration::MigrationChecker.expects(:new).never
+      Puppet.override({:migration_checker => migration_checker}, "test-context") do
+        Puppet::Pops::Parser::EvaluatingParser.new.evaluate_string(scope, "true", __FILE__)
+      end
+      Puppet::Pops::Migration::MigrationChecker.unstub(:new)
+    end
+  end
+end

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

@@ -234,6 +234,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)
@@ -361,6 +374,63 @@ 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 dealing with multi byte characters' do
@@ -371,6 +441,12 @@ 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"
+      CODE
+      expect(tokens_scanned_from(code)).to match_tokens2([:STRING, "x\u{1f452}y"])
+    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
@@ -482,6 +558,71 @@ describe 'Lexer2' do
       [: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
-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
+end