puppet 4.0.0 → 4.9.1

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,12 +41,12 @@ 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
 
       it "can not change a variable value in same scope" do
-        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable a/)
+        expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable '\$a'/)
       end
 
       context "access to numeric variables" do

data/spec/unit/pops/issues_spec.rb

@@ -62,19 +62,19 @@ describe "Puppet::Pops::IssueReporter" do
     end
 
     it "emits warnings if told to emit them" do
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit warnings if not told to emit them" do
-      Puppet.expects(:warning).never
+      Puppet::Log.expects(:create).never
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, {})
     end
 
     it "emits no warnings if :max_warnings is 0" do
       acceptor.accept( warning(2) )
       Puppet[:max_warnings] = 0
-      Puppet.expects(:warning).once.with(regexp_matches(/deprecation1/))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
@@ -82,20 +82,20 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( warning(2) )
       acceptor.accept( warning(3) )
       Puppet[:max_warnings] = 1
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit more deprecations warnings than the max deprecation warnings" do
       acceptor.accept( deprecation(2) )
       Puppet[:max_deprecations] = 0
-      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
 
     it "does not emit deprecation warnings, but does emit regular warnings if disable_warnings includes deprecations" do
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      Puppet::Log.expects(:create).once.with(has_entries(:level => :warning, :message => regexp_matches(/warning1/)))
       Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
     end
   end
@@ -103,7 +103,7 @@ describe "Puppet::Pops::IssueReporter" do
   context "given errors" do
     it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
       end.to raise_error(Puppet::ParseError, 'special')
@@ -111,7 +111,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "prefixes :message if a single error is raised" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /special error1/)
@@ -119,7 +119,7 @@ describe "Puppet::Pops::IssueReporter" do
 
     it "logs nothing and raises immediately if there is only one error" do
       acceptor.accept( error(1) )
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -129,7 +129,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:max_errors] = 0
-      Puppet.expects(:err).never
+      Puppet::Log.expects(:create).never
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /error1/)
@@ -138,7 +138,7 @@ describe "Puppet::Pops::IssueReporter" do
     it "logs the :message if there is more than one allowed error" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
-      Puppet.expects(:err).times(3).with(regexp_matches(/error1|error2|special/))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2|special/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -149,7 +149,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 2
-      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -160,7 +160,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(2) )
       acceptor.accept( error(3) )
       Puppet[:max_errors] = 4
-      Puppet.expects(:err).times(3).with(regexp_matches(/error[123]/))
+      Puppet::Log.expects(:create).times(3).with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
@@ -170,7 +170,7 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(1) )
       acceptor.accept( error(2) )
       Puppet[:disable_warnings] = 'deprecations'
-      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      Puppet::Log.expects(:create).times(2).with(has_entries(:level => :err, :message => regexp_matches(/error1|error2/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
       end.to raise_error(Puppet::ParseError, /Giving up/)
@@ -186,8 +186,8 @@ describe "Puppet::Pops::IssueReporter" do
       acceptor.accept( error(3) )
       acceptor.accept( deprecation(1) )
       Puppet[:max_errors] = 2
-      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
-      Puppet.expects(:err).times(2).with(regexp_matches(/error[123]/))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :warning, :message => regexp_matches(/warning1|deprecation1/)))
+      Puppet::Log.expects(:create).twice.with(has_entries(:level => :err, :message => regexp_matches(/error[123]/)))
       expect do
         Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
       end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)

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' =>