puppet 4.5.3-x64-mingw32 → 4.6.1-x64-mingw32

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

@@ -792,7 +792,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         Puppet.override({:global_scope => scope,
                          :environments => Puppet::Environments::Static.new(@node.environment)
         }, "gets class parameter test") do
-          scope.known_resource_types.import_ast(ast, '')
+          scope.environment.known_resource_types.import_ast(ast, '')
           expect(ast.code.safeevaluate(scope)).to eq('chocolate')
         end
       end

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

@@ -114,6 +114,6 @@ Puppet::Functions.create_function('testmodule::foo') {
   end
 
   def typed_name(type, name)
-    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+    Puppet::Pops::Loader::TypedName.new(type, name)
   end
 end

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

@@ -7,7 +7,7 @@ describe 'loader paths' do
   include PuppetSpec::Files
 
   let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
-  let(:unused_loaders) { nil }
+  let(:unused_loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:'*test*', [])) }
 
   it 'module loader has smart-paths that prunes unavailable paths' do
     module_dir = dir_containing('testmodule', {'lib' => {'puppet' => {'functions' =>

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

@@ -15,7 +15,7 @@ describe 'loader helper classes' do
   end
 
   it 'TypedName holds values and is frozen' do
-    tn = Puppet::Pops::Loader::Loader::TypedName.new(:function, '::foo::bar')
+    tn = Puppet::Pops::Loader::TypedName.new(:function, '::foo::bar')
     expect(tn.frozen?).to be_truthy
     expect(tn.type).to eq(:function)
     expect(tn.name_parts).to eq(['foo', 'bar'])
@@ -33,6 +33,7 @@ describe 'loaders' do
   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') }
+  let(:no_modules) { config_dir('no_modules') }
   let(:user_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/user/metadata.json') }
 
   let(:empty_test_env) { environment_for() }
@@ -40,6 +41,42 @@ describe 'loaders' do
   # Loaders caches the puppet_system_loader, must reset between tests
   before(:each) { Puppet::Pops::Loaders.clear() }
 
+  context 'when loading pp resource types using auto loading' do
+    let(:pp_resources) { config_dir('pp_resources') }
+    let(:environments) { Puppet::Environments::Directories.new(my_fixture_dir, []) }
+    let(:env) { Puppet::Node::Environment.create(:'pp_resources', [File.join(pp_resources, 'modules')]) }
+    let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
+    let(:loader) { Puppet::Pops::Loaders.loaders.find_loader(nil) }
+    around(:each) do |example|
+      Puppet.override(:environments => environments, :current_environment => scope.environment, :global_scope => scope) do
+        Puppet.override(:loaders => Puppet::Pops::Loaders.new(env)) do
+          example.run
+        end
+      end
+    end
+
+    it 'finds a resource type that resides under <environment root>/.resource_types' do
+      rt = loader.load(:resource_type_pp, 'myresource')
+      expect(rt).to be_a(Puppet::Pops::Resource::ResourceTypeImpl)
+    end
+
+    it 'does not allow additional logic in the file' do
+      expect{loader.load(:resource_type_pp, 'addlogic')}.to raise_error(ArgumentError, /it has additional logic/)
+    end
+
+    it 'does not allow creation of classes other than Puppet::Resource::ResourceType3' do
+      expect{loader.load(:resource_type_pp, 'badcall')}.to raise_error(ArgumentError, /no call to Puppet::Resource::ResourceType3.new found/)
+    end
+
+    it 'does not allow creation of other types' do
+      expect{loader.load(:resource_type_pp, 'wrongname')}.to raise_error(ArgumentError, /produced resource type with the wrong name, expected 'wrongname', actual 'notwrongname'/)
+    end
+
+    it 'errors with message about empty file for files that contain no logic' do
+      expect{loader.load(:resource_type_pp, 'empty')}.to raise_error(ArgumentError, /it is empty/)
+    end
+  end
+
   it 'creates a puppet_system loader' do
     loaders = Puppet::Pops::Loaders.new(empty_test_env)
     expect(loaders.puppet_system_loader()).to be_a(Puppet::Pops::Loader::ModuleLoaders::FileBased)
@@ -51,7 +88,7 @@ describe 'loaders' do
     expect(loaders.public_environment_loader()).to be_a(Puppet::Pops::Loader::SimpleEnvironmentLoader)
     expect(loaders.public_environment_loader().to_s).to eql("(SimpleEnvironmentLoader 'environment:*test*')")
     expect(loaders.private_environment_loader()).to be_a(Puppet::Pops::Loader::DependencyLoader)
-    expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
+    expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment private' [])")
   end
 
   context 'when loading from a module' do
@@ -200,7 +237,7 @@ describe 'loaders' do
           expect(resource['message']).to eq(desc[:expects])
         end
 
-        it 'can not call ruby function in a dependent module from outside a function if dependency is missing in existing metadata.json' do
+        it "can not call #{desc[:called]} from #{desc[:from]} if dependency is missing in existing metadata.json" do
           File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => []).to_pson
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
           expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
@@ -274,6 +311,28 @@ describe 'loaders' do
     end
   end
 
+  context 'when loading from an environment without modules' do
+    let(:node) { Puppet::Node.new('test', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'no_modules') }
+
+    it 'can load the same function twice with two different compilations and produce different values' do
+      Puppet.settings.initialize_global_settings
+      environments = Puppet::Environments::Directories.new(my_fixture_dir, [])
+      Puppet.override(:environments => environments) do
+        compiler = Puppet::Parser::Compiler.new(node)
+        compiler.topscope['value_from_scope'] = 'first'
+        catalog = compiler.compile
+        expect(catalog.resource('Notify[first]')).to be_a(Puppet::Resource)
+
+        Puppet::Pops::Loader::RubyFunctionInstantiator.expects(:create).never
+        compiler = Puppet::Parser::Compiler.new(node)
+        compiler.topscope['value_from_scope'] = 'second'
+        catalog = compiler.compile
+        expect(catalog.resource('Notify[first]')).to be_nil
+        expect(catalog.resource('Notify[second]')).to be_a(Puppet::Resource)
+      end
+    end
+  end
+
   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) }
@@ -314,13 +373,12 @@ describe 'loaders' do
     end
   end
 
-
   def environment_for(*module_paths)
     Puppet::Node::Environment.create(:'*test*', module_paths)
   end
 
   def typed_name(type, name)
-    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+    Puppet::Pops::Loader::TypedName.new(type, name)
   end
 
   def config_dir(config_name)

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

@@ -58,7 +58,7 @@ describe 'FileBased module loader' do
   end
 
   it 'system loader has itself as private loader' do
-    module_loader = Puppet::Pops::Loader::ModuleLoaders.system_loader_from(static_loader, loaders)
+    module_loader = loaders.puppet_system_loader
     expect(module_loader.private_loader).to be(module_loader)
   end
 
@@ -90,6 +90,6 @@ describe 'FileBased module loader' do
   end
 
   def typed_name(type, name)
-    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+    Puppet::Pops::Loader::TypedName.new(type, name)
   end
 end

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

@@ -121,7 +121,7 @@ describe 'the static loader' do
   end
 
   def typed_name(type, name)
-    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+    Puppet::Pops::Loader::TypedName.new(type, name)
   end
 
   def resource_type(name)

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