puppet 4.3.0 → 4.4.0

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
@@ -486,7 +531,7 @@ EOS
       end
     end
 
-    it 'will handle path merge with not found correctly' do
+    it 'will handle path merge when some entries are not found correctly' do
       assemble_and_compile('${r}', "'hieraprovider::test::param_a'") do |scope|
         lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
         begin
@@ -504,10 +549,10 @@ Merge strategy first
     Data Provider "two paths"
       Merge strategy first
         Path "#{environmentpath}/production/modules/hieraprovider/data/first.json"
-          Original path: first
+          Original path: "first"
           No such key: "hieraprovider::test::not_found"
         Path "#{environmentpath}/production/modules/hieraprovider/data/second_not_present.json"
-          Original path: second_not_present
+          Original path: "second_not_present"
           Path not found
 EOS
       end
@@ -551,5 +596,32 @@ EOS
           )
       end
     end
+
+    it 'will explain that "lookup_options" is an invalid key' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('lookup_options', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Invalid key "lookup_options"
+EOS
+      end
+    end
+
+    it 'will explain that "lookup_options" is an invalid key for any key starting with "lookup_options."' do
+      assemble_and_compile('${r}', "'abc::a'") do |scope|
+        lookup_invocation = Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, true)
+        begin
+          Puppet::Pops::Lookup.lookup('lookup_options.subkey', nil, nil, false, nil, lookup_invocation)
+        rescue Puppet::Error
+        end
+        expect(lookup_invocation.explainer.to_s).to eq(<<EOS)
+Invalid key "lookup_options"
+EOS
+      end
+    end
+
   end
 end

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)
@@ -420,7 +426,7 @@ describe 'the 4x function api' do
         end
         # initiate the function the same way the loader initiates it
         f = fc.new(:closure_scope, Puppet.lookup(:loaders).puppet_system_loader)
-        expect{f.call({})}.to raise_error(ArgumentError, "Function test(): cannot call function 'no_such_function' - not found")
+        expect{f.call({})}.to raise_error(ArgumentError, "Function test(): Unknown function: 'no_such_function'")
       end
     end
 
@@ -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

data/spec/unit/hiera/scope_spec.rb

@@ -76,9 +76,12 @@ describe Hiera::Scope do
 
   describe "#include?" do
     it "should correctly report missing data" do
-      real["foo"] = ""
+      real["nil_value"] = nil
+      real["blank_value"] = ""
 
-      expect(scope.include?("foo")).to eq(false)
+      expect(scope.include?("nil_value")).to eq(true)
+      expect(scope.include?("blank_value")).to eq(true)
+      expect(scope.include?("missing_value")).to eq(false)
     end
 
     it "should always return true for calling_class and calling_module" do