puppet 6.0.0 → 6.1.0

data/spec/unit/transaction/persistence_spec.rb

@@ -73,7 +73,7 @@ describe Puppet::Transaction::Persistence do
       it "should initialize with a clear internal state if the file does not contain valid YAML" do
         write_state_file('{ invalid')
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load
@@ -97,8 +97,8 @@ describe Puppet::Transaction::Persistence do
 
         File.expects(:rename).raises(SystemCallError)
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
-        Puppet.expects(:err).with(regexp_matches(/Unable to rename/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Unable to rename/))
 
         persistence = Puppet::Transaction::Persistence.new
         expect { persistence.load }.to raise_error(Puppet::Error, /Could not rename/)
@@ -109,7 +109,7 @@ describe Puppet::Transaction::Persistence do
 
         File.expects(:rename).at_least_once
 
-        Puppet.expects(:err).with(regexp_matches(/Transaction store file .* is corrupt/))
+        Puppet.expects(:send_log).with(:err, regexp_matches(/Transaction store file .* is corrupt/))
 
         persistence = Puppet::Transaction::Persistence.new
         persistence.load

data/spec/unit/transaction/resource_harness_spec.rb

@@ -173,6 +173,10 @@ describe Puppet::Transaction::ResourceHarness do
           def insync?(value)
             @resource.behaviors[:ensure_insync?]
           end
+
+          def should_to_s(value)
+            (@resource.behaviors[:on_should_to_s] || proc { "'#{value}'" }).call
+          end
         end
 
         newparam(:name) do
@@ -266,6 +270,20 @@ describe Puppet::Transaction::ResourceHarness do
 
       expect(status.events).to be_empty
     end
+
+    it "ensure errors in message still get a log entry" do
+      resource = an_ensurable_resource_reacting_as(:ensure_insync? => false, :on_ensure => proc { raise StandardError }, :on_should_to_s => proc { raise StandardError }, :present? => true)
+
+      status = @harness.evaluate(resource)
+
+      expect(status.events.length).to eq(2)
+      testing_errors = status.events.find_all { |x| x.name.to_s == "Testing_created" }
+      resource_errors = status.events.find_all { |x| x.name.to_s == "resource_error" }
+      expect(testing_errors.length).to eq(1)
+      expect(resource_errors.length).to eq(1)
+      expect(testing_errors[0].message).not_to be_nil
+      expect(resource_errors[0].message).not_to eq("Puppet::Util::Log requires a message")
+    end
   end
 
   describe "when a caught error occurs" do

data/spec/unit/type/group_spec.rb

@@ -72,7 +72,15 @@ describe Puppet::Type.type(:group) do
 
   describe "should delegate :members implementation to the provider:"  do
 
-    let (:provider) { @class.provide(:testing) { has_features :manages_members } }
+    let (:provider) do
+      @class.provide(:testing) do
+        has_features :manages_members
+
+        def members
+          []
+        end
+      end
+    end
     let (:provider_instance) { provider.new }
     let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
@@ -82,11 +90,11 @@ describe Puppet::Type.type(:group) do
     end
 
     it "is_to_s and should_to_s call members_to_s" do
-      provider_instance.expects(:members_to_s).with(['user2', 'user1']).returns "user2 (), user1 ()"
+      provider_instance.expects(:members_to_s).with(['user1', 'user2']).returns "user1 (), user2 ()"
       provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
 
       expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
-      expect(type.property(:members).should_to_s('user2,user1')).to eq('user2 (), user1 ()')
+      expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')
     end
   end
 end

data/spec/unit/type/resources_spec.rb

@@ -100,6 +100,24 @@ describe resources do
         user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
         expect(res.user_check(user)).to be_falsey
       end
+
+      it "should not purge Windows system users" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
+        res.catalog = Puppet::Resource::Catalog.new
+        user_hash = {:name => 'Administrator', :uid => 'S-1-5-21-12345-500'}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        expect(res.user_check(user)).to be_falsey
+      end
+
+      it "should not purge Windows system users" do
+        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
+        res.catalog = Puppet::Resource::Catalog.new
+        user_hash = {:name => 'other', :uid => 'S-1-5-21-12345-1001'}
+        user = Puppet::Type.type(:user).new(user_hash)
+        user.stubs(:retrieve_resource).returns Puppet::Resource.new("user", user_hash[:name], :parameters => user_hash)
+        expect(res.user_check(user)).to be_truthy
+      end
     end
 
     %w(FreeBSD OpenBSD).each do |os|

data/spec/unit/type/service_spec.rb

@@ -29,7 +29,7 @@ end
 describe test_title, "when validating attributes" do
   safely_load_service_type
 
-  [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control].each do |param|
+  [:name, :binary, :hasstatus, :path, :pattern, :start, :restart, :stop, :status, :hasrestart, :control, :timeout].each do |param|
     it "should have a #{param} parameter" do
       expect(Puppet::Type.type(:service).attrtype(param)).to eq(:param)
     end
@@ -103,6 +103,32 @@ describe test_title, "when validating attribute values" do
     end
   end
 
+  describe "the timeout parameter" do
+    before do
+      provider_class_with_timeout = Puppet::Type.type(:service).provide(:simple) do
+        has_features :configurable_timeout
+      end
+      Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class_with_timeout
+    end
+
+    it "should fail when timeout is not an integer" do
+      expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => 'foobar') }.to raise_error(Puppet::Error)
+    end
+
+    [-999, -1, 0].each do |int|
+      it "should not support #{int} as a value to :timeout" do
+        expect { Puppet::Type.type(:service).new(:name => "yay", :timeout => int) }.to raise_error(Puppet::Error)
+      end
+    end
+
+    [1, 30, 999].each do |int|
+      it "should support #{int} as a value to :timeout" do
+        srv = Puppet::Type.type(:service).new(:name => "yay", :timeout => int)
+        expect(srv[:timeout]).to eq(int)
+      end
+    end
+  end
+
   it "should support :true as a value to :hasstatus" do
     srv = Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
     expect(srv[:hasstatus]).to eq(:true)

data/spec/unit/util/execution_spec.rb

@@ -119,6 +119,17 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
         call_exec_posix("/bin/echo 'foo' ; \n /bin/echo 'bar' ;", {:uid => 50, :gid => 55}, @stdin, @stdout, @stderr)
       end
 
+      context 'cwd option' do
+        let(:cwd) { 'cwd' }
+
+        it 'should run the command in the specified working directory' do
+          Dir.expects(:chdir).with(cwd)
+          Kernel.expects(:exec).with('test command')
+
+          call_exec_posix('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the pid of the child process" do
         expect(call_exec_posix('test command', {}, @stdin, @stdout, @stderr)).to eq(pid)
       end
@@ -144,6 +155,42 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
         call_exec_windows('test command', {}, @stdin, @stdout, @stderr)
       end
 
+      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 => {
+              :stdin => @stdin,
+              :stdout => @stdout,
+              :stderr => @stderr
+            },
+            :close_handles => false
+          )
+
+          call_exec_windows('test command', { :cwd => cwd }, @stdin, @stdout, @stderr)
+        end
+      end
+
+      context 'suppress_window option' do
+        let(:cwd) { 'cwd' }
+        it "should execute the command in the specified working directory" do
+          Process.expects(:create).with(
+            :command_line => "test command",
+            :startup_info => {
+              :stdin => @stdin,
+              :stdout => @stdout,
+              :stderr => @stderr
+            },
+            :close_handles => false,
+            :creation_flags => Puppet::Util::Windows::Process::CREATE_NO_WINDOW
+          )
+
+          call_exec_windows('test command', { :suppress_window => true }, @stdin, @stdout, @stderr)
+        end
+      end
+
       it "should return the process info of the child process" do
         expect(call_exec_windows('test command', {}, @stdin, @stdout, @stderr)).to eq(proc_info_stub)
       end
@@ -219,6 +266,36 @@ describe Puppet::Util::Execution, if: !Puppet::Util::Platform.jruby? do
           end
         end
 
+        describe "cwd option" do
+          def expect_cwd_to_be(cwd)
+            Puppet::Util::Execution.expects(executor).with(
+              anything,
+              has_entries(:cwd => cwd),
+              anything,
+              anything,
+              anything
+            ).returns(rval)
+          end
+
+          it 'should raise an ArgumentError if the specified working directory does not exist' do
+            cwd = 'cwd'
+            Puppet::FileSystem.stubs(:directory?).with(cwd).returns(false)
+
+            expect {
+              Puppet::Util::Execution.execute('test command', cwd: cwd)
+            }.to raise_error do |error|
+              expect(error).to be_a(ArgumentError)
+              expect(error.message).to match(cwd)
+            end
+          end
+
+          it "should set the cwd to the user-specified one" do
+            Puppet::FileSystem.stubs(:directory?).with('cwd').returns(true)
+            expect_cwd_to_be('cwd')
+            Puppet::Util::Execution.execute('test command', cwd: 'cwd')
+          end
+        end
+
         describe "on POSIX", :if => Puppet.features.posix? do
           describe "when squelch is not set" do
             it "should set stdout to a pipe" do

data/spec/unit/util/filetype_spec.rb

@@ -107,6 +107,10 @@ describe Puppet::Util::FileType do
     end
 
     describe "#read" do
+      before(:each) do
+        Puppet::Util.stubs(:uid).with(uid).returns 9000
+      end
+
       it "should run crontab -l as the target user" do
         Puppet::Util::Execution.expects(:execute)
           .with(['crontab', '-l'], user_options)
@@ -115,7 +119,7 @@ describe Puppet::Util::FileType do
       end
 
       it "should not switch user if current user is the target user" do
-        Puppet::Util.expects(:uid).with(uid).returns 9000
+        Puppet::Util.expects(:uid).with(uid).twice.returns 9000
         Puppet::Util::SUIDManager.expects(:uid).returns 9000
         Puppet::Util::Execution
           .expects(:execute).with(['crontab', '-l'], options)
@@ -128,11 +132,15 @@ describe Puppet::Util::FileType do
         expect(cron.read).to eq('')
       end
 
-      it "should raise an error if the user is not authorized to use cron" do
+      it "should treat a nonexistent user's crontab as empty" do
+        Puppet::Util.expects(:uid).with(uid).returns nil
+
+        expect(cron.read).to eq('')
+      end
+
+      it "should return empty if the user is not authorized to use cron" do
         Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, unauthorized_crontab)
-        expect {
-          cron.read
-        }.to raise_error Puppet::Error, /User #{uid} not authorized to use cron/
+        expect(cron.read).to eq('')
       end
     end
 

data/spec/unit/util/log/destinations_spec.rb

@@ -54,6 +54,7 @@ describe Puppet::Util::Log.desttypes[:file] do
         it_behaves_like "file destination"
 
         it "logs an error if it can't chown the file owner & group" do
+          File.expects(:exists?).with(abspath).returns(false)
           FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
           Puppet.features.expects(:root?).returns(true)
           Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
@@ -62,11 +63,20 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when running as non-root" do
+          File.expects(:exists?).with(abspath).returns(false)
           FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
           Puppet.features.expects(:root?).returns(false)
 
           @class.new(abspath)
         end
+
+        it "doesn't attempt to chown when file already exists" do
+          File.expects(:exists?).with(abspath).returns(true)
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(true)
+
+          @class.new(abspath)
+        end
       end
 
       describe "with a JSON file" do

data/spec/unit/util/logging_spec.rb

@@ -99,6 +99,64 @@ describe Puppet::Util::Logging do
     end
   end
 
+  describe "log_exception" do
+    context "when requesting a debug level it is logged at debug" do
+      it "the exception is a ParseErrorWithIssue and message is :default" do
+        Puppet::Util::Log.expects(:create).with do |args|
+          expect(args[:message]).to eq("Test")
+          expect(args[:level]).to eq(:debug)
+        end
+
+        begin
+          raise Puppet::ParseErrorWithIssue, "Test"
+        rescue Puppet::ParseErrorWithIssue => err
+          Puppet.log_exception(err, :default, level: :debug)
+        end
+      end
+
+      it "the exception is something else" do
+        Puppet::Util::Log.expects(:create).with do |args|
+          expect(args[:message]).to eq("Test")
+          expect(args[:level]).to eq(:debug)
+        end
+
+        begin
+          raise Puppet::Error, "Test"
+        rescue Puppet::Error => err
+          Puppet.log_exception(err, :default, level: :debug)
+        end
+      end
+    end
+
+    context "no log level is requested it defaults to err" do
+      it "the exception is a ParseErrorWithIssue and message is :default" do
+        Puppet::Util::Log.expects(:create).with do |args|
+          expect(args[:message]).to eq("Test")
+          expect(args[:level]).to eq(:err)
+        end
+
+        begin
+          raise Puppet::ParseErrorWithIssue, "Test"
+        rescue Puppet::ParseErrorWithIssue => err
+          Puppet.log_exception(err)
+        end
+      end
+
+      it "the exception is something else" do
+        Puppet::Util::Log.expects(:create).with do |args|
+          expect(args[:message]).to eq("Test")
+          expect(args[:level]).to eq(:err)
+        end
+
+        begin
+          raise Puppet::Error, "Test"
+        rescue Puppet::Error => err
+          Puppet.log_exception(err)
+        end
+      end
+    end
+  end
+
   describe "when sending a deprecation warning" do
     it "does not log a message when deprecation warnings are disabled" do
       Puppet.expects(:[]).with(:disable_warnings).returns %w[deprecations]
@@ -302,21 +360,6 @@ original
       Facter.unstub(:debugging)
     end
 
-    describe 'does not support debugging' do
-      before :each do
-        Facter.stubs(:respond_to?).with(:debugging).returns false
-        Facter.stubs(:debugging).never
-      end
-
-      it 'does not enable Facter debugging for debug level' do
-        Puppet::Util::Log.level = :debug
-      end
-
-      it 'does not enable Facter debugging non-debug level' do
-        Puppet::Util::Log.level = :info
-      end
-    end
-
     describe 'does support debugging' do
       before :each do
         Facter.stubs(:respond_to?).with(:debugging).returns true
@@ -333,21 +376,6 @@ original
       end
     end
 
-    describe 'does not support trace' do
-      before :each do
-        Facter.stubs(:respond_to?).with(:trace).returns false
-        Facter.stubs(:trace).never
-      end
-
-      it 'does not enable Facter trace when enabled' do
-        Puppet[:trace] = true
-      end
-
-      it 'does not enable Facter trace when disabled' do
-        Puppet[:trace] = false
-      end
-    end
-
     describe 'does support trace' do
       before :each do
         Facter.stubs(:respond_to?).with(:trace).returns true
@@ -364,17 +392,6 @@ original
       end
     end
 
-    describe 'does not support on_message' do
-      before :each do
-        Facter.stubs(:respond_to?).with(:on_message).returns false
-        Facter.stubs(:on_message).never
-      end
-
-      it 'does not call Facter.on_message' do
-        expect(Puppet::Util::Logging::setup_facter_logging!).to be_falsey
-      end
-    end
-
     describe 'does support on_message' do
       before :each do
         Facter.stubs(:respond_to?).with(:on_message).returns true

data/spec/unit/util/monkey_patches_spec.rb

@@ -101,13 +101,26 @@ describe OpenSSL::X509::Store, :if => Puppet::Util::Platform.windows? do
     store.set_default_paths
   end
 
-  it "warns when adding a certificate that already exists" do
-    with_root_certs([cert])
-    store.add_cert(cert)
+  # openssl 1.1.1 ignores duplicate certs
+  # https://github.com/openssl/openssl/commit/c0452248ea1a59a41023a4765ef7d9825e80a62b
+  if OpenSSL::OPENSSL_VERSION_NUMBER < 0x10101000
+    it "warns when adding a certificate that already exists" do
+      with_root_certs([cert])
+      store.add_cert(cert)
 
-    store.expects(:warn).with('Failed to add /DC=com/DC=microsoft/CN=Microsoft Root Certificate Authority')
+      store.expects(:warn).with('Failed to add /DC=com/DC=microsoft/CN=Microsoft Root Certificate Authority')
 
-    store.set_default_paths
+      store.set_default_paths
+    end
+  else
+    it "doesn't warn when adding a duplicate cert" do
+      with_root_certs([cert])
+      store.add_cert(cert)
+
+      store.expects(:warn).never
+
+      store.set_default_paths
+    end
   end
 
   it "raises when adding an invalid certificate" do

data/spec/unit/util/posix_spec.rb

@@ -12,6 +12,34 @@ describe Puppet::Util::POSIX do
     @posix = PosixTest.new
   end
 
+  describe '.groups_of' do
+    let(:mock_groups) do
+      [
+        ['group1', ['user1', 'user2']],
+        ['group2', ['user2']],
+        ['group1', ['user1', 'user2']],
+        ['group3', ['user1']],
+        ['group4', ['user2']]
+      ].map do |(name, members)|
+        group_struct = stub("Group #{name}")
+        group_struct.stubs(:name).returns(name)
+        group_struct.stubs(:mem).returns(members)
+
+        group_struct
+      end
+    end
+
+    before(:each) do
+      Puppet::Etc.stubs(:group).multiple_yields(*mock_groups)
+    end
+
+    it 'returns the groups of the given user' do
+      expect(Puppet::Util::POSIX.groups_of('user1')).to eql(
+        ['group1', 'group3']
+      )
+    end
+  end
+
   [:group, :gr].each do |name|
     it "should return :gid as the field for #{name}" do
       expect(@posix.idfield(name)).to eq(:gid)

data/spec/unit/util/selinux_spec.rb

@@ -73,6 +73,10 @@ describe Puppet::Util::SELinux do
       expect(selinux_label_support?('/etc/puppetlabs/puppet/testfile')).to be_truthy
     end
 
+    it "should return true if tmpfs" do
+      expect(selinux_label_support?('/dev/shm/testfile')).to be_truthy
+    end
+
     it "should return false for a noncapable filesystem" do
       expect(selinux_label_support?('/mnt/nfs/testfile')).to be_falsey
     end

data/spec/unit/util/storage_spec.rb

@@ -225,5 +225,112 @@ describe Puppet::Util::Storage do
 
       expect(Puppet::Util::Storage.state).to eq({:yayness=>{}})
     end
+
+    it "expires entries with a :checked older than statettl seconds ago" do
+      Puppet[:statettl] = '1d'
+      recent_checked = Time.now.round
+      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(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :stale => {
+            :checked => stale_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => 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(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => 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(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+
+      Puppet::Util::Storage.store
+      Puppet::Util::Storage.clear
+
+      expect(Puppet::Util::Storage.state).to eq({})
+
+      Puppet::Util::Storage.load
+
+      expect(Puppet::Util::Storage.state).to eq(
+        {
+          :yayness => {
+            :checked => recent_checked
+          },
+          :older => {
+            :checked => older_checked
+          }
+        }
+      )
+    end
   end
 end

data/spec/unit/util/suidmanager_spec.rb

@@ -121,9 +121,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    it "should not get or set euid/egid on Windows" do
-      Puppet::Util::Platform.stubs(:windows?).returns false
-
+    it "should not get or set euid/egid on Windows", if: Puppet::Util::Platform.windows? do
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
       expect(xids).to be_empty