puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

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

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'loaders' do
+  include PuppetSpec::Files
+
+  let(:module_without_metadata) { File.join(config_dir('wo_metadata_module'), 'modules') }
+  let(:module_with_metadata) { File.join(config_dir('single_module'), 'modules') }
+  let(:dependent_modules_with_metadata) { config_dir('dependent_modules_with_metadata') }
+  let(:empty_test_env) { environment_for() }
+
+  # Loaders caches the puppet_system_loader, must reset between tests
+  before(:each) { Puppet::Pops::Loaders.clear() }
+
+  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)
+  end
+
+  it 'creates an environment loader' 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.private_environment_loader()).to be_a(Puppet::Pops::Loader::DependencyLoader)
+    expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
+  end
+
+  it 'can load 3x system functions' do
+    Puppet[:biff] = true
+    loaders = Puppet::Pops::Loaders.new(empty_test_env)
+    puppet_loader = loaders.puppet_system_loader()
+
+    function = puppet_loader.load_typed(typed_name(:function, 'sprintf')).value
+
+    expect(function.class.name).to eq('sprintf')
+    expect(function).to be_a(Puppet::Functions::Function)
+  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')
+
+    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
+
+  it 'can load a function with a qualified name from module without metadata' 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 '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
+
+  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)
+
+    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("I am modulea::rb_func_a() + I am moduleb::rb_func_b()")
+  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)
+
+    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()")
+  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)
+  end
+
+  def config_dir(config_name)
+    my_fixture(config_name)
+  end
+end

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

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'FileBased module loader' do
+  include PuppetSpec::Files
+
+  let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
+  let(:loaders) { Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, [])) }
+
+  it 'can load a 4x function API ruby function in global name space' do
+    module_dir = dir_containing('testmodule', {
+      'lib' => {
+        'puppet' => {
+          'functions' => {
+            'foo4x.rb' => <<-CODE
+               Puppet::Functions.create_function(:foo4x) do
+                 def foo4x()
+                   'yay'
+                 end
+               end
+            CODE
+          }
+            }
+          }
+        })
+
+    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+    function = module_loader.load_typed(typed_name(:function, 'foo4x')).value
+
+    expect(function.class.name).to eq('foo4x')
+    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+  end
+
+  it 'can load a 4x function API ruby function in qualified name space' do
+    module_dir = dir_containing('testmodule', {
+      'lib' => {
+        'puppet' => {
+          'functions' => {
+            'testmodule' => {
+              'foo4x.rb' => <<-CODE
+                 Puppet::Functions.create_function('testmodule::foo4x') do
+                   def foo4x()
+                     'yay'
+                   end
+                 end
+              CODE
+              }
+            }
+          }
+      }})
+
+    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+    function = module_loader.load_typed(typed_name(:function, 'testmodule::foo4x')).value
+    expect(function.class.name).to eq('testmodule::foo4x')
+    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+  end
+
+  it 'makes parent loader win over entries in child' do
+    module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => <<-CODE
+           Puppet::Functions.create_function('testmodule::foo') do
+             def foo()
+               'yay'
+             end
+           end
+        CODE
+      }}}}})
+    module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+
+    module_dir2 = dir_containing('testmodule2', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule2' => {
+        'foo.rb' => <<-CODE
+           raise "should not get here"
+        CODE
+      }}}}})
+    module_loader2 = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(module_loader, loaders, 'testmodule2', module_dir2, 'test2')
+
+    function = module_loader2.load_typed(typed_name(:function, 'testmodule::foo')).value
+
+    expect(function.class.name).to eq('testmodule::foo')
+    expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+  end
+
+  context 'when delegating 3x to 4x' do
+    before(:each) { Puppet[:biff] = true }
+
+    it 'can load a 3x function API ruby function in global name space' do
+      module_dir = dir_containing('testmodule', {
+        'lib' => {
+          'puppet' => {
+            'parser' => {
+              'functions' => {
+                'foo3x.rb' => <<-CODE
+                  Puppet::Parser::Functions::newfunction(
+                    :foo3x, :type => :rvalue,
+                    :arity => 1
+                  ) do |args|
+                    args[0]
+                  end
+                CODE
+              }
+              }
+            }
+        }})
+
+     module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+     function = module_loader.load_typed(typed_name(:function, 'foo3x')).value
+     expect(function.class.name).to eq('foo3x')
+     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+    end
+  end
+
+  def typed_name(type, name)
+    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+  end
+end

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

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'the static loader' do
+  it 'has no parent' do
+    expect(Puppet::Pops::Loader::StaticLoader.new.parent).to be(nil)
+  end
+
+  it 'identifies itself in string form' do
+    expect(Puppet::Pops::Loader::StaticLoader.new.to_s).to be_eql('(StaticLoader)')
+  end
+
+  it 'support the Loader API' do
+    # it may produce things later, this is just to test that calls work as they should - now all lookups are nil.
+    loader = Puppet::Pops::Loader::StaticLoader.new()
+    a_typed_name = typed_name(:function, 'foo')
+    expect(loader[a_typed_name]).to be(nil)
+    expect(loader.load_typed(a_typed_name)).to be(nil)
+    expect(loader.find(a_typed_name)).to be(nil)
+  end
+
+  context 'provides access to logging functions' 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)
+      end
+
+      it 'and #{level.to_s} can be called' do
+        expect(loader.load(:function, level).call({}, 'yay').to_s).to eql('yay')
+      end
+
+      it "uses the evaluator to format output" do
+        expect(loader.load(:function, level).call({}, ['yay', 'surprise']).to_s).to eql('[yay, surprise]')
+      end
+    end
+  end
+
+  def typed_name(type, name)
+    Puppet::Pops::Loader::Loader::TypedName.new(type, name)
+  end
+end

data/spec/unit/pops/types/type_calculator_spec.rb

@@ -23,6 +23,21 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.string(*strings)
   end
 
+  def callable_t(*params)
+    Puppet::Pops::Types::TypeFactory.callable(*params)
+  end
+  def all_callables_t(*params)
+    Puppet::Pops::Types::TypeFactory.all_callables()
+  end
+
+  def with_block_t(callable_t, *params)
+    Puppet::Pops::Types::TypeFactory.with_block(callable_t, *params)
+  end
+
+  def with_optional_block_t(callable_t, *params)
+    Puppet::Pops::Types::TypeFactory.with_optional_block(callable_t, *params)
+  end
+
   def enum_t(*strings)
     Puppet::Pops::Types::TypeFactory.enum(*strings)
   end
@@ -63,6 +78,10 @@ describe 'The type calculator' do
     Puppet::Pops::Types::TypeFactory.struct(type_hash)
   end
 
+  def optional_object_t
+    Puppet::Pops::Types::TypeFactory.optional_object()
+  end
+
   def types
     Puppet::Pops::Types
   end
@@ -91,6 +110,7 @@ describe 'The type calculator' do
         Puppet::Pops::Types::PVariantType,
         Puppet::Pops::Types::PStructType,
         Puppet::Pops::Types::PTupleType,
+        Puppet::Pops::Types::PCallableType,
       ]
     end
 
@@ -426,6 +446,46 @@ describe 'The type calculator' do
       common_t.class.should == Puppet::Pops::Types::PVariantType
       Set.new(common_t.types).should  == Set.new([a_t1, a_t2])
     end
+
+    context "of callables" do
+      it 'incompatible instances => generic callable' do
+        t1 = callable_t(String)
+        t2 = callable_t(Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(common_t.param_types).to be_nil
+        expect(common_t.block_type).to be_nil
+      end
+
+      it 'compatible instances => the least specific' do
+        t1 = callable_t(String)
+        scalar_t = Puppet::Pops::Types::PScalarType.new
+        t2 = callable_t(scalar_t)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(common_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(common_t.param_types.types).to eql([scalar_t])
+        expect(common_t.block_type).to be_nil
+      end
+
+      it 'block_type is included in the check (incompatible block)' do
+        t1 = with_block_t(callable_t(String), String)
+        t2 = with_block_t(callable_t(String), Integer)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.class).to be(Puppet::Pops::Types::PCallableType)
+        expect(common_t.param_types).to be_nil
+        expect(common_t.block_type).to be_nil
+      end
+
+      it 'block_type is included in the check (compatible block)' do
+        t1 = with_block_t(callable_t(String), String)
+        scalar_t = Puppet::Pops::Types::PScalarType.new
+        t2 = with_block_t(callable_t(String), scalar_t)
+        common_t = calculator.common_type(t1, t2)
+        expect(common_t.param_types.class).to be(Puppet::Pops::Types::PTupleType)
+        expect(common_t.block_type).to eql(callable_t(scalar_t))
+      end
+    end
   end
 
   context 'computes assignability' do
@@ -613,6 +673,16 @@ describe 'The type calculator' do
       end
     end
 
+    context "for Callable, such that" do
+      it "Callable is not assignable to any disjunct type" do
+        t = Puppet::Pops::Types::PCallableType.new()
+        tested_types = all_types - [
+          Puppet::Pops::Types::PCallableType,
+          Puppet::Pops::Types::PObjectType]
+        tested_types.each {|t2| t.should_not be_assignable_to(t2.new) }
+      end
+    end
+
     it 'should recognize mapped ruby types' do
       { Integer    => Puppet::Pops::Types::PIntegerType.new,
         Fixnum     => Puppet::Pops::Types::PIntegerType.new,
@@ -1040,6 +1110,38 @@ describe 'The type calculator' do
         calculator.instance?(data_t, [1, nil, 'a']).should == true
       end
     end
+
+    context "and t is something Callable" do
+
+      it 'a Closure should be considered a Callable' do
+        factory = Puppet::Pops::Model::Factory
+        params = [factory.PARAM('a')]
+        the_block = factory.LAMBDA(params,factory.literal(42))
+        the_closure = Puppet::Pops::Evaluator::Closure.new(:fake_evaluator, the_block, :fake_scope)
+        expect(calculator.instance?(all_callables_t, the_closure)).to be_true
+        # TODO: lambdas are currently unttypes, anything can be given if arg count is correct
+        expect(calculator.instance?(callable_t(optional_object_t), the_closure)).to be_true
+        # Arg count is wrong
+        expect(calculator.instance?(callable_t(optional_object_t, optional_object_t), the_closure)).to be_false
+      end
+
+      it 'a Function instance should be considered a Callable' do
+        fc = Puppet::Functions.create_function(:foo) do
+          dispatch :foo do
+            param 'String', 'a'
+          end
+
+          def foo(a)
+            a
+          end
+        end
+        f = fc.new(:closure_scope, :loader)
+        # Any callable
+        expect(calculator.instance?(all_callables_t, f)).to be_true
+        # Callable[String]
+        expect(calculator.instance?(callable_t(String), f)).to be_true
+      end
+    end
   end
 
   context 'when converting a ruby class' do
@@ -1282,6 +1384,33 @@ describe 'The type calculator' do
       t = variant_t(t1, t2, t3)
       calculator.string(t).should == "Variant[String, Integer, Pattern[/a/]]"
     end
+
+    it "should yield 'Callable' for generic callable" do
+      expect(calculator.string(all_callables_t)).to eql("Callable")
+    end
+
+    it "should yield 'Callable[0,0]' for callable without params" do
+      expect(calculator.string(callable_t)).to eql("Callable[0, 0]")
+    end
+
+    it "should yield 'Callable[t,t]' for callable with typed parameters" do
+      expect(calculator.string(callable_t(String, Integer))).to eql("Callable[String, Integer]")
+    end
+
+    it "should yield 'Callable[t,min.max]' for callable with size constraint (infinite max)" do
+      expect(calculator.string(callable_t(String, 0))).to eql("Callable[String, 0, default]")
+    end
+
+    it "should yield 'Callable[t,min.max]' for callable with size constraint (capped max)" do
+      expect(calculator.string(callable_t(String, 0, 3))).to eql("Callable[String, 0, 3]")
+    end
+
+    it "should yield 'Callable[Callable]' for callable with block" do
+      expect(calculator.string(callable_t(all_callables_t))).to eql("Callable[0, 0, Callable]")
+      expect(calculator.string(callable_t(string_t, all_callables_t))).to eql("Callable[String, Callable]")
+      expect(calculator.string(callable_t(string_t, 1,1, all_callables_t))).to eql("Callable[String, 1, 1, Callable]")
+    end
+
   end
 
   context 'when processing meta type' do
@@ -1306,6 +1435,8 @@ describe 'The type calculator' do
       calculator.infer(Puppet::Pops::Types::PPatternType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PVariantType.new()   ).is_a?(ptype).should() == true
       calculator.infer(Puppet::Pops::Types::PTupleType.new()     ).is_a?(ptype).should() == true
+      calculator.infer(Puppet::Pops::Types::POptionalType.new()  ).is_a?(ptype).should() == true
+      calculator.infer(Puppet::Pops::Types::PCallableType.new()  ).is_a?(ptype).should() == true
     end
 
     it 'should infer PType as the type of all other types' do
@@ -1329,6 +1460,8 @@ describe 'The type calculator' do
       calculator.string(calculator.infer(Puppet::Pops::Types::PVariantType.new()   )).should == "Type[Variant]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PPatternType.new()   )).should == "Type[Pattern]"
       calculator.string(calculator.infer(Puppet::Pops::Types::PTupleType.new()     )).should == "Type[Tuple]"
+      calculator.string(calculator.infer(Puppet::Pops::Types::POptionalType.new()  )).should == "Type[Optional]"
+      calculator.string(calculator.infer(Puppet::Pops::Types::PCallableType.new()  )).should == "Type[Callable]"
     end
 
     it "computes the common type of PType's type parameter" do
@@ -1431,21 +1564,23 @@ describe 'The type calculator' do
     it "does not reduce by combining types when using infer_set" do
       element_type = calculator.infer(['a','b',1,2]).element_type
       element_type.class.should == Puppet::Pops::Types::PScalarType
-      element_type = calculator.infer_set(['a','b',1,2]).element_type
-      element_type.class.should == Puppet::Pops::Types::PVariantType
-      element_type.types[0].class.should == Puppet::Pops::Types::PStringType
-      element_type.types[1].class.should == Puppet::Pops::Types::PStringType
-      element_type.types[2].class.should == Puppet::Pops::Types::PIntegerType
-      element_type.types[3].class.should == Puppet::Pops::Types::PIntegerType
+      inferred_type = calculator.infer_set(['a','b',1,2])
+      inferred_type.class.should == Puppet::Pops::Types::PTupleType
+      element_types = inferred_type.types
+      element_types[0].class.should == Puppet::Pops::Types::PStringType
+      element_types[1].class.should == Puppet::Pops::Types::PStringType
+      element_types[2].class.should == Puppet::Pops::Types::PIntegerType
+      element_types[3].class.should == Puppet::Pops::Types::PIntegerType
     end
 
     it "does not reduce by combining types when using infer_set and values are undef" do
       element_type = calculator.infer(['a',nil]).element_type
       element_type.class.should == Puppet::Pops::Types::PStringType
-      element_type = calculator.infer_set(['a',nil]).element_type
-      element_type.class.should == Puppet::Pops::Types::PVariantType
-      element_type.types[0].class.should == Puppet::Pops::Types::PStringType
-      element_type.types[1].class.should == Puppet::Pops::Types::PNilType
+      inferred_type = calculator.infer_set(['a',nil])
+      inferred_type.class.should == Puppet::Pops::Types::PTupleType
+      element_types = inferred_type.types
+      element_types[0].class.should == Puppet::Pops::Types::PStringType
+      element_types[1].class.should == Puppet::Pops::Types::PNilType
     end
   end