puppet 4.3.2 → 4.4.0

data/spec/unit/functions/defined_spec.rb

@@ -268,11 +268,11 @@ describe "the 'defined' function" do
   end
 
   it 'raises error if referencing undef' do
-    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\[CatalogEntry\]\], got Undef/)
+    expect{func.call(@scope, nil)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Undef/)
   end
 
   it 'raises error if referencing a number' do
-    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String, Type\[CatalogEntry\], or Type\[Type\[CatalogEntry\]\], got Integer/)
+    expect{func.call(@scope, 42)}.to raise_error(ArgumentError, /'defined' parameter 'vals' expects a value of type String or Type, got Integer/)
   end
 
   it 'is false if referencing empty string' do

data/spec/unit/functions/epp_spec.rb

@@ -5,7 +5,7 @@ describe "the epp function" do
 
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
-  let :scope    do Puppet::Parser::Scope.new(compiler) end
+  let :scope    do compiler.topscope end
 
   context "when accessing scope variables as $ variables" do
     it "looks up the value from the scope" do
@@ -27,11 +27,19 @@ describe "the epp function" do
       expect(eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos')).to eq("true")
     end
 
-    it "can use values from the enclosing scope for defaults" do
+    it "can use values from the global scope for defaults" do
       scope['phantom'] = 'of the opera'
-      expect(eval_template("<%- |$phantom = $phantom| -%><%= $phantom %>")).to eq("of the opera")
+      expect(eval_template("<%- |$phantom = $::phantom| -%><%= $phantom %>")).to eq("of the opera")
     end
 
+    it "will not use values from the enclosing scope for defaults" do
+      scope['the_phantom'] = 'of the state opera'
+      scope.new_ephemeral(true)
+      scope['the_phantom'] = 'of the local opera'
+      expect(scope['the_phantom']).to eq('of the local opera')
+      expect(eval_template("<%- |$phantom = $the_phantom| -%><%= $phantom %>")).to eq("of the state opera")
+     end
+
     it "uses the default value if the given value is undef/nil" do
       expect(eval_template_with_args("<%- |$phantom = 'inside your mind'| -%><%= $phantom %>", 'phantom' => nil)).to eq("inside your mind")
     end

data/spec/unit/functions/lookup_spec.rb

@@ -170,7 +170,7 @@ describe "when performing lookup" do
     it 'will not accept a succesful lookup of an undef value when the type rejects it' do
       expect do
         assemble_and_compile('${r}', "'abc::n'", 'String')
-      end.to raise_error(Puppet::ParseError, /found value has wrong type/)
+      end.to raise_error(Puppet::ParseError, /Found value has wrong type, expected a String value, got Undef/)
     end
 
     it 'will raise an exception when value is not found for array key and no default is provided' do
@@ -248,7 +248,8 @@ describe "when performing lookup" do
       it 'fails unless default is an instance of value_type' do
         expect do
           assemble_and_compile('${r[a]}_${r[b]}', "'abc::x'", 'Hash[String,String]', 'undef', "{'a' => 'dflt_x', 'b' => 32}")
-        end.to raise_error(Puppet::ParseError, /default_value value has wrong type/)
+        end.to raise_error(Puppet::ParseError,
+          /Default value has wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
       end
     end
 
@@ -281,7 +282,8 @@ describe "when performing lookup" do
       it 'fails unless block returns an instance of value_type' do
         expect do
           assemble_and_compile_with_block('${r[a]}_${r[b]}', "{'a' => 'dflt_x', 'b' => 32}", "'abc::x'", 'Hash[String,String]')
-        end.to raise_error(Puppet::ParseError, /default_block value has wrong type/)
+        end.to raise_error(Puppet::ParseError,
+          /Value returned from default block has wrong type, expected a Hash\[String, String\] value, got Struct\[\{'a' => String, 'b' => Integer\}\]/)
       end
 
       it 'receives a single name parameter' do
@@ -345,11 +347,28 @@ describe "when performing lookup" do
   end
 
   context 'when accessing from outside a module' do
-    it 'will raise an exception when key in the function provided module data is not prefixed' do
-      Puppet[:code] = "include bad_data\nlookup(bad_data::b)"
-      expect do
-        compiler.compile()
-      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    it 'will both log a warning and raise an exception when key in the function provided module data is not prefixed' do
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        Puppet[:code] = "include bad_data\nlookup('bad_data::b')"
+        expect { compiler.compile }.to raise_error(Puppet::ParseError, /did not find a value for the name 'bad_data::b'/)
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
+    end
+
+    it 'will succeed finding prefixed keys even when a key in the function provided module data is not prefixed' do
+      logs = []
+      resources = nil
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        resources = compile_and_get_notifications(<<-END.gsub(/^ {10}/, ''))
+          include bad_data
+          notify { lookup('bad_data::c'): }
+        END
+        expect(resources).to include('module_c')
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
     end
 
     it 'will resolve global, environment, and module correctly' do
@@ -378,14 +397,40 @@ describe "when performing lookup" do
   end
 
   context 'when accessing bad data' do
-    it 'will raise an exception when key in the function provided module data is not prefixed' do
-      Puppet[:code] = 'include bad_data'
-      expect do
-        compiler.compile()
-      end.to raise_error(Puppet::ParseError, /data for module 'bad_data' must use keys qualified with the name of the module/)
+    it 'a warning will be logged when key in the function provided module data is not prefixed' do
+      Puppet[:code] = "include bad_data\nlookup('bad_data::c')"
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        compiler.compile
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'bad_data' must use keys qualified with the name of the module")
+    end
+
+    it 'a warning will be logged when key in the hiera provided module data is not prefixed' do
+      Puppet[:code] = "include hieraprovider\nlookup('hieraprovider::test::param_a')"
+      logs = []
+      Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+        compiler.compile
+      end
+      warnings = logs.select {|log| log.level == :warning }.map {|log| log.message }
+      expect(warnings).to include("Module data for module 'hieraprovider' must use keys qualified with the name of the module")
     end
   end
 
+  context 'when accessing empty files' do
+    # An empty YAML file is OK and should be treated as a file that contains no keys
+    it "will fail normally with a 'did not find a value' error when a yaml file is empty" do
+      Puppet[:code] = "include empty_yaml\nlookup('empty_yaml::a')"
+      expect { compiler.compile }.to raise_error(Puppet::ParseError, /did not find a value for the name 'empty_yaml::a'/)
+    end
+
+    # An empty JSON file is not OK. Should yield a parse error
+    it "will fail with a LookupError indicating a parser failure when a json file is empty" do
+      Puppet[:code] = "include empty_json\nlookup('empty_json::a')"
+      expect { compiler.compile }.to raise_error(Puppet::DataBinding::LookupError, /Unable to parse/)
+    end
+  end
 
   context 'when using explain' do
     it 'will explain that module is not found' do

data/spec/unit/functions/regsubst_spec.rb

@@ -56,7 +56,7 @@ describe 'the regsubst function' do
     end
 
     it 'should raise an Error if given a flag other thant G' do
-      expect { regsubst('foo', /bar/, 'gazonk', 'I') }.to raise_error(/expected one of/)
+      expect { regsubst('foo', /bar/, 'gazonk', 'I') }.to raise_error(/expects one of/)
     end
 
     it 'should handle global substitutions' do

data/spec/unit/functions/reverse_each_spec.rb

@@ -0,0 +1,108 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the reverse_each function' do
+  include PuppetSpec::Compiler
+
+  it 'raises an error when given a type that cannot be iterated' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        3.14.reverse_each |$v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
+  end
+
+  it 'raises an error when called with more than one argument and without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].reverse_each(1)
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects 1 argument, got 2/)
+  end
+
+  it 'raises an error when called with more than one argument and a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].reverse_each(1) |$v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects 1 argument, got 2/)
+  end
+
+  it 'raises an error when called with a block with too many required parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].reverse_each() |$v1, $v2| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /block expects 1 argument, got 2/)
+  end
+
+  it 'raises an error when called with a block with too few parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].reverse_each() | | {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /block expects 1 argument, got none/)
+  end
+
+  it 'does not raise an error when called with a block with too many but optional arguments' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].reverse_each() |$v1, $v2=extra| {  }
+      MANIFEST
+    end.to_not raise_error
+  end
+
+  it 'returns an Undef when called with a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+            assert_type(Undef, [1].reverse_each |$x| { $x })
+      MANIFEST
+    end.not_to raise_error
+  end
+
+  it 'returns an Iterable when called without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+            assert_type(Iterable, [1].reverse_each)
+      MANIFEST
+    end.not_to raise_error
+  end
+
+  it 'should produce "times" interval of integer in reverse' do
+    expect(eval_and_collect_notices('5.reverse_each |$x| { notice($x) }')).to eq(['4', '3', '2', '1', '0'])
+  end
+
+  it 'should produce range Integer[5,8] in reverse' do
+    expect(eval_and_collect_notices('Integer[5,8].reverse_each |$x| { notice($x) }')).to eq(['8', '7', '6', '5'])
+  end
+
+  it 'should produce the choices of [first,second,third] in reverse' do
+    expect(eval_and_collect_notices('[first,second,third].reverse_each |$x| { notice($x) }')).to eq(%w(third second first))
+  end
+
+  it 'should produce the choices of {first => 1,second => 2,third => 3} in reverse' do
+    expect(eval_and_collect_notices('{first => 1,second => 2,third => 3}.reverse_each |$t| { notice($t[0]) }')).to eq(%w(third second first))
+  end
+
+  it 'should produce the choices of Enum[first,second,third] in reverse' do
+    expect(eval_and_collect_notices('Enum[first,second,third].reverse_each |$x| { notice($x) }')).to eq(%w(third second first))
+  end
+
+  it 'should produce nth element in reverse of range Integer[5,20] when chained after a step' do
+    expect(eval_and_collect_notices('Integer[5,20].step(4).reverse_each |$x| { notice($x) }')
+    ).to eq(['17', '13', '9', '5'])
+  end
+
+  it 'should produce nth element in reverse of times 5 when chained after a step' do
+    expect(eval_and_collect_notices('5.step(2).reverse_each |$x| { notice($x) }')).to eq(['4', '2', '0'])
+  end
+
+  it 'should produce nth element in reverse of range Integer[5,20] when chained after a step' do
+    expect(eval_and_collect_notices(
+      '[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20].step(4).reverse_each |$x| { notice($x) }')
+    ).to eq(['17', '13', '9', '5'])
+  end
+end

data/spec/unit/functions/step_spec.rb

@@ -0,0 +1,113 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'shared_behaviours/iterative_functions'
+
+describe 'the step method' do
+  include PuppetSpec::Compiler
+
+  it 'raises an error when given a type that cannot be iterated' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        3.14.step(1) |$v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects an Iterable value, got Float/)
+  end
+
+  it 'raises an error when called with more than two arguments and a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(1,2) |$v| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects 2 arguments, got 3/)
+  end
+
+  it 'raises an error when called with more than two arguments and without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(1,2)
+      MANIFEST
+    end.to raise_error(Puppet::Error, /expects 2 arguments, got 3/)
+  end
+
+  it 'raises an error when called with a block with too many required parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(1) |$v1, $v2| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /block expects 1 argument, got 2/)
+  end
+
+  it 'raises an error when called with a block with too few parameters' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(1) | | {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /block expects 1 argument, got none/)
+  end
+
+  it 'raises an error when called with step == 0' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(0) |$x| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /'step' expects an Integer\[1, default\] value, got Integer\[0, 0\]/)
+  end
+
+  it 'raises an error when step is not an integer' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step('three') |$x| {  }
+      MANIFEST
+    end.to raise_error(Puppet::Error, /'step' expects an Integer value, got String/)
+  end
+
+  it 'does not raise an error when called with a block with too many but optional arguments' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+        [1].step(1) |$v1, $v2=extra| {  }
+      MANIFEST
+    end.to_not raise_error
+  end
+
+  it 'returns Undef when called with a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+          assert_type(Undef, [1].step(2) |$x| { $x })
+      MANIFEST
+    end.not_to raise_error
+  end
+
+  it 'returns an Iterable when called without a block' do
+    expect do
+      compile_to_catalog(<<-MANIFEST)
+          assert_type(Iterable, [1].step(2))
+      MANIFEST
+    end.not_to raise_error
+  end
+
+  it 'should produce "times" interval of integer according to step' do
+    expect(eval_and_collect_notices('10.step(2) |$x| { notice($x) }')).to eq(['0', '2', '4', '6', '8'])
+  end
+
+  it 'should produce interval of Integer[5,20] according to step' do
+    expect(eval_and_collect_notices('Integer[5,20].step(4) |$x| { notice($x) }')).to eq(['5', '9', '13', '17'])
+  end
+
+  it 'should produce the elements of [a,b,c,d,e,f,g,h] according to step' do
+    expect(eval_and_collect_notices('[a,b,c,d,e,f,g,h].step(2) |$x| { notice($x) }')).to eq(%w(a c e g))
+  end
+
+  it 'should produce the elements {a=>1,b=>2,c=>3,d=>4,e=>5,f=>6,g=>7,h=>8} according to step' do
+    expect(eval_and_collect_notices('{a=>1,b=>2,c=>3,d=>4,e=>5,f=>6,g=>7,h=>8}.step(2) |$t| { notice($t[1]) }')).to eq(%w(1 3 5 7))
+  end
+
+  it 'should produce the choices of Enum[a,b,c,d,e,f,g,h] according to step' do
+    expect(eval_and_collect_notices('Enum[a,b,c,d,e,f,g,h].step(2) |$x| { notice($x) }')).to eq(%w(a c e g))
+  end
+
+  it 'should produce descending interval of Integer[5,20] when chained after a reverse_each' do
+    expect(eval_and_collect_notices('Integer[5,20].reverse_each.step(4) |$x| { notice($x) }')).to eq(['20', '16', '12', '8'])
+  end
+end

data/spec/unit/functions/type_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the type function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'produces the type of a given value with default detailed quality' do
+  expect(compile_to_catalog('notify { "${ type([2, 3.14]) }": }')).to have_resource(
+      'Notify[Tuple[Integer[2, 2], Float[3.14, 3.14]]]')
+  end
+
+  it 'produces the type of a give value with detailed quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], detailed) }": }')).to have_resource(
+      'Notify[Tuple[Integer[2, 2], Float[3.14, 3.14]]]')
+  end
+
+  it 'produces the type of a given value with reduced quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], reduced) }": }')).to have_resource(
+      'Notify[Array[Numeric, 2, 2]]')
+  end
+
+  it 'produces the type of a given value with generalized quality when quality is given' do
+    expect(compile_to_catalog('notify { "${ type([2, 3.14], generalized) }": }')).to have_resource(
+      'Notify[Array[Numeric]]')
+  end
+
+  it 'errors when given a fault inference quality' do
+    expect do
+      compile_to_catalog("notify { type([2, 4.14], gobbledygooked): }")
+    end.to raise_error(/expects a match for Enum\['detailed', 'generalized', 'reduced'\], got 'gobbledygooked'/)
+  end
+end

data/spec/unit/functions4_spec.rb

@@ -10,18 +10,24 @@ module FunctionAPISpecModule
 
   class TestFunctionLoader < Puppet::Pops::Loader::StaticLoader
     def initialize
-      @functions = {}
+      @constants = {}
     end
 
     def add_function(name, function)
       typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:function, name)
       entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, function, __FILE__)
-      @functions[typed_name] = entry
+      @constants[typed_name] = entry
+    end
+
+    def add_type(name, type)
+      typed_name = Puppet::Pops::Loader::Loader::TypedName.new(:type, name)
+      entry = Puppet::Pops::Loader::Loader::NamedEntry.new(typed_name, type, __FILE__)
+      @constants[typed_name] = entry
     end
 
     # override StaticLoader
     def load_constant(typed_name)
-      @functions[typed_name]
+      @constants[typed_name]
     end
   end
 end
@@ -149,7 +155,7 @@ describe 'the 4x function api' do
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 3, 10, 3, "4")
-      end.to raise_error(ArgumentError, "'min' expected one of:
+      end.to raise_error(ArgumentError, "'min' expects one of:
   (Numeric x, Numeric y, Numeric a?, Numeric b?, Numeric c*)
     rejected: parameter 'b' expects a Numeric value, got String
   (String x, String y, String a+)
@@ -217,7 +223,7 @@ describe 'the 4x function api' do
       expect(func.is_a?(Puppet::Functions::Function)).to be_truthy
       expect do
         func.call({}, 10, '20')
-      end.to raise_error(ArgumentError, "'min' expected one of:
+      end.to raise_error(ArgumentError, "'min' expects one of:
   (Numeric a, Numeric b)
     rejected: parameter 'b' expects a Numeric value, got String
   (String s1, String s2)
@@ -466,6 +472,48 @@ describe 'the 4x function api' do
       end
     end
 
+    context 'can use a loader when parsing types in function dispatch' do
+      let(:parser) {  Puppet::Pops::Parser::EvaluatingParser.new }
+
+      it 'and resolve a referenced Type alias' do
+        the_loader = loader()
+        the_loader.add_type('myalias', type_alias_t('MyAlias', 'Integer'))
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'MyAlias', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        expect(parser.evaluate({}, program)).to eql(10)
+      end
+
+      it 'and distinguish between a Type alias and a Resource type' do
+        the_loader = loader()
+        here = get_binding(the_loader)
+        fc = eval(<<-CODE, here)
+          Puppet::Functions.create_function('testing::test') do
+            dispatch :test do
+              param 'MyAlias', :x
+            end
+            def test(x)
+              x
+            end
+          end
+        CODE
+        the_loader.add_function('testing::test', fc.new({}, the_loader))
+        program = parser.parse_string('testing::test(10)', __FILE__)
+        Puppet::Pops::Adapters::LoaderAdapter.adapt(program.model).loader = the_loader
+        expect { parser.evaluate({}, program) }.to raise_error(Puppet::Error, /parameter 'x' expects a Resource value, got Integer/)
+      end
+    end
   end
 
   def create_noargs_function_class
@@ -801,4 +849,12 @@ describe 'the 4x function api' do
     end
   end
 
+  def type_alias_t(name, type_string)
+    type_expr = Puppet::Pops::Parser::EvaluatingParser.new.parse_string(type_string).current
+    Puppet::Pops::Types::TypeFactory.type_alias(name, type_expr)
+  end
+
+  def get_binding(loader_injected_arg)
+    binding
+  end
 end