puppet 4.2.0 → 4.3.0

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

@@ -16,6 +16,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
   include PuppetSpec::Scope
   before(:each) do
     Puppet[:strict_variables] = true
+    Puppet[:data_binding_terminus] = 'none'
 
     # 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
@@ -684,23 +685,23 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     # Type operations (full set tested by tests covering type calculator)
     {
       "Array[Integer]"                  => types.array_of(types.integer),
-      "Array[Integer,1]"                => types.constrain_size(types.array_of(types.integer),1, :default),
-      "Array[Integer,1,2]"              => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1,2]]"     => types.constrain_size(types.array_of(types.integer),1, 2),
-      "Array[Integer,Integer[1]]"       => types.constrain_size(types.array_of(types.integer),1, :default),
+      "Array[Integer,1]"                => types.array_of(types.integer, types.range(1, :default)),
+      "Array[Integer,1,2]"              => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1,2]]"     => types.array_of(types.integer, types.range(1, 2)),
+      "Array[Integer,Integer[1]]"       => types.array_of(types.integer, types.range(1, :default)),
       "Hash[Integer,Integer]"           => types.hash_of(types.integer, types.integer),
-      "Hash[Integer,Integer,1]"         => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
-      "Hash[Integer,Integer,1,2]"       => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1,2]]" => types.constrain_size(types.hash_of(types.integer, types.integer),1, 2),
-      "Hash[Integer,Integer,Integer[1]]"   => types.constrain_size(types.hash_of(types.integer, types.integer),1, :default),
+      "Hash[Integer,Integer,1]"         => types.hash_of(types.integer, types.integer, types.range(1, :default)),
+      "Hash[Integer,Integer,1,2]"       => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1,2]]" => types.hash_of(types.integer, types.integer, types.range(1, 2)),
+      "Hash[Integer,Integer,Integer[1]]"   => types.hash_of(types.integer, types.integer, types.range(1, :default)),
       "Resource[File]"                  => types.resource('File'),
       "Resource['File']"                => types.resource(types.resource('File')),
       "File[foo]"                       => types.resource('file', 'foo'),
       "File[foo, bar]"                  => [types.resource('file', 'foo'), types.resource('file', 'bar')],
       "Pattern[a, /b/, Pattern[c], Regexp[d]]"  => types.pattern('a', 'b', 'c', 'd'),
-      "String[1,2]"                     => types.constrain_size(types.string,1, 2),
-      "String[Integer[1,2]]"            => types.constrain_size(types.string,1, 2),
-      "String[Integer[1]]"              => types.constrain_size(types.string,1, :default),
+      "String[1,2]"                     => types.string(types.range(1, 2)),
+      "String[Integer[1,2]]"            => types.string(types.range(1, 2)),
+      "String[Integer[1]]"              => types.string(types.range(1, :default)),
     }.each do |source, result|
       it "should parse and evaluate the expression '#{source}' to #{result}" do
         expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
@@ -1194,6 +1195,14 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       expect(scope.compiler).to have_relationship(['File', 'b', '->', 'File', 'y'])
     end
 
+    it 'should form a relation with 3.x resource -> resource' do
+      # Create a 3.x resource since this is the value given as arguments to defined type
+      scope['a_3x_resource']= Puppet::Parser::Resource.new('notify', 'a', {:scope => scope, :file => __FILE__, :line => 1})
+      source = "$a_3x_resource -> notify{b:}"
+      parser.evaluate_string(scope, source, __FILE__)
+      expect(scope.compiler).to have_relationship(['Notify', 'a', '->', 'Notify', 'b'])
+    end
+
     it 'should tolerate (eliminate) duplicates in operands' do
       source = "[File[a], File[a]] -> File[x]"
       parser.evaluate_string(scope, source, __FILE__)

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

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/literal_evaluator'
+
+describe "Puppet::Pops::Evaluator::LiteralEvaluator" do
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+  let(:leval)  {  Puppet::Pops::Evaluator::LiteralEvaluator.new }
+
+  { "1"       => 1,
+    "3.14"    => 3.14,
+    "true"    => true,
+    "false"   => false,
+    "'1'"     => '1',
+    "'a'"     => 'a',
+    '"a"'     => 'a',
+    'a'       => 'a',
+    'a::b'    => 'a::b',
+
+    # special values
+    'default' => :default,
+    '/.*/'    => /.*/,
+
+    # collections
+    '[1,2,3]'     => [1,2,3],
+    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
+
+  }.each do |source, result|
+    it "evaluates '#{source}' to #{result}" do
+      expect(leval.literal(parser.parse_string(source))).to eq(result)
+    end
+  end
+
+  it "evaluates undef to nil" do
+    expect(leval.literal(parser.parse_string('undef'))).to be_nil
+  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
+end

data/spec/unit/pops/label_provider_spec.rb

@@ -2,7 +2,11 @@ require 'spec_helper'
 require 'puppet/pops'
 
 describe Puppet::Pops::LabelProvider do
-  let(:labeler) { Puppet::Pops::LabelProvider.new }
+  class TestLabelProvider
+    include Puppet::Pops::LabelProvider
+  end
+
+  let(:labeler) { TestLabelProvider.new }
 
   it "prefixes words that start with a vowel with an 'an'" do
     expect(labeler.a_an('owl')).to eq('an owl')

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

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'matchers/match_tokens2'
 require 'puppet/pops'
 require 'puppet/pops/parser/lexer2'
+require_relative './parser_rspec_helper'
 
 module EgrammarLexer2Spec
   def tokens_scanned_from(s)
@@ -19,6 +20,7 @@ end
 
 describe 'Lexer2' do
   include EgrammarLexer2Spec
+  include ParserRspecHelper
 
   {
     :LISTSTART => '[',
@@ -91,12 +93,49 @@ 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) do
+      with_app_management(true)
+    end
+
+    after(:each) do
+      with_app_management(false)
+    end
+
+    {
+      "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

data/spec/unit/pops/parser/parse_application_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 'application'" do
+  include ParserRspecHelper
+
+  before(:each) do
+    with_app_management(true)
+  end
+
+  after(:each) do
+    with_app_management(false)
+  end
+
+  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

@@ -175,6 +175,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_capabilities_spec.rb

@@ -0,0 +1,47 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+
+describe "egrammar parsing of capability mappings" do
+  include ParserRspecHelper
+
+  before(:each) do
+    with_app_management(true)
+  end
+
+  after(:each) do
+    with_app_management(false)
+  end
+
+  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_site_spec.rb

@@ -0,0 +1,38 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+
+# relative to this spec file (./) does not work as this file is loaded by rspec
+require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+
+describe "egrammar parsing of site expression" do
+  include ParserRspecHelper
+
+  before(:each) do
+    with_app_management(true)
+  end
+
+  after(:each) do
+    with_app_management(false)
+  end
+
+  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
+end

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

@@ -4,6 +4,11 @@ require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
 
 module ParserRspecHelper
   include FactoryRspecHelper
+
+  def with_app_management(flag)
+    Puppet[:app_management] = flag
+  end
+
   def parse(code)
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)

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

@@ -44,4 +44,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