puppet 4.1.0 → 4.10.0

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

@@ -23,18 +23,20 @@ module EvaluatorRspecHelper
     # top_scope = Puppet::Parser::Scope.new(compiler)
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    result = evaluator.evaluate(in_top_scope.current, top_scope)
-    if in_named_scope
-      other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
-      result = evaluator.evaluate(in_named_scope.current, other_scope)
+    Puppet.override(:loaders => compiler.loaders) do
+      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      if in_named_scope
+        other_scope = Puppet::Parser::Scope.new(compiler, :namespace => scopename)
+        result = evaluator.evaluate(in_named_scope.current, other_scope)
+      end
+      if in_top_scope_again
+        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+      end
+      if block_given?
+        block.call(top_scope)
+      end
+      result
     end
-    if in_top_scope_again
-      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
-    end
-    if block_given?
-      block.call(top_scope)
-    end
-    result
   end
 
   # Evaluate a Factory wrapper round a model object in top scope + local scope
@@ -52,20 +54,22 @@ module EvaluatorRspecHelper
     top_scope = compiler.topscope()
 
     evaluator = Puppet::Pops::Evaluator::EvaluatorImpl.new
-    result = evaluator.evaluate(in_top_scope.current, top_scope)
-    if in_local_scope
-      # This is really bad in 3.x scope
-      elevel = top_scope.ephemeral_level
-      top_scope.new_ephemeral(true)
-      result = evaluator.evaluate(in_local_scope.current, top_scope)
-      top_scope.unset_ephemeral_var(elevel)
-    end
-    if in_top_scope_again
-      result = evaluator.evaluate(in_top_scope_again.current, top_scope)
-    end
-    if block_given?
-      block.call(top_scope)
+    Puppet.override(:loaders => compiler.loaders) do
+      result = evaluator.evaluate(in_top_scope.current, top_scope)
+      if in_local_scope
+        # This is really bad in 3.x scope
+        top_scope.with_guarded_scope do
+          top_scope.new_ephemeral(true)
+          result = evaluator.evaluate(in_local_scope.current, top_scope)
+        end
+      end
+      if in_top_scope_again
+        result = evaluator.evaluate(in_top_scope_again.current, top_scope)
+      end
+      if block_given?
+        block.call(top_scope)
+      end
+      result
     end
-    result
   end
 end

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

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/evaluator/json_strict_literal_evaluator'
+
+describe "Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator" do
+  let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+  let(:leval)  {  Puppet::Pops::Evaluator::JsonStrictLiteralEvaluator.new }
+
+  { "1"       => 1,
+    "3.14"    => 3.14,
+    "true"    => true,
+    "false"   => false,
+    "'1'"     => '1',
+    "'a'"     => 'a',
+    '"a"'     => 'a',
+    'a'       => 'a',
+    'a::b'    => 'a::b',
+    'undef'   => nil,
+
+    # collections
+    '[1,2,3]'     => [1,2,3],
+    '{a=>1,b=>2}' => {'a' => 1, 'b' => 2},
+    '[undef]'     => [nil],
+    '{a=>undef}'  => { 'a' => nil }
+
+  }.each do |source, result|
+    it "evaluates '#{source}' to #{result}" do
+      expect(leval.literal(parser.parse_string(source))).to eq(result)
+    end
+  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
+
+  [ 'default', 
+    '/.*/', 
+    '{1=>100}', 
+    '{undef => 10}',
+    '{default => 10}',
+    '{/.*/ => 10}',
+    '{"ok" => {1 => 100}}',
+    '[default]',
+    '[[default]]',
+    '[/.*/]',
+    '[[/.*/]]',
+    '[{1 => 100}]',
+  ].each do |source|
+    it "throws :not_literal for values not representable as pure JSON '#{source}'" do
+      expect{leval.literal(parser.parse_string('1+1'))}.to throw_symbol(:not_literal)
+    end
+  end
+end

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/evaluator/runtime3_converter_spec.rb

@@ -0,0 +1,133 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/types/type_factory'
+
+describe 'when converting to 3.x' do
+  let(:converter) { Puppet::Pops::Evaluator::Runtime3Converter.instance }
+
+  it "converts a resource type starting with Class without confusing it with exact match on 'class'" do
+    t = Puppet::Pops::Types::TypeFactory.resource('classroom', 'kermit')
+    converted = converter.catalog_type_to_split_type_title(t)
+    expect(converted).to eql(['classroom', 'kermit'])
+  end
+
+  it "converts a resource type of exactly 'Class'" do
+    t = Puppet::Pops::Types::TypeFactory.resource('class', 'kermit')
+    converted = converter.catalog_type_to_split_type_title(t)
+    expect(converted).to eql(['class', 'kermit'])
+  end
+
+  it "errors on attempts to convert an 'Iterator'" do
+    expect {
+      converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
+    }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
+  end
+
+  it 'does not convert a SemVer instance to string' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'converts the symbol :undef to the undef value' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert(:undef, {}, 'undef value')).to eql('undef value')
+  end
+
+  it 'converts the nil to the undef value' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert(nil, {}, 'undef value')).to eql('undef value')
+  end
+
+  it 'does not convert a symbol nested in an array' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert({'foo' => :undef}, {}, 'undef value')).to eql({'foo' => :undef})
+  end
+
+  it 'converts nil to :undef when nested in an array' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert({'foo' => nil}, {}, 'undef value')).to eql({'foo' => :undef})
+  end
+
+  it 'does not convert a Regex instance to string' do
+    v = /^[A-Z]$/
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Version instance to string' do
+    v = SemanticPuppet::Version.parse('1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a VersionRange instance to string' do
+    v = SemanticPuppet::VersionRange.parse('>=1.0.0')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Timespan instance to string' do
+    v = Puppet::Pops::Time::Timespan.new(1234)
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Timestamp instance to string' do
+    v = Puppet::Pops::Time::Timestamp.now
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Sensitive instance to string' do
+    v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  it 'does not convert a Binary instance to string' do
+    v = Puppet::Pops::Types::PBinaryType::Binary.from_base64('w5ZzdGVuIG1lZCByw7ZzdGVuCg==')
+    expect(converter.convert(v, {}, nil)).to equal(v)
+  end
+
+  context 'the Runtime3FunctionArgumentConverter' do
+    let(:converter) { Puppet::Pops::Evaluator::Runtime3FunctionArgumentConverter.instance }
+
+    it 'converts a Regex instance to string' do
+      c = converter.convert(/^[A-Z]$/, {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('/^[A-Z]$/')
+    end
+
+    it 'converts a Version instance to string' do
+      c = converter.convert(SemanticPuppet::Version.parse('1.0.0'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('1.0.0')
+    end
+
+    it 'converts a VersionRange instance to string' do
+      c = converter.convert(SemanticPuppet::VersionRange.parse('>=1.0.0'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('>=1.0.0')
+    end
+
+    it 'converts a Timespan instance to string' do
+      c = converter.convert(Puppet::Pops::Time::Timespan.new(1234), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('0-00:00:00.1234')
+    end
+
+    it 'converts a Timestamp instance to string' do
+      c = converter.convert(Puppet::Pops::Time::Timestamp.parse('2016-09-15T12:24:47.193 UTC'), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql('2016-09-15T12:24:47.193 UTC')
+    end
+
+    it 'converts a Binary instance to string' do
+      b64 = 'w5ZzdGVuIG1lZCByw7ZzdGVuCg=='
+      c = converter.convert(Puppet::Pops::Types::PBinaryType::Binary.from_base64(b64), {}, nil)
+      expect(c).to be_a(String)
+      expect(c).to eql(b64)
+    end
+
+    it 'does not convert a Sensitive instance to string' do
+      v = Puppet::Pops::Types::PSensitiveType::Sensitive.new("don't reveal this")
+      expect(converter.convert(v, {}, nil)).to equal(v)
+    end
+  end
+end

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

@@ -41,7 +41,7 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
 
       it "access to global names works in local scope" do
         top_scope_block     = block( var('a').set(literal(2)+literal(2)))
-        local_scope_block   = block( var('a').set(var('::a')+literal(2)), var('::a'))
+        local_scope_block   = block( var('a').set(literal(100)), var('b').set(var('::a')+literal(2)), var('b'))
         expect(evaluate_l(top_scope_block, local_scope_block)).to eq(6)
       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/loaders/dependency_loader_spec.rb

@@ -10,6 +10,18 @@ describe 'dependency loader' do
   let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
 
   describe 'FileBased module loader' do
+    it 'prints a pretty name for itself when inspected' do
+      module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => 'Puppet::Functions.create_function("foo") { def foo; end; }'
+      }}}}})
+
+      loader = loader_for('testmodule', module_dir)
+
+      expect(loader.inspect).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
+      expect(loader.to_s).to eq("(DependencyLoader 'test-dep' [(ModuleLoader::FileBased 'testmodule' 'testmodule')])")
+    end
+
     it 'load something in global name space raises an error' do
       module_dir = dir_containing('testmodule', {
       'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
@@ -53,6 +65,59 @@ describe 'dependency loader' do
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
+
+    describe "when parsing files from disk" do
+
+      # First line of Rune version of Rune poem at http://www.columbia.edu/~fdc/utf8/
+      # characters chosen since they will not parse on Windows with codepage 437 or 1252
+      # Section 3.2.1.3 of Ruby spec guarantees that \u strings are encoded as UTF-8
+      let (:node) { Puppet::Node.new('node') }
+      let (:rune_utf8) { "\u16A0\u16C7\u16BB" } # ᚠᛇᚻ
+      let (:code_utf8) do <<-CODE
+Puppet::Functions.create_function('testmodule::foo') {
+  def foo
+    return \"#{rune_utf8}\"
+  end
+}
+      CODE
+      end
+
+      context 'when loading files from disk' do
+        it 'should always read files as UTF-8' do
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => code_utf8
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+
+        it 'currently ignores the UTF-8 BOM (Byte Order Mark) when loading module files' do
+          bom = "\uFEFF"
+
+          if Puppet.features.microsoft_windows? && Encoding.default_external == Encoding::UTF_8
+            raise 'This test must be run in a codepage other than 65001 to validate behavior'
+          end
+
+          module_dir = dir_containing('testmodule', {
+          'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+            'foo.rb' => "#{bom}#{code_utf8}"
+          }}}}})
+
+          loader = loader_for('testmodule', module_dir)
+
+          function = loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+          expect(function.call({})).to eq(rune_utf8)
+        end
+      end
+    end
   end
 
   def loader_for(name, dir)
@@ -61,6 +126,6 @@ describe 'dependency 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/environment_loader_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'Environment loader' do
+  include PuppetSpec::Files
+
+  let(:env_name) { 'spec' }
+  let(:code_dir) { Puppet[:environmentpath] }
+  let(:env_dir) { File.join(code_dir, env_name) }
+  let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_code_dir, env_name, 'modules')]) }
+  let(:populated_code_dir) do
+    dir_contained_in(code_dir, env_name => env_content)
+    PuppetSpec::Files.record_tmp(env_dir)
+    code_dir
+  end
+
+  let(:env_content) {
+    {
+      'lib' => {
+        'puppet' => {
+          'functions' => {
+            'ruby_foo.rb' => <<-RUBY.unindent,
+              Puppet::Functions.create_function(:ruby_foo) do
+                def ruby_foo()
+                  'ruby_foo'
+                end
+              end
+              RUBY
+            'environment' => {
+              'ruby_foo.rb' => <<-RUBY.unindent
+                Puppet::Functions.create_function(:'environment::ruby_foo') do
+                  def ruby_foo()
+                    'environment::ruby_foo'
+                  end
+                end
+                RUBY
+            },
+            'someother' => {
+              'ruby_foo.rb' => <<-RUBY.unindent
+                Puppet::Functions.create_function(:'someother::ruby_foo') do
+                  def ruby_foo()
+                    'someother::ruby_foo'
+                  end
+                end
+                RUBY
+            },
+          }
+        }
+      },
+      'functions' => {
+        'puppet_foo.pp' => <<-PUPPET.unindent,
+          function puppet_foo() {
+            'puppet_foo'
+          }
+          PUPPET
+        'environment' => {
+          'puppet_foo.pp' => <<-PUPPET.unindent,
+            function environment::puppet_foo() {
+              'environment::puppet_foo'
+            }
+            PUPPET
+        },
+        'someother' => {
+          'puppet_foo.pp' => <<-PUPPET.unindent,
+            function somether::puppet_foo() {
+              'someother::puppet_foo'
+            }
+            PUPPET
+        }
+      },
+      'types' => {
+        'footype.pp' => <<-PUPPET.unindent,
+          type FooType = Enum['foo', 'bar', 'baz']
+          PUPPET
+        'environment' => {
+          'footype.pp' => <<-PUPPET.unindent,
+            type Environment::FooType = Integer[0,9]
+            PUPPET
+        },
+        'someother' => {
+          'footype.pp' => <<-PUPPET.unindent,
+            type SomeOther::FooType = Float[0.0,9.0]
+            PUPPET
+        }
+      }
+    }
+  }
+
+  before(:each) do
+    Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+  end
+
+  after(:each) do
+    Puppet.pop_context
+  end
+
+  def load_or_nil(type, name)
+    found = Puppet::Pops::Loaders.find_loader(nil).load_typed(Puppet::Pops::Loader::TypedName.new(type, name))
+    found.nil? ? nil : found.value
+  end
+
+  context 'loading a Ruby function' do
+    it 'loads from global name space' do
+      function = load_or_nil(:function, 'ruby_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('ruby_foo')
+      expect(function).to be_a(Puppet::Functions::Function)
+    end
+
+    it 'loads from environment name space' do
+      function = load_or_nil(:function, 'environment::ruby_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('environment::ruby_foo')
+      expect(function).to be_a(Puppet::Functions::Function)
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      function = load_or_nil(:function, 'someother::ruby_foo')
+      expect(function).to be_nil
+    end
+  end
+
+  context 'loading a Puppet function' do
+    it 'loads from global name space' do
+      function = load_or_nil(:function, 'puppet_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('puppet_foo')
+      expect(function).to be_a(Puppet::Functions::PuppetFunction)
+    end
+
+    it 'loads from environment name space' do
+      function = load_or_nil(:function, 'environment::puppet_foo')
+      expect(function).not_to be_nil
+
+      expect(function.class.name).to eq('environment::puppet_foo')
+      expect(function).to be_a(Puppet::Functions::PuppetFunction)
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      function = load_or_nil(:function, 'someother::puppet_foo')
+      expect(function).to be_nil
+    end
+  end
+
+  context 'loading a Puppet type' do
+    it 'loads from global name space' do
+      type = load_or_nil(:type, 'footype')
+      expect(type).not_to be_nil
+
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eq('FooType')
+    end
+
+    it 'loads from environment name space' do
+      type = load_or_nil(:type, 'environment::footype')
+      expect(type).not_to be_nil
+
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eq('Environment::FooType')
+    end
+
+    it 'fails to load from namespaces other than global or environment' do
+      type = load_or_nil(:type, 'someother::footype')
+      expect(type).to be_nil
+    end
+  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' =>