puppet 6.0.5-x86-mingw32 → 6.0.7-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::Util:
         '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/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

@@ -33,11 +33,13 @@ describe 'Puppet::Type::Service::Provider::Systemd', unless: Puppet::Util::Platf
     end
   end
 
-  it "should be the default provider on rhel7" do
-    Facter.stubs(:value).with(:osfamily).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystem).returns(:redhat)
-    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("7")
-    expect(provider_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(:operatingsystem).returns(:redhat)
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns(ver.to_s)
+      expect(provider_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 package provider 'pkgng': 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/execution_spec.rb

@@ -158,7 +158,6 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
       context 'cwd option' do
         let(:cwd) { 'cwd' }
         it "should execute the command in the specified working directory" do
-          Dir.expects(:chdir).with(cwd).yields
           Process.expects(:create).with(
             :command_line => "test command",
             :startup_info => {
@@ -166,7 +165,8 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
               :stdout => @stdout,
               :stderr => @stderr
             },
-            :close_handles => false
+            :close_handles => false,
+            :cwd => cwd
           )
 
           call_exec_windows('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)

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/pidlock_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 require 'puppet/util/pidlock'
 
-describe Puppet::Util::Pidlock do
+describe Puppet::Util::Pidlock, if: !Puppet::Util::Platform.jruby? do
   require 'puppet_spec/files'
   include PuppetSpec::Files
 
@@ -23,6 +23,11 @@ describe Puppet::Util::Pidlock do
 
     it "should become locked" do
       @lock.lock
+      if Puppet::Util::Platform.windows?
+        Puppet::Util::Windows::Process.stubs(:get_process_image_name_by_pid).with(@lock.lock_pid).returns('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        Puppet::Util::Execution.stubs(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).returns('puppet')
+      end
       expect(@lock).to be_locked
     end
 
@@ -101,6 +106,11 @@ describe Puppet::Util::Pidlock do
   describe "#locked?" do
     it "should return true if locked" do
       @lock.lock
+      if Puppet::Util::Platform.windows?
+        Puppet::Util::Windows::Process.stubs(:get_process_image_name_by_pid).with(@lock.lock_pid).returns('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        Puppet::Util::Execution.stubs(:execute).with(['ps', '-p', @lock.lock_pid, '-o', 'comm=']).returns('puppet')
+      end
       expect(@lock).to be_locked
     end
 
@@ -146,6 +156,11 @@ describe Puppet::Util::Pidlock do
       end
 
       it "should replace with new locks" do
+        if Puppet::Util::Platform.windows?
+          Puppet::Util::Windows::Process.stubs(:get_process_image_name_by_pid).with(6789).returns('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+        else
+          Puppet::Util::Execution.stubs(:execute).with(['ps', '-p', 6789, '-o', 'comm=']).returns('puppet')
+        end
         @lock.lock
         expect(Puppet::FileSystem.exist?(@lockfile)).to be_truthy
         expect(@lock.lock_pid).to eq(6789)
@@ -170,6 +185,11 @@ describe Puppet::Util::Pidlock do
     before(:each) do
       # fake our pid to be 1234
       Process.stubs(:pid).returns(1234)
+      if Puppet::Util::Platform.windows?
+        Puppet::Util::Windows::Process.stubs(:get_process_image_name_by_pid).with(1234).returns('C:\Program Files\Puppet Labs\Puppet\puppet\bin\ruby.exe')
+      else
+        Puppet::Util::Execution.stubs(:execute).with(['ps', '-p', 1234, '-o', 'comm=']).returns('puppet')
+      end
       # lock the file
       @lock.lock
       # fake our pid to be a different pid, to simulate someone else

data/spec/unit/util/storage_spec.rb

@@ -181,6 +181,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]
@@ -232,13 +234,13 @@ describe Puppet::Util::Storage do
       stale_checked = recent_checked - (Puppet[:statettl] + 10)
       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)
           }
         }
       )
@@ -250,29 +252,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.round
       older_checked = recent_checked - 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)
           }
         }
       )
@@ -284,32 +285,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)
           }
         }
       )
@@ -321,13 +321,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)
           }
         }
       )