puppet 5.3.7 → 5.4.0

data/spec/unit/defaults_spec.rb

@@ -60,18 +60,53 @@ describe "Defaults" do
     end
   end
 
-  describe 'supported_checksum_types' do
-    it 'should default to md5,sha256' do
-      expect(Puppet.settings[:supported_checksum_types]).to eq(['md5', 'sha256'])
+  describe '.default_digest_algorithm' do
+    it 'defaults to md5 when FIPS is not enabled' do
+      Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+      expect(Puppet.default_digest_algorithm).to eq('md5')
+    end
+
+    it 'defaults to sha256 when FIPS is enabled' do
+      Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+      expect(Puppet.default_digest_algorithm).to eq('sha256')
+    end
+  end
+
+  describe '.supported_checksum_types' do
+    it 'defaults to md5, sha256, sha384, sha512, sha224 when FIPS is not enabled' do
+      Puppet::Util::Platform.stubs(:fips_enabled?).returns false
+      expect(Puppet.default_file_checksum_types).to eq(%w[md5 sha256 sha384 sha512 sha224])
+    end
+
+    it 'defaults to sha256, sha384, sha512, sha224 when FIPS is enabled' do
+      Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+      expect(Puppet.default_file_checksum_types).to eq(%w[sha256 sha384 sha512 sha224])
+    end
+  end
+
+  describe 'Puppet[:supported_checksum_types]' do
+    it 'defaults to md5, sha256, sha512, sha384, sha224' do
+      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[md5 sha256 sha384 sha512 sha224])
     end
 
     it 'should raise an error on an unsupported checksum type' do
-      expect { Puppet.settings[:supported_checksum_types] = ['md5', 'foo'] }.to raise_exception ArgumentError, 'Unrecognized checksum types ["foo"] are not supported. Valid values are ["md5", "md5lite", "sha256", "sha256lite", "sha1", "sha1lite", "mtime", "ctime"].'
+      expect {
+        Puppet.settings[:supported_checksum_types] = %w[md5 foo]
+      }.to raise_exception ArgumentError,
+                           /Invalid value 'foo' for parameter supported_checksum_types. Allowed values are/
     end
 
     it 'should not raise an error on setting a valid list of checksum types' do
-      Puppet.settings[:supported_checksum_types] = ['sha256', 'md5lite', 'mtime']
-      expect(Puppet.settings[:supported_checksum_types]).to eq(['sha256', 'md5lite', 'mtime'])
+      Puppet.settings[:supported_checksum_types] = %w[sha256 md5lite mtime]
+      expect(Puppet.settings[:supported_checksum_types]).to eq(%w[sha256 md5lite mtime])
+    end
+
+    it 'raises when setting md5 in FIPS mode' do
+      Puppet::Util::Platform.stubs(:fips_enabled?).returns true
+      expect {
+        Puppet.settings[:supported_checksum_types] = %w[md5]
+      }.to raise_error(ArgumentError,
+                       /Invalid value 'md5' for parameter supported_checksum_types. Allowed values are 'sha256'/)
     end
   end
 
@@ -88,18 +123,4 @@ describe "Defaults" do
       Puppet.settings.handlearg("--server", "test_server")
     end
   end
-
-  describe 'basemodulepath' do
-    it 'includes the global and system modules on non-windows', :unless => Puppet::Util::Platform.windows? do
-      expect(
-        Puppet[:basemodulepath]
-      ).to match(%r{.*/code/modules:/opt/puppetlabs/puppet/modules})
-    end
-
-    it 'includes global modules on windows', :if => Puppet::Util::Platform.windows? do
-      expect(
-        Puppet[:basemodulepath]
-      ).to match(%r{.*/code/modules})
-    end
-  end
 end

data/spec/unit/face/config_spec.rb

@@ -82,7 +82,6 @@ trace = true
 
       manipulator.expects(:set).with("baz", "foo", "bar")
       subject.set('foo', 'bar', {:section => "baz"})
-
     end
 
     it "opens the file with UTF-8 encoding" do
@@ -91,6 +90,52 @@ trace = true
     end
   end
 
+  context 'when the puppet.conf file does not exist' do
+    let(:config_file) { '/foo/puppet.conf' }
+    let(:path) { Pathname.new(config_file).expand_path }
+    before(:each) do
+      Puppet[:config] = config_file
+      Puppet::FileSystem.stubs(:pathname).with(path.to_s).returns(path)
+    end
+
+    it 'prints a message when the puppet.conf file does not exist' do
+      Puppet::FileSystem.stubs(:exist?).with(path).returns(false)
+      Puppet.expects(:warning).with("The puppet.conf file does not exist #{path.to_s}")
+      subject.delete('setting', {:section => 'main'})
+    end
+  end
+
+  context 'when deleting config values' do
+    let(:config_file) { '/foo/puppet.conf' }
+    let(:path) { Pathname.new(config_file).expand_path }
+    before(:each) do
+      Puppet[:config] = config_file
+      Puppet::FileSystem.stubs(:pathname).with(path.to_s).returns(path)
+      Puppet::FileSystem.stubs(:exist?).with(path).returns(true)
+    end
+
+    it 'prints a message about what was deleted' do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:delete).with('main', 'setting').returns('    setting=value')
+      expect { subject.delete('setting', {:section => 'main'}) }.to have_printed("Deleted setting from 'main': 'setting=value'")
+    end
+
+    it 'prints a warning when a setting is not found to delete' do
+      Puppet::FileSystem.stubs(:open).with(path, anything, anything).yields(StringIO.new)
+      config = Puppet::Settings::IniFile.new([Puppet::Settings::IniFile::DefaultSection.new])
+      manipulator = Puppet::Settings::IniFile::Manipulator.new(config)
+      Puppet::Settings::IniFile::Manipulator.stubs(:new).returns(manipulator)
+
+      manipulator.expects(:delete).with('main', 'setting').returns(nil)
+      Puppet.expects(:warning).with("No setting found in configuration file for section 'main' setting name 'setting'")
+      subject.delete('setting', {:section => 'main'})
+    end
+  end
+
   shared_examples_for :config_printing_a_section do |section|
 
     def add_section_option(args, section)

data/spec/unit/face/epp_face_spec.rb

@@ -201,8 +201,12 @@ describe Puppet::Face[:epp, :current] do
       expect(eppface.render(:e => 'hello <%= $x %>', :values => '{x => "mr X"}')).to eq("hello mr X")
     end
 
-    it "adds values given in a puppet hash given on command line with --values" do
-      expect(eppface.render(:e => 'hello <%= $x %>', :values => '{x => "mr X"}')).to eq("hello mr X")
+    it "adds fully qualified values given in a puppet hash given on command line with --values" do
+      expect(eppface.render(:e => 'hello <%= $mr::x %>', :values => '{mr::x => "mr X"}')).to eq("hello mr X")
+    end
+
+    it "adds fully qualified values with leading :: given in a puppet hash given on command line with --values" do
+      expect(eppface.render(:e => 'hello <%= $::mr %>', :values => '{"::mr" => "mr X"}')).to eq("hello mr X")
     end
 
     it "adds values given in a puppet hash produced by a .pp file given with --values_file" do
@@ -239,7 +243,7 @@ describe Puppet::Face[:epp, :current] do
 
     it 'initializes the 4x loader' do
       expect(eppface.render({ :e => <<-EPP.unindent })).to eql("\nString\n\nInteger\n\nBoolean\n")
-        <% $data = [type('a',generalized), type(2,generalized), type(true)] -%>
+        <% $data = [type('a',generalized), type(2,generalized), type(true,generalized)] -%>
         <% $data.each |$value| { %>
         <%= $value %>
         <% } -%>

data/spec/unit/face/module/search_spec.rb

@@ -64,6 +64,17 @@ describe "puppet module search" do
       expect(subject.render(results, ['apache', {}])).to match(/tag2/)
     end
 
+    it 'should mark deprecated modules in search results' do
+      results = {
+        :result => :success,
+        :answers => [
+          {'full_name' => 'puppetlabs-corosync', 'deprecated_at' => Time.new, 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
+        ]
+      }
+
+      expect(subject.render(results, ['apache', {}])).to match(/puppetlabs-corosync.*DEPRECATED/i)
+    end
+
     it 'should elide really long descriptions' do
       results = {
         :result => :success,

data/spec/unit/face/parser_spec.rb

@@ -72,7 +72,7 @@ describe Puppet::Face[:parser, :current] do
           expect { parser.validate(manifest) }.to exit_with(1)
         end
 
-        expect(@logs.join).to match(/environment special.*Syntax error at end of file/)
+        expect(@logs.join).to match(/environment special.*Syntax error at end of input/)
       end
 
     end
@@ -117,7 +117,7 @@ describe Puppet::Face[:parser, :current] do
       output = parser.dump({ :e => '{ invalid =>' })
 
       expect(output).to eq("")
-      expect(@logs[0].message).to eq("Syntax error at end of file")
+      expect(@logs[0].message).to eq("Syntax error at end of input")
       expect(@logs[0].level).to eq(:err)
     end
 

data/spec/unit/file_bucket/dipper_spec.rb

@@ -145,6 +145,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   describe "listing files in local filebucket" do
     with_digest_algorithms do
       it "should list all files present" do
+        if Puppet::Util::Platform.windows? && digest_algorithm == "sha512"
+          skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+        end
         Puppet[:bucketdir] =  "/my/bucket"
         file_bucket = tmpdir("bucket")
 
@@ -190,6 +193,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
       end
 
       it "should filter with the provided dates" do
+        if Puppet::Util::Platform.windows? && digest_algorithm == "sha512"
+          skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+        end
         Puppet[:bucketdir] =  "/my/bucket"
         file_bucket = tmpdir("bucket")
 
@@ -294,6 +300,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   describe "backing up and retrieving local files" do
     with_digest_algorithms do
       it "should backup files to a local bucket" do
+        if Puppet::Util::Platform.windows? && digest_algorithm == "sha512"
+          skip "PUP-8257: Skip file bucket test on windows for #{digest_algorithm} due to long path names"
+        end
         Puppet[:bucketdir] = "/non/existent/directory"
         file_bucket = tmpdir("bucket")
 
@@ -311,7 +320,9 @@ describe Puppet::FileBucket::Dipper, :uses_checksums => true do
 
         file = make_tmp_file(plaintext)
 
-        Puppet::FileBucket::File.indirection.expects(:head).returns true
+        Puppet::FileBucket::File.indirection.expects(:head).with(
+          regexp_matches(%r{#{digest_algorithm}/#{checksum}}), :bucket_path => "/my/bucket"
+        ).returns true
         Puppet::FileBucket::File.indirection.expects(:save).never
         expect(@dipper.backup(file)).to eq(checksum)
       end

data/spec/unit/forge/module_release_spec.rb

@@ -215,4 +215,74 @@ describe Puppet::Forge::ModuleRelease do
 
     it_behaves_like 'a module release'
   end
+
+  context 'deprecated forge module' do
+    let(:release_json) do %Q{
+    {
+      "uri": "/#{api_version}/releases/#{module_full_name_versioned}",
+      "module": {
+        "uri": "/#{api_version}/modules/#{module_full_name}",
+        "name": "#{module_name}",
+        "deprecated_at": "2017-10-10 10:21:32 -0700",
+        "owner": {
+          "uri": "/#{api_version}/users/#{module_author}",
+          "username": "#{module_author}",
+          "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
+        }
+      },
+      "version": "#{module_version}",
+      "metadata": {
+        "types": [ ],
+        "license": "Apache 2.0",
+        "checksums": { },
+        "version": "#{module_version}",
+        "description": "Standard Library for Puppet Modules",
+        "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
+        "summary": "Puppet Module Standard Library",
+        "dependencies": [
+
+        ],
+        "author": "#{module_author}",
+        "name": "#{module_full_name}"
+      },
+      "tags": [
+        "puppetlabs",
+        "library",
+        "stdlib",
+        "standard",
+        "stages"
+      ],
+      "file_uri": "/#{api_version}/files/#{module_full_name_versioned}.tar.gz",
+      "file_size": 67586,
+      "file_md5": "#{module_md5}",
+      "downloads": 610751,
+      "readme": "",
+      "changelog": "",
+      "license": "",
+      "created_at": "2013-05-13 08:31:19 -0700",
+      "updated_at": "2013-05-13 08:31:19 -0700",
+      "deleted_at": null
+    }
+    }
+    end
+
+    it_behaves_like 'a module release'
+
+    describe '#prepare' do
+      before :each do
+        release.stubs(:tmpfile).returns(mock_file)
+        release.stubs(:tmpdir).returns(mock_dir)
+        release.stubs(:download)
+        release.stubs(:validate_checksum)
+        release.stubs(:unpack)
+      end
+
+      it 'should emit warning about module deprecation' do
+        Puppet.expects(:warning).with(regexp_matches(/#{Regexp.escape(module_full_name)}.*deprecated/i))
+
+        release.prepare
+      end
+    end
+  end
 end

data/spec/unit/functions/break_spec.rb

@@ -17,7 +17,16 @@ describe 'the break function' do
         CODE
     end
 
-    it 'breaks iteration as if at end of input in a reduce' do
+    it 'breaks iteration as if at end of input in a map for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[[1, 2]]')
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3}.map |$x, $y| { if $y == 3 { break() } $y }
+          }
+          notify { String(please_break()): }
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in a reduce for an array' do
       expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[6]')
           function please_break() {
             [1,2,3,4].reduce |$memo, $x| { if $x == 4 { break() } $memo + $x }
@@ -26,7 +35,21 @@ describe 'the break function' do
         CODE
     end
 
-    it 'breaks iteration as if at end of input in an each' do
+    it 'breaks iteration as if at end of input in a reduce for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to have_resource("Notify[['abc', 6]]")
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3, 'd' => 4}.reduce |$memo, $x| {
+	      if $x[1] == 4 { break() }
+              $string = "${memo[0]}${x[0]}"
+              $number = $memo[1] + $x[1]
+	      [$string, $number]
+	    }
+          }
+          notify { String(please_break()): }
+        CODE
+    end
+
+    it 'breaks iteration as if at end of input in an each for an array' do
       expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
           function please_break() {
             [1,2,3].each |$x| { if $x == 3 { break() } notify { "$x": } }
@@ -35,6 +58,15 @@ describe 'the break function' do
         CODE
     end
 
+    it 'breaks iteration as if at end of input in an each for a hash' do
+      expect(compile_to_catalog(<<-CODE)).to_not have_resource('Notify[3]')
+          function please_break() {
+            {'a' => 1, 'b' => 2, 'c' => 3}.each |$x, $y| { if $y == 3 { break() } notify { "$y": } }
+          }
+          please_break()
+        CODE
+    end
+
     it 'breaks iteration as if at end of input in a reverse_each' do
       expect(compile_to_catalog(<<-CODE)).to have_resource('Notify[2]')
           function please_break() {

data/spec/unit/functions/contain_spec.rb

@@ -295,4 +295,5 @@ describe 'The "contain" function' do
 
   it_should_behave_like 'all functions transforming relative to absolute names', :contain
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :contain
+  it_should_behave_like 'an inclusion function, when --tasks is on,', :contain
 end

data/spec/unit/functions/convert_to_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the convert_to function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  it 'converts and returns the converted when no lambda is given' do
+    expect(compile_to_catalog('notify{ "testing-${[a,1].convert_to(Hash) =~ Hash}": }')).to have_resource('Notify[testing-true]')
+  end
+
+  it 'converts given value to instance of type and calls a lambda with converted value' do
+    expect(compile_to_catalog('"1".convert_to(Integer) |$x| { notify { "testing-${x.type(generalized)}": } }')).to have_resource('Notify[testing-Integer]')
+  end
+
+  it 'returns the lambda return when lambda is given' do
+    expect(compile_to_catalog('notify{ "testing-${[a,1].convert_to(Hash) |$x| { yay }}": }')).to have_resource('Notify[testing-yay]')
+  end
+
+end

data/spec/unit/functions/epp_spec.rb

@@ -13,6 +13,11 @@ describe "the epp function" do
       expect(eval_template("all your base <%= $what %> to us")).to eq("all your base are belong to us")
     end
 
+    it "looks up a fully qualified value from the scope" do
+      scope["what::is"] = "are belong"
+      expect(eval_template("all your base <%= $what::is %> to us")).to eq("all your base are belong to us")
+    end
+
     it "get nil accessing a variable that does not exist" do
       expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end

data/spec/unit/functions/include_spec.rb

@@ -98,6 +98,20 @@ describe 'The "include" function' do
     }.to raise_error(Puppet::Error)
   end
 
+    { "''"      => 'empty string', 
+      'undef'   => 'undef',
+      "['']"    => 'empty string',
+      "[undef]" => 'undef'
+    }.each_pair do |value, name_kind|
+      it "raises an error if class is #{name_kind}" do
+        expect {
+          catalog = compile_to_catalog(<<-MANIFEST)
+            include #{value}
+          MANIFEST
+        }.to raise_error(/Cannot use #{name_kind}/)
+      end
+    end
+
   it "does not contained the included class in the current class" do
     catalog = compile_to_catalog(<<-MANIFEST)
       class not_contained {
@@ -171,5 +185,6 @@ describe 'The "include" function' do
 
   it_should_behave_like 'all functions transforming relative to absolute names', :include
   it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
+  it_should_behave_like 'an inclusion function, when --tasks is on,', :include
 
 end

data/spec/unit/functions/module_directory_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the module_directory function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  it 'returns first found module from one or more given names' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory('one', 'two'):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns first found module from one or more given names in an array' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { module_directory(['one', 'two']):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(mod)
+    expect(compiler.compile()).to have_resource("Notify[expected_path]")
+  end
+
+  it 'returns undef when none of the modules were found' do
+    mod = mock 'module'
+    mod.stubs(:path).returns('expected_path')
+    Puppet[:code] = "notify { String(type(module_directory('one', 'two'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    compiler.environment.stubs(:module).with('one').returns(nil)
+    compiler.environment.stubs(:module).with('two').returns(nil)
+    expect(compiler.compile()).to have_resource("Notify[Undef]")
+  end
+end