puppet 4.1.0 → 4.10.0

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

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/compiler'
 
 require 'puppet/pops'
 require 'puppet/loaders'
@@ -14,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'])
@@ -25,17 +26,59 @@ end
 
 describe 'loaders' do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
   let(:module_without_lib) { File.join(config_dir('module_no_lib'), 'modules') }
   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(:usee_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/usee/metadata.json') }
+  let(:usee2_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/usee2/metadata.json') }
+
   let(:empty_test_env) { environment_for() }
 
   # 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(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:loader) { Puppet::Pops::Loaders.loaders.find_loader(nil) }
+    around(:each) do |example|
+      Puppet.override(:environments => environments) do
+        Puppet.override(:loaders => compiler.loaders) 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)
@@ -47,7 +90,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
@@ -103,7 +146,11 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+
+      env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -116,13 +163,146 @@ describe 'loaders' do
   end
 
   context 'when loading from a module with metadata' do
+    let(:env) { environment_for(File.join(dependent_modules_with_metadata, 'modules')) }
+    let(:scope) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)).newscope(nil) }
+
+    let(:environmentpath) { my_fixture_dir }
+    let(:node) { Puppet::Node.new('test', :facts => Puppet::Node::Facts.new('facts', {}), :environment => 'dependent_modules_with_metadata') }
+    let(:compiler) { Puppet::Parser::Compiler.new(node) }
+
+    let(:user_metadata) {
+      {
+        'name' => 'test-user',
+        'author' =>  'test',
+        'description' =>  '',
+        'license' =>  '',
+        'source' =>  '',
+        'version' =>  '1.0.0',
+        'dependencies' =>  []
+      }
+    }
+
+    def compile_and_get_notifications(code)
+      Puppet[:code] = code
+      catalog = block_given? ? compiler.compile { |catalog| yield(compiler.topscope); catalog } : compiler.compile
+      catalog.resources.map(&:ref).select { |r| r.start_with?('Notify[') }.map { |r| r[7..-2] }
+    end
+
+    around(:each) do |example|
+      # Initialize settings to get a full compile as close as possible to a real
+      # environment load
+      Puppet.settings.initialize_global_settings
+
+      # Initialize loaders based on the environmentpath. It does not work to
+      # just set the setting environmentpath for some reason - this achieves the same:
+      # - first a loader is created, loading directory environments from the fixture (there is
+      # one environment, 'sample', which will be loaded since the node references this
+      # environment by name).
+      # - secondly, the created env loader is set as 'environments' in the puppet context.
+      #
+      environments = Puppet::Environments::Directories.new(environmentpath, [])
+      Puppet.override(:environments => environments) do
+        example.run
+      end
+    end
+
     it 'all dependent modules are visible' do
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
       function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
       expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller2')).value
+      expect(function.call({})).to eql("usee2::callee() was told 'passed value' + I am user::caller2()")
+    end
+
+    [ 'outside a function', 'a puppet function declared under functions', 'a puppet function declared in init.pp', 'a ruby function'].each_with_index do |from, from_idx|
+      [ {:from => from, :called => 'a puppet function declared under functions', :expects => "I'm the function usee::usee_puppet()"},
+        {:from => from, :called => 'a puppet function declared in init.pp', :expects => "I'm the function usee::usee_puppet_init()"},
+        {:from => from, :called => 'a ruby function', :expects => "I'm the function usee::usee_ruby()"} ].each_with_index do |desc, called_idx|
+        case_number = from_idx * 3 + called_idx + 1
+        it "can call #{desc[:called]} from #{desc[:from]} when dependency is present in metadata.json" do
+          File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          catalog = compiler.compile
+          resource = catalog.resource('Notify', "case_#{case_number}")
+          expect(resource).not_to be_nil
+          expect(resource['message']).to eq(desc[:expects])
+        end
+
+        it "can call #{desc[:called]} from #{desc[:from]} when no metadata is present" do
+          Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          catalog = compiler.compile
+          resource = catalog.resource('Notify', "case_#{case_number}")
+          expect(resource).not_to be_nil
+          expect(resource['message']).to eq(desc[:expects])
+        end
+
+        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
+          File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+          Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
+          expect { catalog = compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
+        end
+      end
+    end
+
+    it "a type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference an autoloaded type alias from another module when no metadata is present" do
+      Puppet::Module.any_instance.expects('has_metadata?').at_least_once.returns(false)
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(Usee::Zero, 0)
+        notice(ok)
+      CODE
+    end
+
+    it "a type can reference a type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(Usee::One, 1)
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when dependency is present in metadata.json" do
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(User::WithUseeZero, [0])
+        notice(ok)
+      CODE
+    end
+
+    it "an autoloaded type can reference an autoloaded type alias from another module when other module has it declared in init.pp" do
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'} ]).to_pson
+      File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(User::WithUseeOne, [1])
+        notice(ok)
+      CODE
     end
   end
 
@@ -149,53 +329,169 @@ 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) }
-    let(:loader) { Puppet::Pops::Loaders.new(env).private_loader_for_module('user') }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:scope) { compiler.topscope }
+    let(:loader) { compiler.loaders.private_loader_for_module('user') }
 
-    it 'a 3x function in dependent module can be called from a 4x function' do
-      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
-        function = loader.load_typed(typed_name(:function, 'user::caller')).value
-        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
+    around(:each) do |example|
+      Puppet.override(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders) do
+        example.run
       end
     end
 
+    it 'a 3x function in dependent module can be called from a 4x function' do
+      function = loader.load_typed(typed_name(:function, 'user::caller')).value
+      expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
+    end
+
     it 'a 3x function in dependent module can be called from a puppet function' do
-      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
-        function = loader.load_typed(typed_name(:function, 'user::puppetcaller')).value
-        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
-      end
+      function = loader.load_typed(typed_name(:function, 'user::puppetcaller')).value
+      expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
     end
 
     it 'a 4x function can be called from a puppet function' do
-      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
-        function = loader.load_typed(typed_name(:function, 'user::puppetcaller4')).value
-        expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
-      end
+      function = loader.load_typed(typed_name(:function, 'user::puppetcaller4')).value
+      expect(function.call(scope)).to eql("usee::callee() got 'first' - usee::callee() got 'second'")
     end
+
     it 'a puppet function can be called from a 4x function' do
-      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
-        function = loader.load_typed(typed_name(:function, 'user::callingpuppet')).value
-        expect(function.call(scope)).to eql("Did you call to say you love me?")
-      end
+      function = loader.load_typed(typed_name(:function, 'user::callingpuppet')).value
+      expect(function.call(scope)).to eql("Did you call to say you love me?")
     end
 
     it 'a 3x function can be called with caller scope propagated from a 4x function' do
-      Puppet.override({ :current_environment => scope.environment, :global_scope => scope }) do
-        function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
-        expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
-      end
+      function = loader.load_typed(typed_name(:function, 'user::caller_ws')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'passed in scope'")
     end
   end
 
+  context 'loading types' do
+    let(:env_name) { 'testenv' }
+    let(:environments_dir) { Puppet[:environmentpath] }
+    let(:env_dir) { File.join(environments_dir, env_name) }
+    let(:env) { Puppet::Node::Environment.create(env_name.to_sym, [File.join(populated_env_dir, 'modules')]) }
+    let(:metadata_json) {
+      <<-JSON
+      {
+        "name": "example/%1$s",
+        "version": "0.0.2",
+        "source": "git@github.com/example/example-%1$s.git",
+        "dependencies": [],
+        "author": "Bob the Builder",
+        "license": "Apache-2.0"%2$s
+      }
+      JSON
+    }
+
+    let(:env_dir_files) do
+      {
+        'modules' => {
+          'a' => {
+            'manifests' => {
+              'init.pp' => 'class a { notice(A::A) }'
+            },
+            'types' => {
+              'a.pp' => 'type A::A = Variant[B::B, String]',
+              'n.pp' => 'type A::N = C::C'
+            },
+            'metadata.json' => sprintf(metadata_json, 'a', ', "dependencies": [{ "name": "example/b" }]')
+          },
+          'b' => {
+            'types' => {
+              'b.pp' => 'type B::B = Variant[C::C, Float]',
+              'x.pp' => 'type B::X = A::A'
+            },
+            'metadata.json' => sprintf(metadata_json, 'b', ', "dependencies": [{ "name": "example/c" }]')
+          },
+          'c' => {
+            'types' => {
+              'c.pp' => 'type C::C = Integer'
+            },
+            'metadata.json' => sprintf(metadata_json, 'c', '')
+          },
+        }
+      }
+    end
+
+    let(:populated_env_dir) do
+      dir_contained_in(environments_dir, env_name => env_dir_files)
+      PuppetSpec::Files.record_tmp(env_dir)
+      env_dir
+    end
+
+    before(:each) do
+      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
+    end
+
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    it 'resolves types using the loader that loaded the type a -> b -> c' do
+      type = Puppet::Pops::Types::TypeParser.singleton.parse('A::A', Puppet::Pops::Loaders.find_loader('a'))
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eql('A::A')
+      type = type.resolved_type
+      expect(type).to be_a(Puppet::Pops::Types::PVariantType)
+      type = type.types[0]
+      expect(type.name).to eql('B::B')
+      type = type.resolved_type
+      expect(type).to be_a(Puppet::Pops::Types::PVariantType)
+      type = type.types[0]
+      expect(type.name).to eql('C::C')
+      type = type.resolved_type
+      expect(type).to be_a(Puppet::Pops::Types::PIntegerType)
+    end
+
+    it 'will not resolve implicit transitive dependencies, a -> c' do
+      type = Puppet::Pops::Types::TypeParser.singleton.parse('A::N', Puppet::Pops::Loaders.find_loader('a'))
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eql('A::N')
+      type = type.resolved_type
+      expect(type).to be_a(Puppet::Pops::Types::PTypeReferenceType)
+      expect(type.type_string).to eql('C::C')
+    end
+
+    it 'will not resolve reverse dependencies, b -> a' do
+      type = Puppet::Pops::Types::TypeParser.singleton.parse('B::X', Puppet::Pops::Loaders.find_loader('b'))
+      expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+      expect(type.name).to eql('B::X')
+      type = type.resolved_type
+      expect(type).to be_a(Puppet::Pops::Types::PTypeReferenceType)
+      expect(type.type_string).to eql('A::A')
+    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

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/pops'
 require 'puppet/loaders'
+require 'puppet_spec/compiler'
 
 describe 'FileBased module loader' do
   include PuppetSpec::Files
@@ -58,7 +59,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 +91,66 @@ 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
+
+  context 'module function and class using a module type alias' do
+    include PuppetSpec::Compiler
+
+    let(:modules) do
+      {
+        'mod' => {
+          'functions' => {
+            'afunc.pp' => <<-PUPPET.unindent
+              function mod::afunc(Mod::Analias $v) {
+                notice($v)
+              }
+          PUPPET
+          },
+          'types' => {
+            'analias.pp' => <<-PUPPET.unindent
+               type Mod::Analias = Enum[a,b]
+               PUPPET
+          },
+          'manifests' => {
+            'init.pp' => <<-PUPPET.unindent
+              class mod(Mod::Analias $v) {
+                notify { $v: }
+              }
+              PUPPET
+          }
+        }
+      }
+    end
+
+    let(:testing_env) do
+      {
+        'testing' => {
+          'modules' => modules
+        }
+      }
+    end
+
+    let(:environments_dir) { Puppet[:environmentpath] }
+
+    let(:testing_env_dir) do
+      dir_contained_in(environments_dir, testing_env)
+      env_dir = File.join(environments_dir, 'testing')
+      PuppetSpec::Files.record_tmp(env_dir)
+      env_dir
+    end
+
+    let(:env) { Puppet::Node::Environment.create(:testing, [File.join(testing_env_dir, 'modules')]) }
+    let(:node) { Puppet::Node.new('test', :environment => env) }
+
+    # The call to mod:afunc will load the function, and as a consequence, make an attempt to load
+    # the parameter type Mod::Analias. That load in turn, will trigger the Runtime3TypeLoader which
+    # will load the manifests in Mod. The init.pp manifest also references the Mod::Analias parameter
+    # which results in a recursive call to the same loader. This test asserts that this recursive
+    # call is handled OK.
+    # See PUP-7391 for more info.
+    it 'should handle a recursive load' do
+      expect(eval_and_collect_notices("mod::afunc('b')", node)).to eql(['b'])
+    end
   end
 end

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

@@ -20,33 +20,98 @@ describe 'the static loader' do
     expect(loader.find(a_typed_name)).to be(nil)
   end
 
-  context 'provides access to logging functions' do
+  context 'provides access to resource types built into puppet' do
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
-    # Ensure all logging functions produce output
-    before(:each) { Puppet::Util::Log.level = :debug }
 
-    Puppet::Util::Log.levels.each do |level|
-      it "defines the function #{level.to_s}" do
-        expect(loader.load(:function, level).class.name).to eql(level.to_s)
+    %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.each do |name |
+      it "such that #{name} is available" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
       end
+    end
+  end
 
-      it 'and #{level.to_s} can be called' do
-        expect(loader.load(:function, level).call({}, 'yay').to_s).to eql('yay')
-      end
+  context 'provides access to app-management specific resource types built into puppet' do
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
 
-      it "uses the evaluator to format output" do
-        expect(loader.load(:function, level).call({}, ['yay', 'surprise']).to_s).to eql('[yay, surprise]')
-      end
+    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
-      it 'outputs name of source (scope) by passing it to the Log utility' do
-        the_scope = {}
-        Puppet::Util::Log.any_instance.expects(:source=).with(the_scope)
-        loader.load(:function, level).call(the_scope, 'x')
+    %w{Node}.each do |name|
+      it "such that #{name} is avaiable" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
       end
     end
   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)
+    Puppet::Pops::Types::TypeFactory.resource(name)
   end
-end
+
+  matcher :be_the_type do |type|
+    calc = Puppet::Pops::Types::TypeCalculator.new
+
+    match do |actual|
+      calc.assignable?(actual, type) && calc.assignable?(type, actual)
+    end
+
+    failure_message do |actual|
+      "expected #{type.to_s}, but was #{actual.to_s}"
+    end
+  end
+
+end