puppet 4.3.1-x64-mingw32 → 4.3.2-x64-mingw32

data/spec/unit/functions/epp_spec.rb

@@ -44,15 +44,15 @@ describe "the epp function" do
     it "raises an error if required variable is not given" do
       scope['x'] = 'wrong one'
       expect do
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
-      end.to raise_error(/no value given for required parameters x/)
+        eval_template("<%-| $x |-%><%= $x == correct %>")
+      end.to raise_error(/expects a value for parameter 'x'/)
     end
 
-    it "raises an error if too many arguments are given" do
+    it 'raises an error if invalid arguments are given' do
       scope['x'] = 'wrong one'
       expect do
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      end.to raise_error(/Too many arguments: 2 for 1/)
+      end.to raise_error(/has no parameter named 'y'/)
     end
   end
 
@@ -80,13 +80,13 @@ describe "the epp function" do
     it "raises an error when the passed value does not match the parameter's type" do
       expect do
         eval_template_with_args("<%-|Integer $x|-%><%= $x %>", 'x' => 'incorrect')
-      end.to raise_error(/block parameter 'x' expects an Integer value, got String/)
+      end.to raise_error(/parameter 'x' expects an Integer value, got String/)
     end
 
     it "raises an error when the default value does not match the parameter's type" do
       expect do
         eval_template("<%-|Integer $x = 'nope'|-%><%= $x %>")
-      end.to raise_error(/block parameter 'x' expects an Integer value, got String/)
+      end.to raise_error(/parameter 'x' expects an Integer value, got String/)
     end
 
     it "allows an parameter to default to undef" do

data/spec/unit/functions/inline_epp_spec.rb

@@ -36,15 +36,15 @@ describe "the inline_epp function" do
     it "raises an error if required variable is not given" do
       scope['x'] = 'wrong one'
       expect {
-        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'y' => 'correct')
-      }.to raise_error(/no value given for required parameters x/)
+        eval_template_with_args("<%-| $x |-%><%= $x == correct %>", {})
+      }.to raise_error(/expects a value for parameter 'x'/)
     end
 
-    it "raises an error if too many arguments are given" do
+    it 'raises an error if unexpected arguments are given' do
       scope['x'] = 'wrong one'
       expect {
         eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct', 'y' => 'surplus')
-      }.to raise_error(/Too many arguments: 2 for 1/)
+      }.to raise_error(/has no parameter named 'y'/)
     end
   end
 

data/spec/unit/functions/lookup_spec.rb

@@ -486,7 +486,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 +504,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 +551,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/functions4_spec.rb

@@ -420,7 +420,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
 

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

data/spec/unit/indirector/json_spec.rb

@@ -81,7 +81,7 @@ describe Puppet::Indirector::JSON do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          File.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end

data/spec/unit/node_spec.rb

@@ -86,6 +86,14 @@ describe Puppet::Node do
                              )
       expect(node.to_pson).to validate_against('api/schemas/node.json')
     end
+
+    it "should allow its environment parameter to be set by attribute after initialization" do
+      node = Puppet::Node.new("foo", { :parameters => { 'environment' => :foo } })
+      node.environment_name = :foo
+      node.environment = :bar
+      expect(node.environment_name).to eq(:bar)
+      expect(node.parameters['environment']).to eq(:bar)
+    end
   end
 
   describe "when serializing using yaml" do

data/spec/unit/parser/compiler_spec.rb

@@ -194,24 +194,6 @@ describe Puppet::Parser::Compiler do
       expect(sanitized.trusted_data).to_not eq({ :a => 42 })
     end
 
-    it "should report 'trusted' parameters as trusted_data but as inauthentic if running as non-root" do
-      node = Puppet::Node.new("mynode")
-      node.parameters['trusted'] = { 'authenticated' => true,
-                                     'certname'      => 'foo',
-                                     'extensions'    => 'things' }
-
-      Puppet.features.stubs(:root?).returns(false)
-
-      Puppet.ignore(:trusted_information)
-      compiler = Puppet::Parser::Compiler.new(node)
-      Puppet.restore(:trusted_information)
-
-      sanitized = compiler.node
-      expect(sanitized.trusted_data).to eq({ 'authenticated' => false,
-                                             'certname'      => 'foo',
-                                             'extensions'    => 'things' })
-    end
-
     it "should prefer trusted_data in the node above other plausible sources" do
       node = Puppet::Node.new("mynode")
       node.trusted_data = { 'authenticated' => true,

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

@@ -123,9 +123,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(expr)).to eql(range(1,1))
     end
 
-    it 'produces an Integer[from, <from]' do
+    it 'gives an error for Integer[from, <from]' do
       expr = fqr('Integer')[1,0]
-      expect(evaluate(expr)).to eql(range(1,0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Integer[] if there are more than 2 keys' do
@@ -154,9 +154,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
       expect(evaluate(expr)).to eql(float_range(1.0,1.0))
     end
 
-    it 'produces a Float[from, <from]' do
+    it 'gives an error for Float[from, <from]' do
       expr = fqr('Float')[1.0,0.0]
-      expect(evaluate(expr)).to eql(float_range(1.0,0.0))
+      expect{evaluate(expr)}.to raise_error(/'from' must be less or equal to 'to'/)
     end
 
     it 'produces an error for Float[] if there are more than 2 keys' do

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

@@ -960,7 +960,7 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
     it "provides location information on error in unparenthesized call logic" do
-    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /line 1\:1/)
+    expect{parser.evaluate_string(scope, "include non_existing_class", __FILE__)}.to raise_error(Puppet::ParseError, /:1:1/)
     end
 
     it 'defaults can be given in a lambda and used only when arg is missing' do

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

@@ -31,6 +31,8 @@ describe 'loaders' do
   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
@@ -103,7 +105,9 @@ describe 'loaders' do
     end
 
     it 'loader allows loading a function more than once' do
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path).returns ''
+
+      env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
       loaders = Puppet::Pops::Loaders.new(env)
 
       moduleb_loader = loaders.private_loader_for_module('user')
@@ -116,16 +120,94 @@ describe 'loaders' do
   end
 
   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
-      env = environment_for(dependent_modules_with_metadata)
+      File.stubs(:read).with(user_metadata_path).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).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).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
   end
 
+
   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))

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -329,6 +329,12 @@ describe 'Lexer2' do
     end
   end
 
+  it 'detects unterminated multiline comment' do
+    expect { tokens_scanned_from("/* not terminated\nmultiline\ncomment") }.to raise_error(Puppet::ParseErrorWithIssue) { |e|
+      expect(e.issue_code).to be(Puppet::Pops::Issues::UNCLOSED_MLCOMMENT.issue_code)
+    }
+  end
+
   { "=~" => [:MATCH, "=~ /./"],
     "!~" => [:NOMATCH, "!~ /./"],
     ","  => [:COMMA, ", /./"],

data/spec/unit/pops/parser/parser_rspec_helper.rb

@@ -13,4 +13,9 @@ module ParserRspecHelper
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)
   end
+
+  def parse_epp(code)
+    parser = Puppet::Pops::Parser::EppParser.new()
+    parser.parse_string(code)
+  end
 end

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

@@ -970,35 +970,18 @@ describe 'The type calculator' do
         expect(calculator.assignable?(range_t(2,5), range_t(2,5))).to eq(true)
       end
 
-      it 'should accept an equal reverse range' do
-        expect(calculator.assignable?(range_t(2,5), range_t(5,2))).to eq(true)
-      end
-
       it 'should accept a narrower range' do
         expect(calculator.assignable?(range_t(2,10), range_t(3,5))).to eq(true)
       end
 
-      it 'should accept a narrower reverse range' do
-        expect(calculator.assignable?(range_t(2,10), range_t(5,3))).to eq(true)
-      end
-
       it 'should reject a wider range' do
         expect(calculator.assignable?(range_t(3,5), range_t(2,10))).to eq(false)
       end
 
-      it 'should reject a wider reverse range' do
-        expect(calculator.assignable?(range_t(3,5), range_t(10,2))).to eq(false)
-      end
-
       it 'should reject a partially overlapping range' do
         expect(calculator.assignable?(range_t(3,5), range_t(2,4))).to eq(false)
         expect(calculator.assignable?(range_t(3,5), range_t(4,6))).to eq(false)
       end
-
-      it 'should reject a partially overlapping reverse range' do
-        expect(calculator.assignable?(range_t(3,5), range_t(4,2))).to eq(false)
-        expect(calculator.assignable?(range_t(3,5), range_t(6,4))).to eq(false)
-      end
     end
 
     context 'when dealing with patterns' do

data/spec/unit/pops/validator/validator_spec.rb

@@ -107,6 +107,46 @@ describe "validating 4x" do
         SOURCE
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::IDEM_NOT_ALLOWED_LAST)
       end
+
+      it "detects a resource declared without title in #{type} when it is the only declaration present" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is in between other declarations" do
+        source = <<-SOURCE
+        #{type} nope {
+            notify { succ: message => 'Nope' }
+            notify { message => 'Nope' }
+            notify { pred: message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is declarated first" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { message => 'Nope' }
+            notify { pred: message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is declarated last" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { succ: message => 'Nope' }
+            notify { message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
     end
   end
 
@@ -177,6 +217,18 @@ describe "validating 4x" do
     end
   end
 
+  context 'for parameter names' do
+    ['class', 'define'].each do |word|
+      it "should require that #{word} parameter names are unique" do
+        expect(validate(parse("#{word} foo($a = 10, $a = 20) {}"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
+      end
+    end
+
+    it "should require that template parameter names are unique" do
+      expect(validate(parse_epp("<%-| $a, $a |-%><%= $a == doh %>"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
+    end
+  end
+
   context 'for reserved parameter names' do
     ['name', 'title'].each do |word|
       it "produces an error when $#{word} is used as a parameter in a class" do
@@ -241,6 +293,41 @@ describe "validating 4x" do
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
       end
     end
+
+    ['class', 'define', 'node'].each do |word|
+      it "produces an error when $#{word} is nested in an function" do
+        source = "function y() { #{word} x {} }"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
+      end
+    end
+
+    it 'produces an error when a function is nested in an function' do
+      source = 'function y() { function x() {} }'
+      expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+    end
+
+    ['class', 'define', 'node'].each do |word|
+      it "produces an error when function is nested in a #{word}" do
+        source = "#{word} x { function y() {} }"
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+      end
+    end
+
+    it 'does not produce an error when function is at top level script' do
+      source = 'function y() {}'
+      expect(validate(parse(source))).not_to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+    end
+
+    it 'does not produce an error when function is at top level file' do
+      source = 'function y() {}'
+
+      # We simulate a file by inserting a block between the program and the contained function
+      program = parse(source).current
+      function = program.body
+      program.body = Puppet::Pops::Model::BlockExpression.new
+      program.body.addStatements(function)
+      expect(validate(program)).not_to have_issue(Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL)
+    end
   end
 
   context "capability annotations" do