puppet 4.10.0 → 5.0.0

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

@@ -82,15 +82,11 @@ describe 'the static loader' do
   end
 
   context 'provides access to app-management specific resource types built into puppet' do
-    before(:each) { Puppet[:app_management] = true }
-    after(:each) { Puppet[:app_management] = false }
 
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
-    %w{Node}.each do |name|
-      it "such that #{name} is avaiable" do
-        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
-      end
+    it "such that Node is available" do
+      expect(loader.load(:type, 'node')).to be_the_type(resource_type('Node'))
     end
   end
 

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

@@ -6,28 +6,57 @@ module Puppet::Pops
 describe 'Puppet::Pops::Lookup::Interpolation' do
   include Lookup::SubLookup
 
+  class InterpolationTestAdapter < Lookup::LookupAdapter
+    include Lookup::SubLookup
+
+    def initialize(data, interpolator)
+      @data = data
+      @interpolator = interpolator
+    end
+
+    def track(name)
+    end
+
+    def lookup(name, lookup_invocation, merge)
+      track(name)
+      segments = split_key(name)
+      root_key = segments.shift
+      found = @data[root_key]
+      found = sub_lookup(name, lookup_invocation, segments, found) unless segments.empty?
+      @interpolator.interpolate(found, lookup_invocation, true)
+    end
+  end
+
   let(:interpolator) { Class.new { include Lookup::Interpolation }.new }
   let(:scope) { {} }
+  let(:data) { {} }
+  let(:adapter) { InterpolationTestAdapter.new(data, interpolator) }
   let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
+  before(:each) do
+    Lookup::Invocation.any_instance.stubs(:lookup_adapter).returns(adapter)
+  end
+
   def expect_lookup(*keys)
-    keys.each do |key|
-      segments = split_key(key)
-      root_key = segments.shift
-      found = data[root_key]
-      found = sub_lookup(key, lookup_invocation, segments, found) unless segments.empty?
-      Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(found)
-    end
+    keys.each { |key| adapter.expects(:track).with(key) }
   end
 
   context 'when interpolating nested data' do
     let(:nested_hash) { {'a' => {'aa' => "%{alias('aaa')}"}} }
 
+    let(:scope) {
+      {
+        'ds1' => 'a',
+        'ds2' => 'b'
+      }
+    }
+
     let(:data) {
       {
         'aaa' => {'b' => {'bb' => "%{alias('bbb')}"}},
         'bbb' => ["%{alias('ccc')}"],
-        'ccc' => 'text'
+        'ccc' => 'text',
+        'ddd' => "%{literal('%')}{ds1}_%{literal('%')}{ds2}",
       }
     }
 
@@ -35,6 +64,16 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
       expect_lookup('aaa', 'bbb', 'ccc')
       expect(interpolator.interpolate(nested_hash, lookup_invocation, true)).to eq('a' => {'aa' => {'b' => {'bb' => ['text']}}})
     end
+
+    it "'%{lookup('key')} will interpolate the returned value'" do
+      expect_lookup('ddd')
+      expect(interpolator.interpolate("%{lookup('ddd')}", lookup_invocation, true)).to eq('a_b')
+    end
+
+    it "'%{alias('key')} will not interpolate the returned value'" do
+      expect_lookup('ddd')
+      expect(interpolator.interpolate("%{alias('ddd')}", lookup_invocation, true)).to eq('%{ds1}_%{ds2}')
+    end
   end
 
   context 'when interpolating boolean scope values' do
@@ -242,7 +281,8 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
 
     it 'should not find a subkey that is matched within a string' do
-      expect{ expect_lookup('key.subkey') }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
+      expect{ interpolator.interpolate("%{lookup('key.subkey')}", lookup_invocation, true) }.to raise_error(
+        /Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
     end
   end
 
@@ -330,4 +370,4 @@ describe 'Puppet::Pops::Lookup::Interpolation' do
     end
   end
 end
-end
+end

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

@@ -57,6 +57,13 @@ describe 'The lookup API' do
           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
       }
     }
@@ -137,6 +144,31 @@ describe 'The lookup API' 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 }
 

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

@@ -4,7 +4,7 @@ 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
+    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
@@ -16,22 +16,22 @@ describe Puppet::Pops::Model::Factory do
   it "construct an arithmetic expression" do
     x = Factory.literal(10) + Factory.literal(20)
     expect(x.is_a?(Factory)).to eq(true)
-    current = x.current
-    expect(current.is_a?(Model::ArithmeticExpression)).to eq(true)
-    expect(current.operator).to eq(:'+')
-    expect(current.left_expr.class).to eq(Model::LiteralInteger)
-    expect(current.right_expr.class).to eq(Model::LiteralInteger)
-    expect(current.left_expr.value).to eq(10)
-    expect(current.right_expr.value).to eq(20)
+    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.current)).to eq("(+ 10 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.current)).to eq("(+ (* 2 10) 20)")
+    expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ (* 2 10) 20)")
   end
 end

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

@@ -21,7 +21,7 @@ describe "epp parser" do
 
   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...").current
+    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)

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

@@ -94,41 +94,16 @@ describe 'Lexer2' do
     "private"  => :PRIVATE,
     "type"     => :TYPE,
     "attr"     => :ATTR,
+    "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
 
-  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
@@ -412,6 +387,34 @@ describe 'Lexer2' do
     expect(tokens_scanned_from("1 / /./")).to match_tokens2(:NUMBER, :DIV, :REGEX)
   end
 
+  it 'should lex regexp with escaped slash' do
+    scanned = tokens_scanned_from('/\//')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('/'))
+  end
+
+  it 'should lex regexp with escaped backslash' do
+    scanned = tokens_scanned_from('/\\\\/')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('\\\\'))
+  end
+
+  it 'should lex regexp with escaped backslash followed escaped slash ' do
+    scanned = tokens_scanned_from('/\\\\\\//')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('\\\\/'))
+  end
+
+  it 'should lex regexp with escaped slash followed escaped backslash ' do
+    scanned = tokens_scanned_from('/\\/\\\\/')
+    expect(scanned).to match_tokens2(:REGEX)
+    expect(scanned[0][1][:value]).to eql(Regexp.new('/\\\\'))
+  end
+
+  it 'should not lex regexp with escaped ending slash' do
+    expect(tokens_scanned_from('/\\/')).to match_tokens2(:DIV, :OTHER, :DIV)
+  end
+
   it "should accept newline in a regular expression" do
     scanned = tokens_scanned_from("/\n.\n/")
     # Note that strange formatting here is important

data/spec/unit/pops/parser/{source_pos_adapter_spec.rb → locator_spec.rb}

@@ -1,26 +1,24 @@
 require 'spec_helper'
 require 'puppet/pops'
 
-describe Puppet::Pops::Adapters::SourcePosAdapter do
+describe Puppet::Pops::Parser::Locator do
 
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").current
+    model = parser.parse_string("# \u{0400}comment\nabcdef#XXXXXXXXXX").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(12)
-    expect(adapter.length).to eq(6)
-    expect(adapter.extract_text).to eq('abcdef')
+    expect(model.body.offset).to eq(12)
+    expect(model.body.length).to eq(6)
+    expect(model.body.locator.extract_text(model.body.offset, model.body.length)).to eq('abcdef')
   end
 
   it "multi byte characters in a comment does not interfere with AST node text extraction" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# \u{0400}comment\n1 + 2#XXXXXXXXXX").current
+    model = parser.parse_string("# \u{0400}comment\n1 + 2#XXXXXXXXXX").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
-    adapter = Puppet::Pops::Adapters::SourcePosAdapter.adapt(model.body)
-    expect(adapter.offset).to eq(14) # The '+'
-    expect(adapter.length).to eq(1)
-    expect(adapter.extract_tree_text).to eq('1 + 2')
+    expect(model.body.offset).to eq(14) # The '+'
+    expect(model.body.length).to eq(1)
+    expect(model.body.locator.extract_tree_text(model.body)).to eq('1 + 2')
   end
 
 end

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

@@ -6,9 +6,6 @@ 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

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

@@ -165,8 +165,8 @@ describe "egrammar parsing basic expressions" do
     end
 
     it "calculates the text length of an empty array" do
-      expect(parse("[]").current.body.length).to eq(2)
-      expect(parse("[ ]").current.body.length).to eq(3)
+      expect(parse("[]").model.body.length).to eq(2)
+      expect(parse("[ ]").model.body.length).to eq(3)
     end
 
     {
@@ -251,8 +251,8 @@ describe "egrammar parsing basic expressions" do
     end
 
     it "calculates the text length of an empty hash" do
-      expect(parse("{}").current.body.length).to eq(2)
-      expect(parse("{ }").current.body.length).to eq(3)
+      expect(parse("{}").model.body.length).to eq(2)
+      expect(parse("{ }").model.body.length).to eq(3)
     end
   end
 

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

@@ -6,9 +6,6 @@ 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 }"

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

@@ -74,26 +74,31 @@ describe "egrammar parsing containers" do
         # Not as much weird as confusing that it is possible to name a class 'class'. Can have
         # a very confusing effect when resolving relative names, getting the global hardwired "Class"
         # instead of some foo::class etc.
-        # This is allowed in 3.x.
-        expect {
-          expect(dump(parse("class class {}"))).to eq("(class class ())")
-        }.to raise_error(/not a valid classname/)
+        # This was allowed in 3.x.
+        expect { parse("class class {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 
       it "class default {} # a class named 'default'" do
         # The weirdness here is that a class can inherit 'default' but not declare a class called default.
         # (It will work with relative names i.e. foo::default though). The whole idea with keywords as
         # names is flawed to begin with - it generally just a very bad idea.
-        expect { expect(dump(parse("class default {}"))).to eq("(class default ())") }.to raise_error(Puppet::ParseError)
+        expect { parse("class default {}") }.to raise_error(Puppet::ParseError)
+      end
+
+      it "class 'foo' {} # a string as class name" do
+        # A common error is to put quotes around the class name, the parser should provide the error message at the right location
+        # See PUP-7471
+        expect { parse("class 'foo' {}") }.to raise_error(/A quoted string is not valid as a name here at line 1:7/)
       end
 
+
       it "class foo::default {} # a nested name 'default'" do
         expect(dump(parse("class foo::default {}"))).to eq("(class foo::default ())")
       end
 
       it "class class inherits default {} # inherits default", :broken => true do
         expect {
-          expect(dump(parse("class class inherits default {}"))).to eq("(class class (inherits default) ())")
+          parse("class class inherits default {}")
         }.to raise_error(/not a valid classname/)
       end
 
@@ -102,16 +107,12 @@ describe "egrammar parsing containers" do
         # this because a class is named at parse time (since class evaluation is lazy, the model must have the
         # full class name for nested classes - only, it gets this wrong when a class is named "class" - or at least
         # I think it is wrong.)
-        # 
-        expect {
-        expect(dump(parse("class class inherits default {}"))).to eq("(class class::class (inherits default) ())")
-          }.to raise_error(/not a valid classname/)
+        #
+        expect { parse("class class inherits default {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 
       it "class foo inherits class" do
-        expect {
-          expect(dump(parse("class foo inherits class {}"))).to eq("(class foo (inherits class) ())")
-        }.to raise_error(/not a valid classname/)
+        expect { parse("class foo inherits class {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
     end
 
@@ -119,7 +120,7 @@ describe "egrammar parsing containers" do
       ['and', 'case', 'class', 'default', 'define', 'else', 'elsif', 'if', 'in', 'inherits', 'node', 'or',
         'undef', 'unless', 'type', 'attr', 'function', 'private'].each do |keyword|
         it "such as #{keyword}" do
-          expect {parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }")}.to_not raise_error
+          expect { parse("class x ($#{keyword}){} class { x: #{keyword} => 1 }") }.to_not raise_error
         end
       end
     end
@@ -177,16 +178,13 @@ describe "egrammar parsing containers" do
       it "define class {} # a define named 'class'" do
         # This is weird because Class already exists, and instantiating this define will probably not
         # work
-        expect {
-          expect(dump(parse("define class {}"))).to eq("(define class ())")
-          }.to raise_error(/not a valid classname/)
+        expect { parse("define class {}") }.to raise_error(/'class' keyword not allowed at this location/)
       end
 
       it "define default {} # a define named 'default'" do
         # Check unwanted ability to define 'default'.
         # The expression below is not allowed (which is good).
-        #
-        expect { expect(dump(parse("define default {}"))).to eq("(define default ())")}.to raise_error(Puppet::ParseError)
+        expect { parse("define default {}") }.to raise_error(Puppet::ParseError)
       end
     end
 

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

@@ -6,9 +6,6 @@ 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 { }"

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

@@ -9,36 +9,34 @@ describe Puppet::Pops::Parser::Parser do
 
   it "should parse a code string and return a model" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("$a = 10").current
+    model = parser.parse_string("$a = 10").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(Puppet::Pops::Model::AssignmentExpression)
   end
 
   it "should accept empty input and return a model" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("").current
+    model = parser.parse_string("").model
     expect(model.class).to eq(Puppet::Pops::Model::Program)
     expect(model.body.class).to eq(Puppet::Pops::Model::Nop)
   end
 
   it "should accept empty input containing only comments and report location at end of input" do
     parser = Puppet::Pops::Parser::Parser.new()
-    model = parser.parse_string("# comment\n").current
+    model = parser.parse_string("# comment\n").model
     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(10)
-    expect(adapter.length).to eq(0)
+    expect(model.body.offset).to eq(10)
+    expect(model.body.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
+    model = parser.parse_string("# \u{0400}comment\n").model
     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)
+    expect(model.body.offset).to eq(12)
+    expect(model.body.length).to eq(0)
   end
 
   it "should raise an error with position information when error is raised from within parser" do

data/spec/unit/pops/resource/resource_type_impl_spec.rb

@@ -14,7 +14,7 @@ describe "Puppet::Pops::Resource" do
   let(:factory) { TypeFactory }
 
   context 'when creating resources' do
-    let!(:resource_type) { ResourceTypeImpl._ptype }
+    let!(:resource_type) { ResourceTypeImpl._pcore_type }
 
     it 'can create an instance of a ResourceType' do
       code = <<-CODE
@@ -93,13 +93,11 @@ describe "Puppet::Pops::Resource" do
     let(:env) { Puppet::Node::Environment.create(:'spec', [File.join(env_dir, 'spec', 'modules')]) }
     let(:node) { Puppet::Node.new('test', :environment => env) }
     around(:each) do |example|
-      Puppet[:app_management] = true
       Puppet[:environment] = env_name
       Puppet.override(:environments => environments, :current_environment => env) do
         example.run
       end
       Puppet::Type.rmtype(:capability)
-      Puppet[:app_management] = false
     end
 
     it 'does not load the Ruby resource' do