puppet 4.0.0 → 4.5.0

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

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/pops'
+require 'puppet/pops/types/type_factory'
+
+describe 'when converting to 3.x' do
+  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 = Puppet::Pops::Evaluator::Runtime3Converter.instance.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 = Puppet::Pops::Evaluator::Runtime3Converter.instance.catalog_type_to_split_type_title(t)
+    expect(converted).to eql(['class', 'kermit'])
+  end
+
+  it "errors on attempts to convert an 'Iterator'" do
+    expect {
+      Puppet::Pops::Evaluator::Runtime3Converter.convert(Puppet::Pops::Types::Iterable.on((1..3)), {}, nil)
+    }.to raise_error(Puppet::Error, /Use of an Iterator is not supported here/)
+  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

@@ -53,6 +53,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)

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'
@@ -25,11 +26,15 @@ 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(:user_metadata_path) { File.join(dependent_modules_with_metadata, 'modules/user/metadata.json') }
+
   let(:empty_test_env) { environment_for() }
 
   # Loaders caches the puppet_system_loader, must reset between tests
@@ -49,70 +54,259 @@ describe 'loaders' do
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
   end
 
-  it 'can load a function using a qualified or unqualified name from a module with metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
-    modulea_loader = loaders.public_loader_for_module('modulea')
+  context 'when loading from a module' do
+    it 'loads a ruby function using a qualified or unqualified name' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    unqualified_function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
-    qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
+      unqualified_function = modulea_loader.load_typed(typed_name(:function, 'rb_func_a')).value
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::rb_func_a')).value
 
-    expect(unqualified_function).to be_a(Puppet::Functions::Function)
-    expect(qualified_function).to be_a(Puppet::Functions::Function)
-    expect(unqualified_function.class.name).to eq('rb_func_a')
-    expect(qualified_function.class.name).to eq('modulea::rb_func_a')
-  end
+      expect(unqualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(unqualified_function.class.name).to eq('rb_func_a')
+      expect(qualified_function.class.name).to eq('modulea::rb_func_a')
+    end
 
-  it 'can load a function with a qualified name from module without metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+    it 'loads a puppet function using a qualified name in module' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
 
-    moduleb_loader = loaders.public_loader_for_module('moduleb')
-    function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::hello')).value
 
-    expect(function).to be_a(Puppet::Functions::Function)
-    expect(function.class.name).to eq('moduleb::rb_func_b')
-  end
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::hello')
+    end
+
+    it 'loads a puppet function from a module without a lib directory' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_lib))
+      modulea_loader = loaders.public_loader_for_module('modulea')
+
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::hello')).value
+
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::hello')
+    end
+
+    it 'loads a puppet function in a sub namespace of module' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
+      modulea_loader = loaders.public_loader_for_module('modulea')
+
+      qualified_function = modulea_loader.load_typed(typed_name(:function, 'modulea::subspace::hello')).value
+
+      expect(qualified_function).to be_a(Puppet::Functions::Function)
+      expect(qualified_function.class.name).to eq('modulea::subspace::hello')
+    end
+
+    it 'loader does not add namespace if not given' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
 
-  it 'cannot load an unqualified function from a module without metadata' do
-    loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+      moduleb_loader = loaders.public_loader_for_module('moduleb')
+
+      expect(moduleb_loader.load_typed(typed_name(:function, 'rb_func_b'))).to be_nil
+    end
 
-    moduleb_loader = loaders.public_loader_for_module('moduleb')
+    it 'loader allows loading a function more than once' do
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns ''
 
-    expect(moduleb_loader.load_typed(typed_name(:function, 'rb_func_b'))).to be_nil
+      env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
+      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::caller')).value
+      expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+    end
   end
 
-  it 'makes all other modules visible to a module without metadata' do
-    env = environment_for(module_with_metadata, module_without_metadata)
-    loaders = Puppet::Pops::Loaders.new(env)
+  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
+      File.stubs(:read).with(user_metadata_path, {:encoding => 'utf-8'}).returns user_metadata.merge('dependencies' => [ { 'name' => 'test-usee'}, { 'name' => 'test-usee2'} ]).to_pson
+      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
+          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 ruby function in a dependent module from outside a function 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/)
+        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
+      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
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(Usee::One, 1)
+        notice(ok)
+      CODE
+    end
 
-    moduleb_loader = loaders.private_loader_for_module('moduleb')
-    function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+    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
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        assert_type(User::WithUseeZero, [0])
+        notice(ok)
+      CODE
+    end
 
-    expect(function.call({})).to eql("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
+    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
+      expect(eval_and_collect_notices(<<-CODE, node)).to eq(['ok'])
+        include 'usee'
+        assert_type(User::WithUseeOne, [1])
+        notice(ok)
+      CODE
+    end
   end
 
-  it 'makes dependent modules visible to a module with metadata' do
-    env = environment_for(dependent_modules_with_metadata)
-    loaders = Puppet::Pops::Loaders.new(env)
+  context 'when loading from a module without metadata' do
+    it 'loads a ruby function with a qualified name' do
+      loaders = Puppet::Pops::Loaders.new(environment_for(module_without_metadata))
+
+      moduleb_loader = loaders.public_loader_for_module('moduleb')
+      function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
+
+      expect(function).to be_a(Puppet::Functions::Function)
+      expect(function.class.name).to eq('moduleb::rb_func_b')
+    end
+
+
+    it 'all other modules are visible' do
+      env = environment_for(module_with_metadata, module_without_metadata)
+      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
+      moduleb_loader = loaders.private_loader_for_module('moduleb')
+      function = moduleb_loader.load_typed(typed_name(:function, 'moduleb::rb_func_b')).value
 
-    expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+      expect(function.call({})).to eql("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
+    end
   end
 
-  context 'with scope' do
+  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') }
 
-    it 'can call 3x function in dependent module from a 4x function' do
+    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'")
       end
     end
 
-    it 'can call 3x function and propagate caller scope from a 4x function' do
+    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
+    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
+    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
+    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'")
@@ -120,17 +314,6 @@ describe 'loaders' do
     end
   end
 
-  it 'can load a function more than once from modules' do
-    env = environment_for(dependent_modules_with_metadata)
-    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::caller')).value
-    expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
-  end
 
   def environment_for(*module_paths)
     Puppet::Node::Environment.create(:'*test*', module_paths)