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

data/spec/unit/{appmgmt_spec.rb → parser/environment_compiler_spec.rb}

@@ -480,7 +480,6 @@ EOS
     end
   end
 
-
   describe "in the environment catalog" do
     it "does not fail if there is no site expression" do
       expect {
@@ -490,6 +489,18 @@ EOS
       }.to_not raise_error()
     end
 
+    it "ignores usage of hiera_include() at topscope for classification" do
+      Puppet.expects(:debug).with(regexp_matches /Ignoring hiera_include/)
+
+      expect {
+        catalog = compile_to_env_catalog(<<-EOC).to_resource
+        hiera_include('classes')
+        site { }
+        EOC
+      }.to_not raise_error()
+
+    end
+
     it "includes components and capability resources" do
       catalog = compile_to_env_catalog(MANIFEST).to_resource
       apps = catalog.resources.select do |res|

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -1,9 +1,11 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'puppet_spec/files'
 
 describe 'function for dynamically creating resources' do
   include PuppetSpec::Compiler
+  include PuppetSpec::Files
 
   before :each do
     node      = Puppet::Node.new("floppy", :environment => 'production')
@@ -31,6 +33,35 @@ describe 'function for dynamically creating resources' do
     expect { @scope.function_create_resources(['foo',{},'foo']) }.to raise_error(ArgumentError, 'create_resources(): third argument, if provided, must be a hash')
   end
 
+  context 'when being called from a manifest in a file' do
+    let(:dir) do
+      dir_containing('manifests', {
+              'site.pp' => <<-EOF
+                # comment here to make the call be on a particular
+                # source line (3)
+                create_resources('notify', {
+                  'a'  => { 'message'=>'message a'},
+                  'b'  => { 'message'=>'message b'},
+                  }
+                )
+              EOF
+          }
+      )
+    end
+
+    it 'file and line information where call originates is written to all resources created in one call' do
+      node = Puppet::Node.new('test')
+      file = File.join(dir, 'site.pp')
+      Puppet[:manifest] = file
+      catalog = Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
+
+      expect(catalog.resource(:notify, 'a').file).to eq(file)
+      expect(catalog.resource(:notify, 'a').line).to eq(3)
+      expect(catalog.resource(:notify, 'b').file).to eq(file)
+      expect(catalog.resource(:notify, 'b').line).to eq(3)
+    end
+
+  end
   describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
@@ -43,6 +74,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
+    it 'should pick up and pass on file and line information' do
+      # mock location as the compile_to_catalog sets Puppet[:code} which does not
+      # have file/line support.
+      Puppet::Pops::PuppetStack.expects(:stacktrace).once.returns([['test.pp', 1234]])
+      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      r = catalog.resource(:file, "/etc/foo")
+      expect(r.file).to eq('test.pp')
+      expect(r.line).to eq(1234)
+    end
+
     it 'should be able to add virtual resources' do
       catalog = compile_to_catalog("create_resources('@file', {'/etc/foo'=>{'ensure'=>'present'}})\nrealize(File['/etc/foo'])")
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
@@ -54,16 +95,16 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
     end
 
-    it 'should accept multiple types' do
+    it 'should accept multiple resources' do
       catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
       expect(catalog.resource(:notify, "foo")['message']).to eq('one')
       expect(catalog.resource(:notify, "bar")['message']).to eq('two')
     end
 
-    it 'should fail to add non-existing type' do
+    it 'should fail to add non-existing resource type' do
       expect do
         @scope.function_create_resources(['create-resource-foo', { 'foo' => {} }])
-      end.to raise_error(/Invalid resource type create-resource-foo/)
+      end.to raise_error(/Unknown resource type: 'create-resource-foo'/)
     end
 
     it 'should be able to add edges' do
@@ -84,6 +125,15 @@ describe 'function for dynamically creating resources' do
       expect(rg.path_between(foo,nil)).to_not be
     end
 
+    it 'should filter out undefined edges in an array as they cause errors' do
+      rg = compile_to_relationship_graph("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>[undef]}})")
+      test  = rg.vertices.find { |v| v.title == 'test' }
+      foo   = rg.vertices.find { |v| v.title == 'foo' }
+      expect(test).to be
+      expect(foo).to be
+      expect(rg.path_between(foo,nil)).to_not be
+    end
+
     it 'should account for default values' do
       catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'})")
       expect(catalog.resource(:file, "/etc/foo")['group']).to eq('bar')
@@ -112,7 +162,29 @@ describe 'function for dynamically creating resources' do
 
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one' on node test/)
+      }.to raise_error(Puppet::Error, /Foocreateresource\[blah\]: expects a value for parameter 'one'/)
+    end
+
+    it 'should accept undef as explicit value when parameter has no default value' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one) {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaabbb')
+    end
+
+    it 'should use default value expression if given value is undef' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one = 'xx') {
+            notify { $name: message => "aaa${one}bbb" }
+          }
+
+          create_resources('foocreateresource', {'blah'=>{ one => undef}})
+        MANIFEST
+      expect(catalog.resource(:notify, "blah")['message']).to eq('aaaxxbbb')
     end
 
     it 'should be able to add multiple defines' do

data/spec/unit/parser/functions/require_spec.rb

@@ -18,7 +18,7 @@ describe "the require function" do
 
     @scope.stubs(:findresource)
     @klass = stub 'class', :name => "myclass"
-    @scope.stubs(:find_hostclass).returns(@klass)
+    @scope.environment.known_resource_types.stubs(:find_hostclass).returns(@klass)
 
     @resource = Puppet::Parser::Resource.new(:file, "/my/file", :scope => @scope, :source => "source")
     @scope.stubs(:resource).returns @resource
@@ -45,7 +45,7 @@ describe "the require function" do
   it "should lookup the absolute class path" do
     @scope.compiler.stubs(:evaluate_classes)
 
-    @scope.expects(:find_hostclass).with("::myclass").returns(@klass)
+    @scope.environment.known_resource_types.expects(:find_hostclass).with("::myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
     @scope.function_require(["myclass"])

data/spec/unit/parser/resource_spec.rb

@@ -54,10 +54,6 @@ describe Puppet::Parser::Resource do
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => scope).environment).to eq("foo")
   end
 
-  it "should use the resource type collection helper module" do
-    expect(Puppet::Parser::Resource.ancestors).to be_include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   it "should use the scope's environment as its environment" do
     @scope.expects(:environment).returns("myenv").at_least_once
     expect(Puppet::Parser::Resource.new("file", "whatever", :scope => @scope).environment).to eq("myenv")
@@ -157,7 +153,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should add an edge to any specified stage for class resources" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       other_stage = Puppet::Parser::Resource.new(:stage, "other", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, other_stage)
@@ -171,7 +167,7 @@ describe Puppet::Parser::Resource do
     end
 
     it "should fail if an unknown stage is specified" do
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
 
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'other'
@@ -183,7 +179,7 @@ describe Puppet::Parser::Resource do
       main      = @compiler.catalog.resource(:stage, :main)
       foo_stage = Puppet::Parser::Resource.new(:stage, :foo_stage, :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, foo_stage)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       resource[:stage] = 'foo_stage'
       @compiler.add_resource(@scope, resource)
@@ -200,6 +196,16 @@ describe Puppet::Parser::Resource do
       expect(edges).to include(['Class[main]', 'Notify[hello]'])
     end
 
+    it 'should evaluate class in the same file without include' do
+      Puppet[:code] = <<-MANIFEST
+        class a($myvar = 'hello') {}
+        class { 'a': myvar => 'goodbye' }
+        notify { $a::myvar: }
+      MANIFEST
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+      expect(catalog.resource('Notify[goodbye]')).to be_a(Puppet::Resource)
+    end
+
     it "should allow edges to propagate multiple levels down the scope hierarchy" do
       Puppet[:code] = <<-MANIFEST
         stage { before: before => Stage[main] }
@@ -246,7 +252,7 @@ describe Puppet::Parser::Resource do
 
     it "should add edges from top-level class resources to the main stage if no stage is specified" do
       main = @compiler.catalog.resource(:stage, :main)
-      @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
+      @compiler.environment.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", {})
       resource = Puppet::Parser::Resource.new(:class, "foo", :scope => @scope, :catalog => @catalog)
       @compiler.add_resource(@scope, resource)
 
@@ -258,9 +264,6 @@ describe Puppet::Parser::Resource do
 
   describe "when finishing" do
     before do
-      @class = newclass "myclass"
-      @nodedef = newnode("mynode")
-
       @resource = Puppet::Parser::Resource.new("file", "whatever", :scope => @scope, :source => @source)
     end
 
@@ -295,6 +298,13 @@ describe Puppet::Parser::Resource do
 
       expect(@resource[:owner]).to eq("other")
     end
+
+    it "converts parameters with Sensitive values to unwrapped values and metadata" do
+      @resource[:content] = Puppet::Pops::Types::PSensitiveType::Sensitive.new("hunter2")
+      @resource.finish
+      expect(@resource[:content]).to eq "hunter2"
+      expect(@resource.sensitive_parameters).to eq [:content]
+    end
   end
 
   describe "when being tagged" do

data/spec/unit/parser/scope_spec.rb

@@ -91,10 +91,6 @@ describe Puppet::Parser::Scope do
     }.to raise_error(Puppet::DevError, /you must pass a compiler instance/)
   end
 
-  it "should use the resource type collection helper to find its known resource types" do
-    expect(Puppet::Parser::Scope.ancestors).to include(Puppet::Resource::TypeCollectionHelper)
-  end
-
   describe "when custom functions are called" do
     let(:env) { Puppet::Node::Environment.create(:testing, []) }
     let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => env)) }
@@ -230,7 +226,7 @@ describe Puppet::Parser::Scope do
 
     describe "and the variable is qualified" do
       before :each do
-        @known_resource_types = @scope.known_resource_types
+        @known_resource_types = @scope.environment.known_resource_types
 
         node      = Puppet::Node.new('localhost')
         @compiler = Puppet::Parser::Compiler.new(node)

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)