puppet 5.5.6 → 5.5.7

data/spec/unit/defaults_spec.rb

@@ -150,4 +150,24 @@ describe "Defaults" do
       ).to match(%r{.*/code/modules})
     end
   end
+
+  describe 'ordering' do
+    it 'issues a deprecation warning when set to title-hash' do
+      Puppet.expects(:deprecation_warning).with('Setting ordering is deprecated.', 'setting-ordering')
+
+      Puppet.settings[:ordering] = 'title-hash'
+    end
+
+    it 'issues a deprecation warning when set to random' do
+      Puppet.expects(:deprecation_warning).with('Setting ordering is deprecated.', 'setting-ordering')
+
+      Puppet.settings[:ordering] = 'random'
+    end
+
+    it 'does not issue a deprecation warning when set to manifest' do
+      Puppet.expects(:deprecation_warning).with('Setting ordering is deprecated.', 'setting-ordering').never
+
+      Puppet.settings[:ordering] = 'manifest'
+    end
+  end
 end

data/spec/unit/etc_spec.rb

@@ -412,6 +412,31 @@ describe Puppet::Etc, :if => !Puppet.features.microsoft_windows? do
     end
   end
 
+  describe :group do
+    it 'should return the next group struct if a block is not provided' do
+      Puppet::Etc.expects(:getgrent).returns(ascii_group_struct)
+
+      expect(Puppet::Etc.group).to eql(ascii_group_struct)
+    end
+
+    it 'should iterate over the available groups if a block is provided' do
+      expected_groups = [
+        utf_8_group_struct,
+        euc_kr_group_struct,
+        ascii_group_struct
+      ]
+      Puppet::Etc.stubs(:getgrent).returns(*(expected_groups + [nil]))
+
+      Puppet::Etc.expects(:setgrent)
+      Puppet::Etc.expects(:endgrent)
+
+      actual_groups = []
+      Puppet::Etc.group { |group| actual_groups << group }
+
+      expect(actual_groups).to eql(expected_groups)
+    end
+  end
+
   describe "endgrent" do
     it "should call Etc.getgrent" do
       Etc.expects(:getgrent)

data/spec/unit/file_serving/fileset_spec.rb

@@ -147,12 +147,12 @@ describe Puppet::FileServing::Fileset do
       top_names = %w{one two .svn CVS}
       sub_names = %w{file1 file2 .svn CVS 0 false}
 
-      Dir.stubs(:entries).with(path).returns(top_names)
+      Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(top_names)
       top_names.each do |subdir|
         @files << subdir # relative path
         subpath = File.join(path, subdir)
         Puppet::FileSystem.stubs(stat_method).with(subpath).returns @dirstat
-        Dir.stubs(:entries).with(subpath).returns(sub_names)
+        Dir.stubs(:entries).with(subpath, encoding: Encoding::UTF_8).returns(sub_names)
         sub_names.each do |file|
           @files << File.join(subdir, file) # relative path
           subfile_path = File.join(subpath, file)
@@ -173,7 +173,7 @@ describe Puppet::FileServing::Fileset do
         extend Mocha::API
         path = File.join(base_path, name)
         Puppet::FileSystem.stubs(:lstat).with(path).returns MockStat.new(path, true)
-        Dir.stubs(:entries).with(path).returns(['.', '..'] + entries.map(&:name))
+        Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(['.', '..'] + entries.map(&:name))
         entries.each do |entry|
           entry.mock(path)
         end
@@ -295,7 +295,7 @@ describe Puppet::FileServing::Fileset do
     link_path = File.join(path, "mylink")
     Puppet::FileSystem.expects(:stat).with(link_path).raises(Errno::ENOENT)
 
-    Dir.stubs(:entries).with(path).returns(["mylink"])
+    Dir.stubs(:entries).with(path, encoding: Encoding::UTF_8).returns(["mylink"])
 
     fileset = Puppet::FileServing::Fileset.new(path)
 
@@ -319,9 +319,9 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "returns a hash of all files in each fileset with the value being the base path" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one uno})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two dos})
-      Dir.expects(:entries).with(make_absolute("/third/path")).returns(%w{three tres})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one uno})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two dos})
+      Dir.expects(:entries).with(make_absolute("/third/path"), encoding: Encoding::UTF_8).returns(%w{three tres})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
@@ -335,15 +335,15 @@ describe Puppet::FileServing::Fileset do
     end
 
     it "includes the base directory from the first fileset" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{two})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
-      Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
-      Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/first/path"), encoding: Encoding::UTF_8).returns(%w{one})
+      Dir.expects(:entries).with(make_absolute("/second/path"), encoding: Encoding::UTF_8).returns(%w{one})
 
       expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end

data/spec/unit/gettext/config_spec.rb

@@ -108,7 +108,7 @@ describe Puppet::GettextConfig do
   describe "clearing the configured text domain" do
     it 'succeeds' do
       Puppet::GettextConfig.clear_text_domain
-      expect(FastGettext.text_domain).to be_nil
+      expect(FastGettext.text_domain).to eq(FastGettext.default_text_domain)
     end
 
     it 'falls back to default' do

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

@@ -1102,15 +1102,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       end
 
       it 'does not map :undef to empty string in arrays' do
-        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(:undef)
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0][0] == :undef}
+        expect(parser.evaluate_string(scope, "$a = {} $b = [$a[nope]] bazinga($b)", __FILE__)).to eq(true)
+        expect(parser.evaluate_string(scope, "bazinga([undef])", __FILE__)).to eq(true)
       end
 
       it 'does not map :undef to empty string in hashes' do
-        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] }
-        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(:undef)
-        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(:undef)
+        Puppet::Parser::Functions.newfunction("bazinga", :type => :rvalue) { |args| args[0]['a'] == :undef }
+        expect(parser.evaluate_string(scope, "$a = {} $b = {a => $a[nope]} bazinga($b)", __FILE__)).to eq(true)
+        expect(parser.evaluate_string(scope, "bazinga({a => undef})", __FILE__)).to eq(true)
       end
     end
   end

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

@@ -271,7 +271,10 @@ describe 'loaders' do
           File.stubs(:read).with(usee_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           File.stubs(:read).with(usee2_metadata_path, {:encoding => 'utf-8'}).raises Errno::ENOENT
           Puppet[:code] = "$case_number = #{case_number}\ninclude ::user"
-          expect { compiler.compile }.to raise_error(Puppet::Error, /Unknown function/)
+          catalog = compiler.compile
+          resource = catalog.resource('Notify', "case_#{case_number}")
+          expect(resource).not_to be_nil
+          expect(resource['message']).to eq(desc[:expects])
         end
       end
     end
@@ -408,6 +411,36 @@ describe 'loaders' 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'")
     end
+
+  end
+
+  context 'when causing a 3x load followed by a 4x load' do
+    let(:env) { environment_for(mix_4x_and_3x_functions) }
+    let(:compiler) { Puppet::Parser::Compiler.new(Puppet::Node.new("test", :environment => env)) }
+    let(:scope) { compiler.topscope }
+    let(:loader) { compiler.loaders.private_loader_for_module('user') }
+
+
+    before(:each) do
+      Puppet.push_context(:current_environment => scope.environment, :global_scope => scope, :loaders => compiler.loaders)
+    end
+    after(:each) do
+      Puppet.pop_context
+    end
+
+    it 'a 3x function is loaded once' do
+      # create a 3x function that when called will do a load of "callee_ws"
+      Puppet::Parser::Functions::newfunction(:callee, :type => :rvalue, :arity => 1) do |args|
+        function_callee_ws(['passed in scope'])
+      end
+      Puppet.expects(:warning).with(any_parameters).never
+      scope['passed_in_scope'] = 'value'
+      function = loader.load_typed(typed_name(:function, 'callee')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+
+      function = loader.load_typed(typed_name(:function, 'callee_ws')).value
+      expect(function.call(scope, 'passed in scope')).to eql("usee::callee_ws() got 'value'")
+    end
   end
 
   context 'loading' do
@@ -576,22 +609,22 @@ describe 'loaders' do
         expect(type).to be_a(Puppet::Pops::Types::PIntegerType)
       end
 
-      it 'will not resolve implicit transitive dependencies, a -> c' do
+      it 'will resolve implicit transitive dependencies, a -> c' do
         type = Puppet::Pops::Types::TypeParser.singleton.parse('A::N', Puppet::Pops::Loaders.find_loader('a'))
         expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
         expect(type.name).to eql('A::N')
         type = type.resolved_type
-        expect(type).to be_a(Puppet::Pops::Types::PTypeReferenceType)
-        expect(type.type_string).to eql('C::C')
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.name).to eql('C::C')
       end
 
-      it 'will not resolve reverse dependencies, b -> a' do
+      it 'will resolve reverse dependencies, b -> a' do
         type = Puppet::Pops::Types::TypeParser.singleton.parse('B::X', Puppet::Pops::Loaders.find_loader('b'))
         expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
         expect(type.name).to eql('B::X')
         type = type.resolved_type
-        expect(type).to be_a(Puppet::Pops::Types::PTypeReferenceType)
-        expect(type.type_string).to eql('A::A')
+        expect(type).to be_a(Puppet::Pops::Types::PTypeAliasType)
+        expect(type.name).to eql('A::A')
       end
 
       it 'does not resolve init_typeset when more qualified type is found in typeset' do

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

@@ -140,6 +140,22 @@ describe "egrammar parsing heredoc" do
     ].join("\n"))
   end
 
+  it "parses interpolated [] expression by looking at the correct preceding char for space" do
+    # NOTE: Important not to use the left margin feature here
+    src = <<-CODE
+$xxxxxxx = @("END")
+${facts['os']['family']}
+XXXXXXX XXX
+END
+CODE
+    expect(dump(parse(src))).to eq([
+      "(= $xxxxxxx (@()",
+      "  (sublocated (cat (str (slice (slice $facts 'os') 'family')) '",
+      "XXXXXXX XXX",
+      "'))",
+      "))"].join("\n"))
+  end
+
   it 'parses multiple heredocs on the same line' do
     src = <<-CODE
     notice({ @(foo) => @(bar) })

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

@@ -23,7 +23,11 @@ describe "validating 4x" do
 
   def with_environment(environment, env_params = {})
     override_env = environment
-    override_env = environment.override_with(env_params) if env_params.count > 0
+    override_env = environment.override_with({
+      modulepath:     env_params[:modulepath]     || environment.full_modulepath,
+      manifest:       env_params[:manifest]       || environment.manifest,
+      config_version: env_params[:config_version] || environment.config_version
+    }) if env_params.count > 0
     Puppet.override(current_environment: override_env) do
       yield
     end
@@ -72,15 +76,6 @@ describe "validating 4x" do
     end
   end
 
-  it 'should not raise error for legal definition locations' do
-    with_environment(environment, :manifest => 'a/manifest/file.pp') do
-      expect(validate(parse('function aaa::bbb() {}',      'path/aaa/manifests/bbb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('class aaa() {}',      'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbB::ccc() {}', 'path/aaa/manifests/bBb.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-      expect(validate(parse('function aaa::bbb::ccc() {}', 'path/aaa/manifests/bbb/CCC.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
-    end
-  end
-
   it 'should not raise error for definitions inside initial --manifest file' do
     with_environment(environment, :manifest => 'a/manifest/file.pp') do
       expect(validate(parse('class aaa() {}', 'a/manifest/file.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -100,6 +95,13 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error for empty files in modulepath' do
+    with_environment(environment) do
+      expect(validate(parse('', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      expect(validate(parse('#this is a comment', 'path/aaa/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+    end
+  end
+
   it 'should raise error if the file is in the modulepath but is not well formed' do
     with_environment(environment) do
       expect(validate(parse('class aaa::bbb::ccc() {}', 'path/manifest/aaa/bbb.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
@@ -113,6 +115,18 @@ describe "validating 4x" do
     end
   end
 
+  it 'should not raise error when one modulepath is a substring of another' do
+    with_environment(environment, modulepath: ['path', 'pathplus']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
+  it 'should not raise error when a modulepath ends with a file separator' do
+    with_environment(environment, modulepath: ['path/']) do
+      expect(validate(parse('class aaa::ccc() {}', 'pathplus/aaa/manifests/ccc.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
+    end
+  end
+
   it 'should raise error for illegal type names' do
     expect(validate(parse('type ::Aaa = Any'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_NAME)
   end
@@ -145,6 +159,16 @@ describe "validating 4x" do
         expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
       end
     end
+
+    it 'produces a deprecation for illegal top level constructs' do
+      with_environment(environment) do
+        acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to warning' do
@@ -179,6 +203,16 @@ describe "validating 4x" do
         expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
       end
     end
+
+    it 'produces a deprecation for illegal top level constructs' do
+      with_environment(environment) do
+        acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to error' do
@@ -220,6 +254,16 @@ describe "validating 4x" do
         expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
       end
     end
+
+    it 'produces a deprecation for illegal top level constructs' do
+      with_environment(environment) do
+        acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      end
+    end
   end
 
   context 'with --strict set to off' do
@@ -240,6 +284,16 @@ describe "validating 4x" do
         expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_DEFINITION_LOCATION)
       end
     end
+
+    it 'produces a deprecation for illegal top level constructs' do
+      with_environment(environment) do
+        acceptor = validate(parse('$foo = 1', 'path/aaa/manifests/bbb.pp'))
+        expect(deprecation_count(acceptor)).to eql(1)
+        expect(acceptor.warning_count).to eql(1)
+        expect(acceptor.error_count).to eql(0)
+        expect(acceptor).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+      end
+    end
   end
 
   context 'irrespective of --strict' do
@@ -760,6 +814,71 @@ describe "validating 4x" do
     end
   end
 
+  context 'top level constructs' do
+    {
+      'a class' => 'class x{}',
+      'a define' => 'define x{}',
+      'a function' => 'function x() {}',
+      'a type alias' => 'type A = Data',
+      'a type alias for a complex type' => 'type C = Hash[String[1],Integer]',
+      'a type definition' => 'type A {}',
+    }.each_pair do |word, source|
+      it "will not have an issue with #{word} at the top level in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source, 'path/x/manifests/init.pp'))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+    end
+  end
+
+  context 'non-top level constructs' do
+    {
+      'an assignment' => '$foo = 1',
+      'a resource' => 'notify { nope: }',
+      'a resource default' => "Notify { message => 'yo' }",
+      'a function call' => "include 'foo'",
+      'a node definition' => 'node default {}',
+      'an expression' => '1+1',
+      'a conditional' => 'if true {42}',
+      'a literal value' => '42',
+      'a virtual collector' => 'User <| tag == web |>',
+      'an exported collector' => 'Sshkey <<| |>>',
+    }.each_pair do |word, source|
+      it "will have an issue with #{word} at the top level in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source, 'path/x/manifests/init.pp'))).to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+
+      it "will not have an issue with #{word} at top level not in a module" do
+        with_environment(environment) do
+          expect(validate(parse(source))).not_to have_issue(Puppet::Pops::Issues::ILLEGAL_TOP_CONSTRUCT_LOCATION)
+        end
+      end
+    end
+
+    it "will give multiple errors in one file with multiple issues" do
+      source = <<-SOURCE
+      class foo {}
+      notify { nope: }
+      node bar {}
+
+      $a = 7
+      SOURCE
+
+      with_environment(environment) do
+        acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+        expect(deprecation_count(acceptor)).to eql(3)
+        expect(acceptor.warning_count).to eql(3)
+        expect(acceptor.error_count).to eql(0)
+
+        expect(acceptor.warnings[0].source_pos.line).to eql(2)
+        expect(acceptor.warnings[1].source_pos.line).to eql(3)
+        expect(acceptor.warnings[2].source_pos.line).to eql(5)
+      end
+    end
+  end
+
   context "capability annotations" do
     ['produces', 'consumes'].each do |word|
       it "rejects illegal resource types in #{word} clauses" do