puppet 5.5.10-x86-mingw32 → 5.5.12-x86-mingw32

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

@@ -244,6 +244,15 @@ describe 'the type mismatch describer' do
     expect { eval_and_collect_notices(code) }.to(raise_error(Puppet::Error,
       /Class\[Test\]: parameter 'opts' expects size to be 1, got 0/))
   end
+
+  it "treats Optional as Optional[Any]" do
+    code = <<-PUPPET
+      class test(Optional $var=undef) {}
+      class { 'test': var => 'hello' }
+    PUPPET
+    expect { eval_and_collect_notices(code) }.not_to raise_error
+  end
+
 end
 end
 end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -251,7 +251,13 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         'user3',
       ]
 
-      expect(provider.members).to match_array([user1.sid, user2.sid, user3.sid])
+      expected_member_sids = [user1.sid, user2.sid, user3.sid]
+      expected_members = ['user1', 'user2', 'user3']
+      provider.stubs(:members_to_s)
+        .with(expected_member_sids)
+        .returns(expected_members.join(','))
+
+      expect(provider.members).to match_array(expected_members)
     end
 
     it "should be able to set group members" do

data/spec/unit/provider/mount/parsed_spec.rb

@@ -172,6 +172,7 @@ FSTAB
       expect(mounts[2]).to eq({ :name => '/sys', :mounted => :yes })
       expect(mounts[3]).to eq({ :name => '/usr/portage', :mounted => :yes })
       expect(mounts[4]).to eq({ :name => '/ghost', :mounted => :yes })
+      expect(mounts[5]).to eq({ :name => '/run', :mounted => :yes})
     end
 
     it "should get name from mountoutput found on AIX" do
@@ -283,10 +284,11 @@ FSTAB
         @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
         @res_unmounted = Puppet::Type::Mount.new(:name => '/boot') # in every fake fstab
         @res_absent = Puppet::Type::Mount.new(:name => '/absent')  # in no fake fstab
+        @res_trailing_slash = Puppet::Type::Mount.new(:name => '/run/') # in every fake fstab
 
         # Simulate transaction.rb:prefetch
         @resource_hash = {}
-        [@res_ghost, @res_mounted, @res_unmounted, @res_absent].each do |resource|
+        [@res_ghost, @res_mounted, @res_unmounted, @res_absent, @res_trailing_slash].each do |resource|
           @resource_hash[resource.name] = resource
         end
       end
@@ -306,6 +308,11 @@ FSTAB
           described_class.prefetch(@resource_hash)
           expect(@res_mounted.provider.get(:ensure)).to eq(:mounted)
         end
+
+        it 'strips trailing slashes from resource titles' do
+          described_class.prefetch(@resource_hash)
+          expect(@res_trailing_slash.provider.get(:ensure)).to eq(:mounted)
+        end
       end
 
       it "should set :ensure to :absent if not found in fstab and not mounted" do

data/spec/unit/provider/package/windows_spec.rb

@@ -86,7 +86,7 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
   context '#install' do
     let(:command) { 'blarg.exe /S' }
     let(:klass) { mock('installer', :install_command => ['blarg.exe', '/S'] ) }
-    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
+    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => nil, :suppress_window => true} end
     before :each do
       Puppet::Provider::Package::Windows::Package.expects(:installer_class).returns(klass)
     end
@@ -136,6 +136,17 @@ describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.
         expect(error.code).to eq(5) # ERROR_ACCESS_DENIED
       end
     end
+
+    context 'With a real working dir' do
+      let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
+
+      it 'should not try to set the working directory' do
+        Puppet::FileSystem.expects(:exist?).with('E:\Rando\Directory').returns(true)
+        expect_execute(command, 0)
+
+        provider.install
+      end
+    end
   end
 
   context '#uninstall' do

data/spec/unit/provider/service/systemd_spec.rb

@@ -30,10 +30,12 @@ describe Puppet::Type.type(:service).provider(:systemd) do
     end
   end
 
-  it "should be the default provider on rhel7" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-    expect(described_class).to be_default
+  [7, 8].each do |ver|
+    it "should be the default provider on rhel#{ver}" do
+      Facter.stubs(:value).with(:osfamily).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns(ver.to_s)
+      expect(described_class).to be_default
+    end
   end
 
   [ 4, 5, 6 ].each do |ver|

data/spec/unit/settings_spec.rb

@@ -702,6 +702,42 @@ describe Puppet::Settings do
         @settings.send(:parse_config_files)
       end
     end
+
+    describe "when the file exists" do
+      it "fails if the file is not readable" do
+        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(true)
+        @settings.expects(:read_file).raises('Permission denied')
+
+        expect{ @settings.send(:parse_config_files) }.to raise_error(RuntimeError, /Could not load #{user_config_file_default_location}: Permission denied/)
+      end
+
+      it "does not fail if the file is not readable and when `require_config` is false" do
+        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(true)
+        @settings.expects(:read_file).raises('Permission denied')
+
+        @settings.expects(:parse_config).never
+        Puppet.expects(:log_exception)
+
+        expect{ @settings.send(:parse_config_files, false) }.not_to raise_error
+      end
+
+      it "reads the file if it is readable" do
+        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(true)
+        @settings.expects(:read_file).returns('server = host.string')
+        @settings.expects(:parse_config)
+
+        @settings.send(:parse_config_files)
+      end
+    end
+
+    describe "when the file does not exist" do
+      it "does not attempt to parse the config file" do
+        Puppet::FileSystem.expects(:exist?).with(user_config_file_default_location).returns(false)
+        @settings.expects(:parse_config).never
+
+        @settings.send(:parse_config_files)
+      end
+    end
   end
 
   describe "when parsing its configuration" do

data/spec/unit/transaction/resource_harness_spec.rb

@@ -601,4 +601,30 @@ describe Puppet::Transaction::ResourceHarness do
     Puppet::Util::Storage.expects(:cache).with(@resource).returns data
     expect(@harness.cached(@resource, :foo)).to eq("other")
   end
+
+  describe "successful event message" do
+    let(:test_file) do
+      tmpfile('foo').tap do |path|
+        File.open(path, 'w') { |fh| fh.write("old contents") }
+      end
+    end
+
+    let(:resource) do
+      Puppet::Type.type(:file).new(:path => test_file, :backup => false, :content => "hello world")
+    end
+
+    it "contains (corrective) when corrective change" do
+      Puppet::Transaction::Event.any_instance.stubs(:corrective_change).returns(true)
+      status = @harness.evaluate(resource)
+      sync_event = status.events[0]
+      expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+' \(corrective\)/)
+    end
+
+    it "contains no modifier when intentional change" do
+      Puppet::Transaction::Event.any_instance.stubs(:corrective_change).returns(false)
+      status = @harness.evaluate(resource)
+      sync_event = status.events[0]
+      expect(sync_event.message).to match(/content changed '{md5}[0-9a-f]+' to '{md5}[0-9a-f]+'$/)
+    end
+  end
 end

data/spec/unit/transaction_spec.rb

@@ -600,6 +600,30 @@ describe Puppet::Transaction do
       transaction.prefetch_if_necessary(resource)
     end
 
+    it "should not rescue SystemExit without future_features flag" do
+      Puppet.settings[:future_features] = false
+      resource.provider.class.expects(:prefetch).raises(SystemExit, "SystemMessage")
+      expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
+    end
+
+    it "should not rescue SystemExit with future_features flag" do
+      Puppet.settings[:future_features] = true
+      resource.provider.class.expects(:prefetch).raises(SystemExit, "SystemMessage")
+      expect { transaction.prefetch_if_necessary(resource) }.to raise_error(SystemExit, "SystemMessage")
+    end
+
+    it "should rescue LoadError without future_features flag" do
+      Puppet.settings[:future_features] = false
+      resource.provider.class.expects(:prefetch).raises(LoadError, "LoadMessage")
+      expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
+    end
+
+    it "should rescue LoadError with future_features flag" do
+      Puppet.settings[:future_features] = true
+      resource.provider.class.expects(:prefetch).raises(LoadError, "LoadMessage")
+      expect { transaction.prefetch_if_necessary(resource) }.not_to raise_error
+    end
+
     describe "and prefetching fails" do
       before :each do
         resource.provider.class.expects(:prefetch).raises(Puppet::Error, "message")
@@ -613,6 +637,11 @@ describe Puppet::Transaction do
         it "should not rescue prefetch executions" do
           expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error)
         end
+
+        it "should log the exception during prefetch" do
+          Puppet.expects(:log_exception).with(anything, "Could not prefetch sshkey provider 'parsed': message")
+          expect { transaction.prefetch_if_necessary(resource) }.to raise_error(Puppet::Error, "message")
+        end
       end
 
       context "with future_features flag" do

data/spec/unit/type/exec_spec.rb

@@ -31,6 +31,33 @@ describe Puppet::Type.type(:exec) do
     return exec
   end
 
+  def exec_stub(options = {})
+    command = options.delete(:command) || @command
+    #unless_val = options.delete(:unless) || :true
+    type_args = {
+      :name   => command,
+      #:unless => unless_val,
+    }.merge(options)
+
+    # Chicken, meet egg:
+    # Provider methods have to be stubbed before resource init or checks fail
+    # We have to set 'unless' in resource init or it can not be marked sensitive correctly.
+    # So: we create a dummy ahead of time and use 'any_instance' to stub out provider methods.
+    dummy = Puppet::Type.type(:exec).new(:name => @command)
+    dummy.provider.class.any_instance.stubs(:validatecmd)
+    dummy.provider.class.any_instance.stubs(:checkexe).returns(true)
+    pass_status = stub('status', :exitstatus => 0, :split => ["pass output"])
+    fail_status = stub('status', :exitstatus => 1, :split => ["fail output"])
+    Puppet::Util::Execution.stubs(:execute).with(:true, anything).returns(pass_status)
+    Puppet::Util::Execution.stubs(:execute).with(:false, anything).returns(fail_status)
+
+    test = Puppet::Type.type(:exec).new(type_args)
+
+    Puppet::Util::Log.level = :debug
+
+    return test
+  end
+
   before do
     @command = make_absolute('/bin/true whatever')
     @executable = make_absolute('/bin/true')
@@ -176,6 +203,26 @@ describe Puppet::Type.type(:exec) do
       expect(@logs).to eq([])
     end
 
+    describe "when checks stop execution when debugging" do
+      [[:unless, :true], [:onlyif, :false]].each do |check, result|
+        it "should log a message with the command when #{check} is #{result}" do
+          output = "'#{@command}' won't be executed because of failed check '#{check}'"
+          test = exec_stub({:command => @command, check => result})
+          expect(test.check_all_attributes).to eq(false)
+          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output))
+        end
+
+        it "should log a message with a redacted command and check if #{check} is sensitive" do
+          output1 = "Executing check '[redacted]'"
+          output2 = "'[command redacted]' won't be executed because of failed check '#{check}'"
+          test = exec_stub({:command => @command, check => result, :sensitive_parameters => [check]})
+          expect(test.check_all_attributes).to eq(false)
+          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output1))
+          expect(@logs).to include(an_object_having_attributes(level: :debug, message: output2))
+        end
+      end
+    end
+
     describe " when multiple tries are set," do
       it "should repeat the command attempt 'tries' times on failure and produce an error" do
         tries = 5

data/spec/unit/type/filebucket_spec.rb

@@ -21,14 +21,14 @@ describe Puppet::Type.type(:filebucket) do
     expect(Puppet::Type.type(:filebucket).new(:name => "main")[:path]).to eq(Puppet[:clientbucketdir])
   end
 
-  it "should use the masterport as the path by default port" do
+  it "should not have a default port" do
     Puppet.settings[:masterport] = 50
-    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:port]).to eq(Puppet[:masterport])
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:port]).to eq(nil)
   end
 
-  it "should use the server as the path by default server" do
+  it "should not have a default server" do
     Puppet.settings[:server] = "myserver"
-    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:server]).to eq(Puppet[:server])
+    expect(Puppet::Type.type(:filebucket).new(:name => "main")[:server]).to eq(nil)
   end
 
   it "be local by default" do
@@ -93,10 +93,12 @@ describe Puppet::Type.type(:filebucket) do
       bucket.bucket
     end
 
-    it "should use the default server if the path is unset and no server is provided" do
+    it "should not try to guess server or port if the path is unset and no server is provided" do
       Puppet.settings[:server] = "myserv"
+      Puppet.settings[:server_list] = ['server_list_0', 'server_list_1']
+      Puppet::FileBucket::Dipper.expects(:new).with(:Server => nil, :Port => nil).returns @bucket
+
       bucket = Puppet::Type.type(:filebucket).new :name => "main", :path => false
-      Puppet::FileBucket::Dipper.expects(:new).with { |args| args[:Server] == "myserv" }.returns @bucket
       bucket.bucket
     end
   end

data/spec/unit/util/command_line_spec.rb

@@ -67,8 +67,8 @@ describe Puppet::Util::CommandLine do
       end
     end
 
-    %w{--help -h}.each do|arg|
-      it "should print help" do
+    %w{--help -h help}.each do|arg|
+      it "should print help and exit if #{arg} is given" do
         commandline = Puppet::Util::CommandLine.new("puppet", [arg])
         commandline.expects(:exec).never
 
@@ -77,6 +77,27 @@ describe Puppet::Util::CommandLine do
         }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
       end
     end
+
+    it "should fail if the config file isn't readable and we're running a subcommand that requires a readable config file" do
+      Puppet::FileSystem.stubs(:exist?).with(Puppet[:config]).returns(true)
+      Puppet::Settings.any_instance.stubs(:read_file).returns('')
+      Puppet::Settings.any_instance.expects(:read_file).with(Puppet[:config]).raises('Permission denied')
+
+      expect{ described_class.new("puppet", ['config']).execute }.to raise_error(SystemExit)
+    end
+
+    it "should not fail if the config file isn't readable and we're running a subcommand that does not require a readable config file" do
+      Puppet::FileSystem.stubs(:exist?)
+      Puppet::FileSystem.stubs(:exist?).with(Puppet[:config]).returns(true)
+      Puppet::Settings.any_instance.stubs(:read_file).returns('')
+      Puppet::Settings.any_instance.expects(:read_file).with(Puppet[:config]).raises('Permission denied')
+
+      commandline = described_class.new("puppet", ['help'])
+
+      expect {
+        commandline.execute
+      }.to have_printed(/Usage: puppet <subcommand> \[options\] <action> \[options\]/).and_exit_with(0)
+    end
   end
 
   describe "when dealing with puppet commands" do

data/spec/unit/util/log_spec.rb

@@ -88,6 +88,21 @@ describe Puppet::Util::Log do
     expect(logs.last.source).to eq(utf_8_msg)
   end
 
+  require 'puppet/util/log/destinations'
+
+  it "raises an error when it has no successful logging destinations" do
+    # spec_helper.rb redirects log output away from the console,
+    # so we have to stop that here, or else the logic we are testing
+    # will not be reached.
+    Puppet::Util::Log.stubs(:destinations).returns({})
+
+    our_exception = Puppet::DevError.new("test exception")
+    Puppet::FileSystem.expects(:dir).raises(our_exception)
+    bad_file = tmpfile("bad_file")
+
+    expect { Puppet::Util::Log.newdestination(bad_file) }.to raise_error(Puppet::DevError)
+  end
+
   describe ".setup_default" do
     it "should default to :syslog" do
       Puppet.features.stubs(:syslog?).returns(true)

data/spec/unit/util/storage_spec.rb

@@ -169,6 +169,8 @@ describe Puppet::Util::Storage do
   end
 
   describe "when storing to the state file" do
+    A_SMALL_AMOUNT_OF_TIME = 0.001 #Seconds
+
     before(:each) do
       @state_file = tmpfile('storage_test')
       @saved_statefile = Puppet[:statefile]
@@ -220,13 +222,13 @@ describe Puppet::Util::Storage do
       stale_checked = Time.now - (Puppet[:statettl] + 1)
       Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
       Puppet::Util::Storage.cache(:stale)[:checked] = stale_checked
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           },
           :stale => {
-            :checked => stale_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(stale_checked)
           }
         }
       )
@@ -238,29 +240,28 @@ describe Puppet::Util::Storage do
 
       Puppet::Util::Storage.load
 
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           }
         }
       )
     end
 
-
     it "does not expire entries when statettl is 0" do
       Puppet[:statettl] = '0'
       recent_checked = Time.now
       older_checked = Time.now - 10_000_000
       Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
       Puppet::Util::Storage.cache(:older)[:checked] = older_checked
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           },
           :older => {
-            :checked => older_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
           }
         }
       )
@@ -272,32 +273,31 @@ describe Puppet::Util::Storage do
 
       Puppet::Util::Storage.load
 
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           },
           :older => {
-            :checked => older_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
           }
         }
       )
     end
 
-
     it "does not expire entries when statettl is 'unlimited'" do
       Puppet[:statettl] = 'unlimited'
       recent_checked = Time.now
       older_checked = Time.now - 10_000_000
       Puppet::Util::Storage.cache(:yayness)[:checked] = recent_checked
       Puppet::Util::Storage.cache(:older)[:checked] = older_checked
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           },
           :older => {
-            :checked => older_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
           }
         }
       )
@@ -309,13 +309,13 @@ describe Puppet::Util::Storage do
 
       Puppet::Util::Storage.load
 
-      expect(Puppet::Util::Storage.state).to eq(
+      expect(Puppet::Util::Storage.state).to match(
         {
           :yayness => {
-            :checked => recent_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(recent_checked)
           },
           :older => {
-            :checked => older_checked
+            :checked => a_value_within(A_SMALL_AMOUNT_OF_TIME).of(older_checked)
           }
         }
       )