puppet 4.10.1-universal-darwin → 4.10.4-universal-darwin

data/spec/unit/functions/lookup_spec.rb

@@ -2080,8 +2080,9 @@ describe "The lookup function" do
             }
           end
 
-          it 'raises an error' do
-            expect { lookup('mod_a::a') }.to raise_error(Puppet::Error, /hiera.yaml version 3 cannot be used in a module/)
+          it 'raises a warning' do
+            expect(lookup('mod_a::a')).to eql('value mod_a::a (from environment)')
+            expect(warnings).to include(/hiera.yaml version 3 found at module root was ignored/)
           end
         end
 
@@ -2946,6 +2947,121 @@ describe "The lookup function" do
 
       let(:env_data) { data_files }
 
+      context 'and a module using eyaml with different options' do
+
+        let(:private_module_key) do
+          <<-PKCS7.unindent
+          -----BEGIN RSA PRIVATE KEY-----
+          MIIEogIBAAKCAQEAuqVpctipK4OMWM+RwKcd/mR4pg6qE3+ItPVC9TlvBrmDaN/y
+          YZRjQR+XovXSGuy/CneSQ9Qss0Ff3FKAmEeH0qN0V47a81hgLpjhLCX1n+Ov7r1Q
+          DC1ciTpVzHE4krN3rJ/RmDohitIqT1IYYhdcEdaMG9E26HIzn1QIwaDiYU3mfqWM
+          8CZExa0CeIsEzHRLSxuMi/xX0ENImCRUzY9GH88Cu2gUhpKlbVzJmVqGPgp94pJY
+          YM+SUb0XP1yRySpJMnVg98oCUrQO2OoE/Gax/djAi6hrJUzejPsEKdZ1yxM6OyJW
+          NjWZYs8izAxBqm7pv1hx5+X7AIPqwZTMVrB7TQIDAQABAoIBAHIex13QOYeAlGSM
+          7bpUtBMiTV6DItxvIyA5wen8ZvU+oqmSHDorp5BfB7E9Cm0qChkVSRot9fLYawtk
+          anoxakuRY4ZRs3AMvipfkXYT854CckTP/cykQ6soPuOU6plQIEEtKtMf3/hoTjRX
+          ps77J3FEtEAh6Kexg/zMPdpeS2xgULhk0P9ZQEg+JhLA5dq0p0nz3SBkuzcxei79
+          +Za/Tg1osD0AINOajdvPnKxvlmWJN0+LpGwVjFNhkoUXPeDyvq0z2V/Uqwz4HP2I
+          UGv4tz3SbzFc3Ie4lzgUZzCQgUK3u60pq1uyA6BRtxwdEmpn5v++jGXBGJZpWwcW
+          UNblESUCgYEA4aTH9+LHsNjLPs2FmSc7hNjwHG1rAHcDXTX2ccySjRcQvH4Z7xBL
+          di+SzZ2Tf8gSLycPRgRVCbrgCODpjoV2D5wWnyUHfWm4+GQxHURYa4UDx69tsSKE
+          OTRASJo7/Mz0M1a6YzgCzVRM/TO676ucmawzKUY5OUm1oehtODAiZOcCgYEA08GM
+          AMBOznys02xREJI5nLR6AveuTbIjF2efEidoxoW+1RrMOkcqaDTrJQ5PLM+oDDwD
+          iPzVjnroSbwJzFB71atIg7b7TwltgkXy7wNTedO2cm5u/I0q8tY2Jaa4Mz8JUnbe
+          yafvtS0/mY6A5k+8/2UIMFin2rqU9NC9EUPIo6sCgYBhOvAwELibq89osIbxB8bN
+          5+0PUtbYzG/WqnoXb193DIlZr7zdFththPJtR4lXdo7fYqViNluuZahEKyZ5E2lc
+          MJZO3VXs5LGf1wyS3/B55EdMtHs/6O+w9qL8pflTZb2UobqPJoOOltTWBoR24iwI
+          y/r/vhLKbMini9AEdjlb4QKBgGdYsax4Lr4GCQ8ScSnmQ6ngRyAFo5MV2pyEnRTu
+          GOuywKUe9AeJTgAXu5+VMT0Mh9aYv5zu0Ic+IvpBhIKr0RRCCR0Hg/VaA5Et9FeE
+          RwxRMFz+2rn1Z72moDyV9pZEMJeHnknK5WmGEOEvtGczCWmX9Hwr+Jf+sc4dxfiU
+          HWsLAoGAXWSX73p/6R4eRfF5zU2UFJPvDzhmwObAuvU4zKs9x7PMxZfvyt/eBCO1
+          fj2+hIR72RxVuHbLApF1BT6gPVLtNdvaNuCs8YlHcnx/Oi088F0ni7fL/xYBUvaB
+          7wTf188UJxP1ofVMZW00P4I9mR6BrOulv455gCwsmg2X7WtJU48=
+          -----END RSA PRIVATE KEY-----
+          PKCS7
+        end
+
+        let(:public_module_key) do
+          <<-PKCS7.unindent
+          -----BEGIN CERTIFICATE-----
+          MIIC2TCCAcGgAwIBAgIBATANBgkqhkiG9w0BAQUFADAAMCAXDTE3MDUzMTE2Mjc0
+          M1oYDzIwNjcwNTE5MTYyNzQzWjAAMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
+          CgKCAQEAuqVpctipK4OMWM+RwKcd/mR4pg6qE3+ItPVC9TlvBrmDaN/yYZRjQR+X
+          ovXSGuy/CneSQ9Qss0Ff3FKAmEeH0qN0V47a81hgLpjhLCX1n+Ov7r1QDC1ciTpV
+          zHE4krN3rJ/RmDohitIqT1IYYhdcEdaMG9E26HIzn1QIwaDiYU3mfqWM8CZExa0C
+          eIsEzHRLSxuMi/xX0ENImCRUzY9GH88Cu2gUhpKlbVzJmVqGPgp94pJYYM+SUb0X
+          P1yRySpJMnVg98oCUrQO2OoE/Gax/djAi6hrJUzejPsEKdZ1yxM6OyJWNjWZYs8i
+          zAxBqm7pv1hx5+X7AIPqwZTMVrB7TQIDAQABo1wwWjAPBgNVHRMBAf8EBTADAQH/
+          MB0GA1UdDgQWBBQkhoMgOyPzEe7tOOimNH2//PYF2TAoBgNVHSMEITAfgBQkhoMg
+          OyPzEe7tOOimNH2//PYF2aEEpAIwAIIBATANBgkqhkiG9w0BAQUFAAOCAQEAhRWc
+          Nz3PcUJllao5G/v4AyvjLgwB2JgjJgh6D3ILoOe9TrDSXD7ZV3F30vFae+Eztk86
+          pmM8x57E0HsuuY+Owf6/hvELtwbzf9N/lc9ySZSogGFoQeJ8rnCJAQ0FaPjqb7AN
+          xTaY9HTzr4dZG1f+sw32RUu2fDe7Deqgf85uMSZ1mtRTt9zvo8lMQxVA2nVOfwz2
+          Nxf+qSNYSCtf0/6iwfzHy0qPjaJnywgBCi3Lg2IMSqGUatxzH+9HWrBgD+ZYxmDz
+          2gW+EIU1Y/We/tbjIWaR1PD+IzeRJi5fHq60RKHPSdp7TGtV48bQRvyZXC7sVCRa
+          yxfX1IGYhCDzbFRQNg==
+          -----END CERTIFICATE-----
+          PKCS7
+        end
+
+        let(:module_keys_dir) do
+          keys = tmpdir('keys')
+          dir_contained_in(keys, {
+            private_key_name => private_module_key,
+            public_key_name => public_module_key
+          })
+          keys
+        end
+
+        let(:private_module_key_path) { File.join(module_keys_dir, private_key_name) }
+        let(:public_module_key_path) { File.join(module_keys_dir, public_key_name) }
+
+        let(:mod_a_files) do
+          {
+            'mod_a' => {
+              'hiera.yaml' => <<-YAML.unindent,
+                version: 5
+                hierarchy:
+                  - name: EYaml
+                    path: common.eyaml
+                    lookup_key: eyaml_lookup_key
+                    options:
+                      pkcs7_private_key: #{private_module_key_path}
+                      pkcs7_public_key: #{public_module_key_path}
+                YAML
+              'data' => {
+                'common.eyaml' => <<-YAML.unindent
+                ---
+                # "%{lookup('a')} (from module)"
+                mod_a::a: >
+                  ENC[PKCS7,MIIBiQYJKoZIhvcNAQcDoIIBejCCAXYCAQAxggEhMIIBHQIBADAFMAACAQEw
+                  DQYJKoZIhvcNAQEBBQAEggEAC+lvda8mX6XkgCBstNw4IQUDyFcS6M0mS9gZ
+                  ev4VBDeUK4AUNVnzzdbW0Mnj9LbqlpzFx96VGqSxsRBpe7BVD0kVo5jQsEMn
+                  nbrWOD1lvXYrXZMXBeD9xJbMbH5EiiFhbaXcEKRAVGaLVQKjXDENDQ/On+it
+                  1+wmmVwJynDJR0lsCz6dcSKvw6wnxBcv32qFyePvJuIf04CHMhaS4ykedYHK
+                  vagUn5uVXOv/8G0JPlZnQLyxjE0v0heb0Zj0mvcP2+Y5BSW50AQVrMWJNtdW
+                  aFEg6H5hpjduQfQh3iWVuDLnWhbP0sY2Grn5dTOxQP8aTDSsiTUcSeIAmjr/
+                  K8YRCjBMBgkqhkiG9w0BBwEwHQYJYIZIAWUDBAEqBBAjL7InlBjRuohLLcBx
+                  686ogCDkhCan8bCE7aX2nr75QtLF3q89pFIR4/NGl5+oGEO+qQ==]
+                YAML
+              }
+            }
+          }
+        end
+
+        let(:populated_env_dir) do
+          dir_contained_in(env_dir, DeepMerge.deep_merge!(environment_files, env_name => { 'modules' => mod_a_files }))
+          env_dir
+        end
+
+        it 'repeatedly finds data in environment and module' do
+          expect(lookup(['array_a', 'mod_a::a', 'hash_a'])).to eql([
+            ['array_a[0]', 'array_a[1]'],
+            "Encrypted value 'a' (from environment) (from module)",
+            {'hash_aa'=>{'aaa'=>'Encrypted value hash_a.hash_aa.aaa (from environment)'}}])
+        end
+      end
+
       it 'finds data in the environment' do
         expect(lookup('a')).to eql("Encrypted value 'a' (from environment)")
       end

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

@@ -89,6 +89,15 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
     end
 
+    it 'unrealized exported resources should not be added' do
+      # a compiled catalog is normally filtered on virtual resources
+      # here the compilation is performed unfiltered to be able to find the exported resource
+      # it is then asserted that the exported resource is also virtual (and therefore filtered out by a real compilation).
+      catalog = compile_to_catalog_unfiltered("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      expect(catalog.resource(:file, "/etc/foo").exported).to eq(true)
+      expect(catalog.resource(:file, "/etc/foo").virtual).to eq(true)
+    end
+
     it 'should be able to add exported resources' do
       catalog = compile_to_catalog("create_resources('@@file', {'/etc/foo'=>{'ensure'=>'present'}}) realize(File['/etc/foo'])")
       expect(catalog.resource(:file, "/etc/foo")['ensure']).to eq('present')
@@ -232,6 +241,9 @@ describe 'function for dynamically creating resources' do
   end
 
   describe 'when creating classes' do
+    let(:logs) { [] }
+    let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+
     it 'should be able to create classes' do
       catalog = compile_to_catalog(<<-MANIFEST)
         class bar($one) {
@@ -245,12 +257,34 @@ describe 'function for dynamically creating resources' do
       expect(catalog.resource(:class, "bar")).not_to be_nil
     end
 
-    it 'should fail to create non-existing classes' do
-      expect do
-        compile_to_catalog(<<-MANIFEST)
-          create_resources('class', {'blah'=>{'one'=>'two'}})
-        MANIFEST
-      end.to raise_error(/Could not find declared class blah at line 1:11 on node test/)
+    [:off, :warning].each do | strictness |
+      it "should warn if strict = #{strictness} and class is exported" do
+        Puppet[:strict] = strictness
+        collect_notices('class test{} create_resources("@@class", {test => {}})')
+        expect(warnings).to include(/Classes are not virtualizable/)
+      end
+    end
+
+    it 'should error if strict = error and class is exported' do
+      Puppet[:strict] = :error
+      expect{
+        compile_to_catalog('class test{} create_resources("@@class", {test => {}})')
+      }.to raise_error(/Classes are not virtualizable/)
+    end
+
+    [:off, :warning].each do | strictness |
+      it "should warn if strict = #{strictness} and class is virtual" do
+        Puppet[:strict] = strictness
+        collect_notices('class test{} create_resources("@class", {test => {}})')
+        expect(warnings).to include(/Classes are not virtualizable/)
+      end
+    end
+
+    it 'should error if strict = error and class is virtual' do
+      Puppet[:strict] = :error
+      expect{
+        compile_to_catalog('class test{} create_resources("@class", {test => {}})')
+      }.to raise_error(/Classes are not virtualizable/)
     end
 
     it 'should be able to add edges' do
@@ -291,4 +325,11 @@ describe 'function for dynamically creating resources' do
       }.to raise_error(Puppet::Error, /Syntax error at.*/)
     end
   end
+
+  def collect_notices(code)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      compile_to_catalog(code)
+    end
+  end
+
 end

data/spec/unit/parser/scope_spec.rb

@@ -578,6 +578,14 @@ describe Puppet::Parser::Scope do
       @scope.unset_ephemeral_var
       expect(@scope["apple"]).to eq(nil)
     end
+
+    it 'should store an undef in local scope and let it override parent scope' do
+      @scope['cloaked'] = 'Cloak me please'
+      @scope.new_ephemeral(true)
+      @scope['cloaked'] = nil
+      expect(@scope['cloaked']).to eq(nil)
+    end
+
     it "should be created from a hash" do
       @scope.ephemeral_from({ "apple" => :fruit, "strawberry" => :berry})
       expect(@scope["apple"]).to eq(:fruit)

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

@@ -403,6 +403,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
 
     context "on strings requiring boxing to Numeric" do
+      let(:logs) { [] }
+      let(:notices) { logs.select { |log| log.level == :notice }.map { |log| log.message } }
+      let(:warnings) { logs.select { |log| log.level == :warning }.map { |log| log.message } }
+      let(:debugs) { logs.select { |log| log.level == :debug }.map { |log| log.message } }
+
       {
         "'2' + '2'"       => 4,
         "'-2' + '2'"      => 0,
@@ -426,6 +431,35 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
           end
         end
 
+      {
+        "'2' + 2"       => 2,
+        "'4' - 2"       => 4,
+        "'2' * 2"       => 2,
+        "'2' / 1"       => 2,
+        "'8' >> 1"      => 8,
+        "'4' << 1"      => 4,
+        "'10' % 3"      => 10,
+      }.each do |source, coerced_val|
+          it "should warn about numeric coercion in '#{source}' when strict = warning" do
+            Puppet[:strict] = :warning
+            collect_notices(source)
+            expect(warnings).to include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
+          end
+
+          it "should not warn about numeric coercion in '#{source}' if strict = off" do
+            Puppet[:strict] = :off
+            collect_notices(source)
+            expect(warnings).to_not include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
+          end
+
+        it "should error when finding numeric coercion in '#{source}' if strict = error" do
+          Puppet[:strict] = :error
+          expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(
+            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
+            )
+        end
+      end
+
       {
         "'0888' + '010'"   => :error,
         "'0xWTF' + '010'"  => :error,
@@ -1466,4 +1500,10 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
     end
   end
 
+  def collect_notices(code)
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      parser.evaluate_string(scope, code, __FILE__)
+    end
+  end
+
 end

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

@@ -22,6 +22,16 @@ describe 'loader helper classes' do
     expect(tn.name).to eq('foo::bar')
     expect(tn.qualified?).to be_truthy
   end
+
+  it 'TypedName converts name to lower case' do
+    tn = Puppet::Pops::Loader::TypedName.new(:type, '::Foo::Bar')
+    expect(tn.name_parts).to eq(['foo', 'bar'])
+    expect(tn.name).to eq('foo::bar')
+  end
+
+  it 'TypedName is case insensitive' do
+    expect(Puppet::Pops::Loader::TypedName.new(:type, '::Foo::Bar')).to eq(Puppet::Pops::Loader::TypedName.new(:type, '::foo::bar'))
+  end
 end
 
 describe 'loaders' do
@@ -88,7 +98,7 @@ describe 'loaders' do
     loaders = Puppet::Pops::Loaders.new(empty_test_env)
 
     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.public_environment_loader().to_s).to eql("(SimpleEnvironmentLoader 'environment')")
     expect(loaders.private_environment_loader()).to be_a(Puppet::Pops::Loader::DependencyLoader)
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment private' [])")
   end
@@ -389,53 +399,13 @@ describe 'loaders' do
     end
   end
 
-  context 'loading types' do
+  context 'loading' 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(:node) { Puppet::Node.new("test", :environment => env) }
+    let(:env_dir_files) {}
 
     let(:populated_env_dir) do
       dir_contained_in(environments_dir, env_name => env_dir_files)
@@ -443,46 +413,138 @@ describe 'loaders' do
       env_dir
     end
 
-    before(:each) do
-      Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))
-    end
+    context 'non autoloaded types and functions' do
+      let(:env_dir_files) {
+        {
+          'modules' => {
+            'tstf' => {
+              'manifests' => {
+                'init.pp' => <<-PUPPET.unindent
+                  class tstf {
+                    notice(testfunc())
+                  }
+                  PUPPET
+              }
+            },
+            'tstt' => {
+              'manifests' => {
+                'init.pp' => <<-PUPPET.unindent
+                  class tstt {
+                    notice(assert_type(GlobalType, 23))
+                  }
+                  PUPPET
+              }
+            }
+          }
+        }
+      }
 
-    after(:each) do
-      Puppet.pop_context
-    end
+      it 'finds the function from a module' do
+        expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eq(['hello from testfunc'])
+          function testfunc() {
+            'hello from testfunc'
+          }
+          include 'tstf'
+          PUPPET
+      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)
+      it 'finds the type from a module' do
+        expect(eval_and_collect_notices(<<-PUPPET.unindent, node)).to eq(['23'])
+          type GlobalType = Integer
+          include 'tstt'
+          PUPPET
+      end
     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
+    context '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
+      }
 
-    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')
+      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
+
+      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
   end