puppet 4.5.3-universal-darwin → 4.6.1-universal-darwin

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

@@ -25,7 +25,7 @@ describe 'Lexer2' do
     :RBRACK => ']',
     :LBRACE => '{',
     :RBRACE => '}',
-    :LPAREN => '(',
+    :WSLPAREN => '(', # since it is first on a line it is special (LPAREN handled separately)
     :RPAREN => ')',
     :EQUALS => '=',
     :ISEQUAL => '==',
@@ -301,12 +301,32 @@ describe 'Lexer2' do
     expect(tokens_scanned_from("$a [1]")).to match_tokens2(:VARIABLE, :LISTSTART, :NUMBER, :RBRACK)
     expect(tokens_scanned_from("a[1]")).to match_tokens2(:NAME, :LBRACK, :NUMBER, :RBRACK)
     expect(tokens_scanned_from("a [1]")).to match_tokens2(:NAME, :LISTSTART, :NUMBER, :RBRACK)
-    expect(tokens_scanned_from(" if \n\r\t\nif if ")).to match_tokens2(:IF, :IF, :IF)
+  end
+
+  it "differentiates between '(' first on line, and not first on line" do
+    expect(tokens_scanned_from("(")).to match_tokens2(:WSLPAREN)
+    expect(tokens_scanned_from("\n(")).to match_tokens2(:WSLPAREN)
+    expect(tokens_scanned_from("\n\r(")).to match_tokens2(:WSLPAREN)
+    expect(tokens_scanned_from("\n\t(")).to match_tokens2(:WSLPAREN)
+    expect(tokens_scanned_from("\n\r\t(")).to match_tokens2(:WSLPAREN)
+    expect(tokens_scanned_from("\n\u00a0(")).to match_tokens2(:WSLPAREN)
+
+    expect(tokens_scanned_from("x(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("\nx(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("\n\rx(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("\n\tx(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("\n\r\tx(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("\n\u00a0x(")).to match_tokens2(:NAME, :LPAREN)
+
+    expect(tokens_scanned_from("x (")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("x\t(")).to match_tokens2(:NAME, :LPAREN)
+    expect(tokens_scanned_from("x\u00a0(")).to match_tokens2(:NAME, :LPAREN)
   end
 
   it "skips whitepsace" do
     expect(tokens_scanned_from(" if if if ")).to match_tokens2(:IF, :IF, :IF)
     expect(tokens_scanned_from(" if \n\r\t\nif if ")).to match_tokens2(:IF, :IF, :IF)
+    expect(tokens_scanned_from(" if \n\r\t\n\u00a0if\u00a0 if ")).to match_tokens2(:IF, :IF, :IF)
   end
 
   it "skips single line comments" do
@@ -331,7 +351,11 @@ describe 'Lexer2' do
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],
-    "("  => [:LPAREN, "( /./"],
+
+    "("       => [:WSLPAREN, "( /./"],
+    "x ("     => [[:NAME, :LPAREN], "x ( /./"],
+    "x\\t ("  => [[:NAME, :LPAREN], "x\t ( /./"],
+
     "[ (liststart)"             => [:LISTSTART, "[ /./"],
     "[ (LBRACK)"                => [[:NAME, :LBRACK], "a[ /./"],
     "[ (liststart after name)"  => [[:NAME, :LISTSTART], "a [ /./"],

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

@@ -307,5 +307,13 @@ describe "egrammar parsing basic expressions" do
       expect(dump(parse("$a = \"yo${var.foo}yo\""))).to eq("(= $a (cat 'yo' (str (call-method (. $var foo))) 'yo'))")
       expect(dump(parse("$a = \"yo${var.foo.bar}yo\""))).to eq("(= $a (cat 'yo' (str (call-method (. (call-method (. $var foo)) bar))) 'yo'))")
     end
+
+    it "should interpolate interpolated expressions with a variable, \"yo${\"$var\"}yo\"" do
+      expect(dump(parse("$a = \"yo${\"$var\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat '' (str $var) '')) 'yo'))")
+    end
+
+    it "should interpolate interpolated expressions with an expression, \"yo${\"${$var+2}\"}yo\"" do
+      expect(dump(parse("$a = \"yo${\"${$var+2}\"}yo\""))).to eq("(= $a (cat 'yo' (str (cat '' (str (+ $var 2)) '')) 'yo'))")
+    end
   end
 end

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

@@ -45,6 +45,11 @@ describe "egrammar parsing function calls" do
       it "notice type(42)" do
         expect(dump(parse("notice type(42)"))).to eq('(invoke notice (call type 42))')
       end
+
+      it "is required to place the '(' on the same line as the name of the function to recognize it as arguments in call" do
+        expect(dump(parse("notice foo\n(42)"))).to eq("(block\n  (invoke notice foo)\n  42\n)")
+      end
+
     end
 
     context "in nested scopes" do
@@ -111,6 +116,10 @@ describe "egrammar parsing function calls" do
     it "notice 42.type(detailed)" do
       expect(dump(parse("notice 42.type(detailed)"))).to eq('(invoke notice (call-method (. 42 type) detailed))')
     end
+
+    it "is required to place the '(' on the same line as the name of the method to recognize it as arguments in call" do
+      expect(dump(parse("notice 42.type\n(detailed)"))).to eq("(block\n  (invoke notice (call-method (. 42 type)))\n  detailed\n)")
+    end
   end
 
   context "When parsing an illegal argument list" do

data/spec/unit/pops/puppet_stack_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+
+describe 'Puppet::Pops::PuppetStack' do
+  class StackTraceTest
+    def get_stacktrace
+      Puppet::Pops::PuppetStack.stacktrace
+    end
+
+    def one_level
+      Puppet::Pops::PuppetStack.stack("one_level.pp", 1234, self, :get_stacktrace, [])
+    end
+
+    def one_level
+      Puppet::Pops::PuppetStack.stack("one_level.pp", 1234, self, :get_stacktrace, [])
+    end
+
+    def two_levels
+      Puppet::Pops::PuppetStack.stack("two_levels.pp", 1237, self, :level2, [])
+    end
+
+    def level2
+      Puppet::Pops::PuppetStack.stack("level2.pp", 1240, self, :get_stacktrace, [])
+    end
+
+    def gets_block(a, &block)
+      block.call(a)
+    end
+
+    def gets_args_and_block(a, b, &block)
+      block.call(a, b)
+    end
+
+    def with_nil_file
+      Puppet::Pops::PuppetStack.stack(nil, 1250, self, :get_stacktrace, [])
+    end
+
+    def with_empty_string_file
+      Puppet::Pops::PuppetStack.stack('', 1251, self, :get_stacktrace, [])
+    end
+  end
+
+  it 'returns an empty array from stacktrace when there is nothing on the stack' do
+    expect(Puppet::Pops::PuppetStack.stacktrace).to eql([])
+  end
+
+  it 'returns a one element array with file, line from stacktrace when there is one entry on the stack' do
+    expect(StackTraceTest.new.one_level).to eql([['one_level.pp', 1234]])
+  end
+
+  it 'returns an array from stacktrace with information about each level with oldest frame last' do
+    expect(StackTraceTest.new.two_levels).to eql([['two_levels.pp', 1237], ['level2.pp', 1240]])
+  end
+
+  it 'accepts file to be nil' do
+    expect(StackTraceTest.new.with_nil_file).to eql([['unknown', 1250]])
+  end
+
+  it 'accepts file to be empty_string' do
+    expect(StackTraceTest.new.with_empty_string_file).to eql([['unknown', 1251]])
+  end
+
+  it 'stacktrace is empty when call has returned' do
+    StackTraceTest.new.two_levels
+    expect(Puppet::Pops::PuppetStack.stacktrace).to eql([])
+  end
+
+  it 'allows passing a block to the stack call' do
+    expect(Puppet::Pops::PuppetStack.stack("test.pp", 1, StackTraceTest.new, :gets_block, ['got_it']) {|x| x }).to eql('got_it')
+  end
+
+  it 'allows passing multiple variables and a block' do
+    expect(
+      Puppet::Pops::PuppetStack.stack("test.pp", 1, StackTraceTest.new, :gets_args_and_block, ['got_it', 'again']) {|x, y| [x,y].join(' ')}
+      ).to eql('got_it again')
+  end
+
+end

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

@@ -0,0 +1,37 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet_spec/compiler'
+
+module Puppet::Pops
+module Resource
+describe "Puppet::Pops::Resource" do
+  include PuppetSpec::Compiler
+
+  let!(:pp_parser) { Parser::EvaluatingParser.new }
+  let(:loader) { Loader::BaseLoader.new(nil, 'type_parser_unit_test_loader') }
+  let(:factory) { TypeFactory }
+
+  context 'when creating resources' do
+    let!(:resource_type) { ResourceTypeImpl._ptype }
+
+    it 'can create an instance of a ResourceType' do
+      code = <<-CODE
+        $rt = Puppet::Resource::ResourceType3.new('notify', [], [Puppet::Resource::Param.new(String, 'message')])
+        assert_type(Puppet::Resource::ResourceType3, $rt)
+        notice('looks like we made it')
+      CODE
+      rt = nil
+      notices = eval_and_collect_notices(code) do |scope, _|
+        rt = scope['rt']
+      end
+      expect(notices).to eq(['looks like we made it'])
+      expect(rt).to be_a(ResourceTypeImpl)
+      expect(rt.valid_parameter?(:nonesuch)).to be_falsey
+      expect(rt.valid_parameter?(:message)).to be_truthy
+      expect(rt.valid_parameter?(:loglevel)).to be_truthy
+    end
+  end
+end
+end
+end

data/spec/unit/pops/serialization/packer_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'puppet/pops/serialization'
+
+module Puppet::Pops::Serialization
+[JSON].each do |packer_module|
+describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
+  let(:io) { StringIO.new }
+  let(:reader_class) { packer_module::Reader }
+  let(:writer_class) { packer_module::Writer }
+
+  def write(*values)
+    io.reopen
+    serializer = writer_class.new(io)
+    values.each { |val| serializer.write(val) }
+    serializer.finish
+    io.rewind
+  end
+
+  def read(count = nil)
+    @deserializer = reader_class.new(io)
+    count.nil? ? @deserializer.read : Array.new(count) { @deserializer.read }
+  end
+
+  context 'can write and read a Scalar' do
+    it 'String' do
+      val = 'the value'
+      write(val)
+      val2 = read
+      expect(val2).to be_a(String)
+      expect(val2).to eql(val)
+    end
+
+    it 'positive Integer' do
+      val = 2**63-1
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Integer)
+      expect(val2).to eql(val)
+    end
+
+    it 'negative Integer' do
+      val = -2**63
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Integer)
+      expect(val2).to eql(val)
+    end
+
+    it 'Float' do
+      val = 32.45
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Float)
+      expect(val2).to eql(val)
+    end
+
+    it 'true' do
+      val = true
+      write(val)
+      val2 = read
+      expect(val2).to be_a(TrueClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'false' do
+      val = false
+      write(val)
+      val2 = read
+      expect(val2).to be_a(FalseClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'nil' do
+      val = nil
+      write(val)
+      val2 = read
+      expect(val2).to be_a(NilClass)
+      expect(val2).to eql(val)
+    end
+
+    it 'Regexp' do
+      val = /match me/
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Regexp)
+      expect(val2).to eql(val)
+    end
+
+    it 'Time created by TimeFactory' do
+      val = TimeFactory.now
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Time)
+      expect(val2).to eql(val)
+    end
+
+    it 'Version' do
+      val = Semantic::Version.parse('1.2.3-alpha2')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Semantic::Version)
+      expect(val2).to eql(val)
+    end
+
+    it 'VersionRange' do
+      val = Semantic::VersionRange.parse('>=1.2.3-alpha2 <1.2.4')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(Semantic::VersionRange)
+      expect(val2).to eql(val)
+    end
+
+    it 'will never fail write and read of Time created by TimeFactory' do
+      val = Time.now
+      val = TimeFactory.at(val.tv_sec, val.tv_nsec / 1000 + 0.123)
+      write(val)
+      val2 = read
+      expect(val).to eq(val2)
+    end
+
+    # Windows doesn't seem ot have fine enough granularity to provoke the problem
+    it 'will fail on Time not created by TimeFactory' do
+      val = Time.now
+      val = Time.at(val.tv_sec, val.tv_nsec / 1000 + 0.123)
+      write(val)
+      val2 = read
+      expect(val).not_to eq(val2)
+    end
+  end
+
+  context 'will fail on attempts to write' do
+    it 'Integer larger than 2**63-1' do
+      expect { write(2**63) }.to raise_error(SerializationError, 'Integer out of bounds')
+    end
+
+    it 'Integer smaller than -2**63' do
+      expect { write(-2**63-1) }.to raise_error(SerializationError, 'Integer out of bounds')
+    end
+
+    it 'objects unknown to Puppet serialization' do
+      expect { write("".class) }.to raise_error(SerializationError, 'Unable to serialize a Class')
+    end
+  end
+
+  it 'should be able to write and read primitives using tabulation' do
+    val = 'the value'
+    write(val, val)
+    expect(read(2)).to eql([val, val])
+    expect(@deserializer.primitive_count).to eql(1)
+  end
+end
+end
+end

data/spec/unit/pops/serialization/rgen_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+module Serialization
+describe 'RGen' do
+  let!(:env) { Puppet::Node::Environment.create(:testing, []) }
+  let!(:loaders) { Puppet::Pops::Loaders.new(env) }
+  let!(:loader) { loaders.find_loader(nil) }
+
+  around :each do |example|
+    Puppet.override(:loaders => loaders, :current_environment => env) do
+      example.run
+    end
+  end
+
+  def find_parent(type, parent_name)
+    p = type
+    while p.is_a?(Types::PObjectType) && p.name != parent_name
+      p = p.parent
+    end
+    expect(p).to be_a(Types::PObjectType), "did not find #{parent_name} in parent chain of #{type.name}"
+    p
+  end
+
+  context 'TypeGenerator' do
+
+    let!(:generator) { RGen::TypeGenerator.new }
+    let!(:type_set) { generator.generate_type_set('PuppetSpec::Bindings', Binder::Bindings, loader) }
+    let!(:bindings_classes) do
+      Binder::Bindings.constants.each_with_object([]) do |n, a|
+        cls = Binder::Bindings.const_get(n)
+        a << cls if cls.is_a?(Class) && cls.respond_to?(:ecore)
+      end
+    end
+
+    it 'generates TypeSet from a module that represents an ECore package' do
+      expect(type_set).to be_a(Types::PTypeSetType)
+      expect(type_set.types).not_to be_empty
+      expect(type_set.types.size).to eql(bindings_classes.size)
+    end
+
+    it 'all types are in the PuppetSpec::Bindings namespace' do
+      type_set.types.values.each {|type| expect(type.name).to start_with('PuppetSpec::Bindings::') }
+    end
+
+    it 'all types extend from PuppetSpec::Bindings::BindingsModelObject' do
+      type_set.types.values.each do |type|
+        expect(find_parent(type, 'PuppetSpec::Bindings::BindingsModelObject').name).to eq('PuppetSpec::Bindings::BindingsModelObject')
+      end
+    end
+  end
+
+  context 'AST model types' do
+    let!(:impl_repo) { Loaders.implementation_registry }
+    let!(:loader) {  Loaders.find_loader(nil) }
+    let!(:type_set) { Types::TypeParser.singleton.parse('Puppet::AST', loader) }
+    let!(:ast_classes) do
+      Model.constants.each_with_object([]) do |n, a|
+        cls = Model.const_get(n)
+        a << cls if cls.is_a?(Class) && cls.respond_to?(:ecore)
+      end
+    end
+
+    it 'can be mapped from the ecore classes found in Puppet::Pops::Model' do
+      ast_classes.each { |ast_class| expect(impl_repo.type_for_module(ast_class)).to be_a(Types::PObjectType) }
+    end
+
+    it 'are contained in a TypeSet named Puppet::AST' do
+      expect(type_set).to be_a(Types::PTypeSetType)
+      expect(type_set.name).to eq('Puppet::AST')
+      expect(type_set.types.size).to eql(ast_classes.size + 1)  # +1 because the Locator is added
+    end
+
+    it 'all reside in the Puppet::AST namespace' do
+      type_set.types.values.each {|type| expect(type.name).to start_with('Puppet::AST::') }
+    end
+
+    it 'all extend from Puppet::AST::PopsObject' do
+      type_set.types.values.each do |type|
+        next if type.name == 'Puppet::AST::Locator'
+        expect(find_parent(type, 'Puppet::AST::PopsObject').name).to eq('Puppet::AST::PopsObject')
+      end
+    end
+  end
+end
+end
+end