puppet 6.15.0-x86-mingw32 → 6.19.1-x86-mingw32

data/spec/integration/util/windows/monkey_patches/dir_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Dir, :if => Puppet::Util::Platform.windows? do
+  it "should always have the PERSONAL constant defined" do
+    expect(described_class).to be_const_defined(:PERSONAL)
+  end
+
+  it "should not raise any errors when accessing the PERSONAL constant" do
+    expect { described_class::PERSONAL }.not_to raise_error
+  end
+end

data/spec/integration/util/windows/process_spec.rb

@@ -33,17 +33,7 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
   end
 
   describe "when reading environment variables" do
-    after :each do
-      # spec\integration\test\test_helper_spec.rb calls set_environment_strings
-      # after :all and thus needs access to the real APIs once again
-      allow(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_call_original
-      allow(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW).and_call_original
-    end
-
     it "will ignore only keys or values with corrupt byte sequences" do
-      arraydest = []
-      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
-
       env_vars = {}
 
       # Create a UTF-16LE version of the below null separated environment string
@@ -61,9 +51,9 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
         ptr.put_array_of_uchar(0, env_var_block_bytes)
 
         # stub the block of memory that the Win32 API would typically return via pointer
-        expect(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_return(ptr)
+        allow(Puppet::Util::Windows::Process).to receive(:GetEnvironmentStringsW).and_return(ptr)
         # stub out the real API call to free memory, else process crashes
-        expect(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW)
+        allow(Puppet::Util::Windows::Process).to receive(:FreeEnvironmentStringsW)
 
         env_vars = Puppet::Util::Windows::Process.get_environment_strings
       end
@@ -72,39 +62,43 @@ describe "Puppet::Util::Windows::Process", :if => Puppet::Util::Platform.windows
       expect(env_vars).to eq({'a' => 'b', 'c' => 'd', 'f' => 'g'})
 
       # and Puppet should emit a warning about it
-      expect(arraydest.last.level).to eq(:warning)
-      expect(arraydest.last.message).to eq("Discarding environment variable e=\uFFFD which contains invalid bytes")
+      expect(@logs.last.level).to eq(:warning)
+      expect(@logs.last.message).to eq("Discarding environment variable e=\uFFFD which contains invalid bytes")
     end
   end
 
   describe "when setting environment variables" do
-    it "can properly handle env var values with = in them" do
-      begin
-        name = SecureRandom.uuid
-        value = 'foo=bar'
+    let(:name) { SecureRandom.uuid }
 
-        Puppet::Util::Windows::Process.set_environment_variable(name, value)
-
-        env = Puppet::Util::Windows::Process.get_environment_strings
-
-        expect(env[name]).to eq(value)
+    around :each do |example|
+      begin
+        example.run
       ensure
         Puppet::Util::Windows::Process.set_environment_variable(name, nil)
       end
     end
 
-    it "can properly handle empty env var values" do
-      begin
-        name = SecureRandom.uuid
+    it "sets environment variables containing '='" do
+      value = 'foo=bar'
+      Puppet::Util::Windows::Process.set_environment_variable(name, value)
+      env = Puppet::Util::Windows::Process.get_environment_strings
 
-        Puppet::Util::Windows::Process.set_environment_variable(name, '')
+      expect(env[name]).to eq(value)
+    end
 
-        env = Puppet::Util::Windows::Process.get_environment_strings
+    it "sets environment variables contains spaces" do
+      Puppet::Util::Windows::Process.set_environment_variable(name, '')
+      env = Puppet::Util::Windows::Process.get_environment_strings
 
-        expect(env[name]).to eq('')
-      ensure
-        Puppet::Util::Windows::Process.set_environment_variable(name, nil)
-      end
+      expect(env[name]).to eq('')
+    end
+
+    it "sets environment variables containing UTF-8" do
+      rune_utf8 = "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7"
+      Puppet::Util::Windows::Process.set_environment_variable(name, rune_utf8)
+      env = Puppet::Util::Windows::Process.get_environment_strings
+
+      expect(env[name]).to eq(rune_utf8)
     end
   end
 end

data/spec/integration/util/windows/registry_spec.rb

@@ -259,23 +259,23 @@ describe Puppet::Util::Windows::Registry do
         {
           name: 'REG_SZ',
           type: Win32::Registry::REG_SZ,
-          value: "reg sz\u0000 string",
-          expected_value: "reg sz  string"
+          value: "reg sz\u0000\u0000 string",
+          expected_value: "reg sz"
         },
         {
           name: 'REG_SZ_2',
           type: Win32::Registry::REG_SZ,
-          value: "reg sz\x00 string",
-          expected_value: "reg sz  string"
+          value: "reg sz 2\x00\x00 string",
+          expected_value: "reg sz 2"
         },
         {
           name: 'REG_EXPAND_SZ',
           type: Win32::Registry::REG_EXPAND_SZ,
-          value: "\0reg expand string",
-          expected_value: " reg expand string"
+          value: "\0\0\0reg expand string",
+          expected_value: ""
         }
       ].each do |pair|
-        it 'replaces null bytes with spaces' do
+        it 'reads up to the first wide null' do
           hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
             reg.write(value_name, pair[:type], pair[:value])
           end

data/spec/integration/util/windows/user_spec.rb

@@ -125,19 +125,16 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
       end
 
       it 'should raise error given that logon returns false' do
-
         allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, passwd, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, anything).and_return (0)
+            user, '.', passwd, fLOGON32_LOGON_NETWORK, fLOGON32_PROVIDER_DEFAULT, anything).and_return (0)
         allow(Puppet::Util::Windows::User).to receive(:logon_user_by_logon_type).with(
-            user, passwd, fLOGON32_LOGON_INTERACTIVE, fLOGON32_PROVIDER_DEFAULT, anything).and_return(0)
+            user, '.', passwd, fLOGON32_LOGON_INTERACTIVE, fLOGON32_PROVIDER_DEFAULT, anything).and_return(0)
 
         expect {Puppet::Util::Windows::User.logon_user(user, passwd) {}}
             .to raise_error(Puppet::Util::Windows::Error, /Failed to logon user/)
-
       end
     end
 
-
     describe "password_is?" do
       it "should return false given an incorrect username and password" do
         expect(Puppet::Util::Windows::User.password_is?(username, bad_password)).to be_falsey
@@ -180,5 +177,50 @@ describe "Puppet::Util::Windows::User", :if => Puppet::Util::Platform.windows? d
         expect { Puppet::Util::Windows::User.check_token_membership }.not_to raise_error
       end
     end
+
+    describe "default_system_account?" do
+      it "should succesfully identify 'SYSTEM' user as a default system account" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('SYSTEM').and_return(Puppet::Util::Windows::SID::LocalSystem)
+        expect(Puppet::Util::Windows::User.default_system_account?('SYSTEM')).to eq(true)
+      end
+
+      it "should succesfully identify 'NETWORK SERVICE' user as a default system account" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('NETWORK SERVICE').and_return(Puppet::Util::Windows::SID::NtNetwork)
+        expect(Puppet::Util::Windows::User.default_system_account?('NETWORK SERVICE')).to eq(true)
+      end
+
+      it "should succesfully identify 'LOCAL SERVICE' user as a default system account" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('LOCAL SERVICE').and_return(Puppet::Util::Windows::SID::NtLocal)
+        expect(Puppet::Util::Windows::User.default_system_account?('LOCAL SERVICE')).to eq(true)
+      end
+
+      it "should not identify user with unknown sid as a default system account" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('UnknownUser').and_return(Puppet::Util::Windows::SID::Null)
+        expect(Puppet::Util::Windows::User.default_system_account?('UnknownUser')).to eq(false)
+      end
+    end
+
+    describe "localsystem?" do
+      before do
+        allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return("myPC")
+      end
+
+      ['LocalSystem', '.\LocalSystem', 'myPC\LocalSystem', 'lOcALsysTem'].each do |input|
+        it "should succesfully identify #{input} as the 'LocalSystem' account" do
+          expect(Puppet::Util::Windows::User.localsystem?(input)).to eq(true)
+        end
+      end
+
+      it "should not identify any other user as the 'LocalSystem' account" do
+        expect(Puppet::Util::Windows::User.localsystem?('OtherUser')).to eq(false)
+      end
+    end
+
+    describe "get_rights" do
+      it "should be empty when given user does not exist" do
+        allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('NonExistingUser').and_return(nil)
+        expect(Puppet::Util::Windows::User.get_rights('NonExistingUser')).to eq("")
+      end
+    end
   end
 end

data/spec/integration/util_spec.rb

@@ -1,32 +1,9 @@
+# coding: utf-8
 require 'spec_helper'
 
 describe Puppet::Util do
   include PuppetSpec::Files
 
-  describe "#execute", unless: Puppet::Util::Platform.jruby? do
-    it "should properly allow stdout and stderr to share a file" do
-      command = "ruby -e '(1..10).each {|i| (i%2==0) ? $stdout.puts(i) : $stderr.puts(i)}'"
-
-      expect(Puppet::Util::Execution.execute(command, :combine => true).split).to match_array([*'1'..'10'])
-    end
-
-    it "should return output and set $CHILD_STATUS" do
-      command = "ruby -e 'puts \"foo\"; exit 42'"
-
-      output = Puppet::Util::Execution.execute(command, {:failonfail => false})
-
-      expect(output).to eq("foo\n")
-      expect($CHILD_STATUS.exitstatus).to eq(42)
-    end
-
-    it "should raise an error if non-zero exit status is returned" do
-      command = "ruby -e 'exit 43'"
-
-      expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
-      expect($CHILD_STATUS.exitstatus).to eq(43)
-    end
-  end
-
   describe "#replace_file on Windows", :if => Puppet::Util::Platform.windows? do
     it "replace_file should preserve original ACEs from existing replaced file on Windows" do
 
@@ -110,18 +87,15 @@ describe Puppet::Util do
   describe "#which on Windows", :if => Puppet::Util::Platform.windows? do
     let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
     let (:filename) { 'foo.exe' }
-    let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
 
-    before :each do
-      allow(FileTest).to receive(:file?).and_return(false)
-      allow(FileTest).to receive(:file?).with(filepath).and_return(true)
+    it "should be able to use UTF8 characters in the path" do
+      utf8 = tmpdir(rune_utf8)
+      Puppet::FileSystem.mkpath(utf8)
 
-      allow(FileTest).to receive(:executable?).and_return(false)
-      allow(FileTest).to receive(:executable?).with(filepath).and_return(true)
-    end
+      filepath = File.join(utf8, filename)
+      Puppet::FileSystem.touch(filepath)
 
-    it "should be able to use UTF8 characters in the path" do
-      path = "C:\\" + rune_utf8 + "#{File::PATH_SEPARATOR}c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
+      path = [utf8, "c:\\windows\\system32", "c:\\windows"].join(File::PATH_SEPARATOR)
       Puppet::Util.withenv( { "PATH" => path } , :windows) do
         expect(Puppet::Util.which(filename)).to eq(filepath)
       end

data/spec/lib/puppet_spec/https.rb

@@ -24,6 +24,12 @@ class PuppetSpec::HTTPSServer
     res = WEBrick::HTTPResponse.new(@config)
     res.status = 200
     res.body = 'OK'
+    # The server explicitly closes the connection after handling it,
+    # so explicitly tell the client we're not going to keep it open.
+    # Without this, ruby will add `Connection: Keep-Alive`, which
+    # confuses the client when it tries to reuse the half-closed
+    # connection.
+    res['Connection'] = 'close'
     response_proc.call(req, res) if response_proc
 
     res.send_response(ssl)

data/spec/lib/puppet_spec/matchers.rb

@@ -41,86 +41,6 @@ RSpec::Matchers.define :exit_with do |expected|
   end
 end
 
-
-RSpec::Matchers.define :have_printed do |expected|
-
-  case expected
-  when String, Regexp, Proc
-    expected = expected
-  else
-    expected = expected.to_s
-  end
-
-  chain :and_exit_with do |code|
-    @expected_exit_code = code
-  end
-
-  define_method :matches_exit_code? do |actual|
-    @expected_exit_code.nil? || @expected_exit_code == actual
-  end
-
-  define_method :matches_output? do |actual|
-    return false unless actual
-    case expected
-      when String
-        actual.include?(expected)
-      when Regexp
-        expected.match(actual)
-      when Proc
-        expected.call(actual)
-      else
-        raise ArgumentError, "No idea how to match a #{actual.class.name}"
-    end
-  end
-
-  match do |block|
-    $stderr = $stdout = StringIO.new
-    $stdout.set_encoding('UTF-8') if $stdout.respond_to?(:set_encoding)
-
-    begin
-      block.call
-    rescue SystemExit => e
-      raise unless @expected_exit_code
-      @actual_exit_code = e.status
-    ensure
-      $stdout.rewind
-      @actual = $stdout.read
-
-      $stdout = STDOUT
-      $stderr = STDERR
-    end
-
-    matches_output?(@actual) && matches_exit_code?(@actual_exit_code)
-  end
-
-  supports_block_expectations
-
-  failure_message do |actual|
-    if actual.nil? then
-      "expected #{expected.inspect}, but nothing was printed"
-    else
-      if !@expected_exit_code.nil? && matches_output?(actual)
-        "expected exit with code #{@expected_exit_code} but " +
-          (@actual_exit_code.nil? ? " exit was not called" : "exited with #{@actual_exit_code} instead")
-      else
-        "expected #{expected.inspect} to be printed; got:\n#{actual}"
-      end
-    end
-  end
-
-  failure_message_when_negated do |actual|
-    if @expected_exit_code && matches_exit_code?(@actual_exit_code)
-      "expected exit code to not be #{@actual_exit_code}"
-    else
-      "expected #{expected.inspect} to not be printed; got:\n#{actual}"
-    end
-  end
-
-  description do
-    "expect #{expected.inspect} to be printed" + (@expected_exit_code.nil ? '' : " with exit code #{@expected_exit_code}")
-  end
-end
-
 RSpec::Matchers.define :equal_attributes_of do |expected|
   match do |actual|
     actual.instance_variables.all? do |attr|

data/spec/lib/puppet_spec/puppetserver.rb

@@ -47,9 +47,13 @@ class PuppetSpec::Puppetserver
   class FilebucketServlet < WEBrick::HTTPServlet::AbstractServlet
     def do_GET request, response
     end
+
     def do_PUT request, response
+      upload = File.join(@config.config[:TempDir], 'filebucket')
+      File.open(upload, 'wb') { |f| f.write(request.body) }
       response['Content-Type'] = 'application/octet-stream'
     end
+
     def do_HEAD request, response
       response.status = 404
     end
@@ -116,4 +120,8 @@ class PuppetSpec::Puppetserver
               end
     @https.mount(path, handler)
   end
+
+  def upload_directory
+    @https.config[:TempDir]
+  end
 end

data/spec/shared_contexts/types_setup.rb

@@ -187,6 +187,8 @@ shared_context 'types_setup' do
     result << Puppet::Pops::Types::PURIType
     result << Puppet::Pops::Types::PTupleType.new([tf.rich_data])
     result << Puppet::Pops::Types::PObjectType
+    result << Puppet::Pops::Types::PTypeType
+    result << Puppet::Pops::Types::PTypeSetType
     result
   end
   def rich_data_compatible_types

data/spec/unit/agent_spec.rb

@@ -179,6 +179,52 @@ describe Puppet::Agent do
       expect(@agent.run).to eq(:result)
     end
 
+    describe "and a puppet agent is already running" do
+      before(:each) do
+        allow_any_instance_of(Object).to receive(:sleep)
+        lockfile = double('lockfile')
+        expect(@agent).to receive(:lockfile).and_return(lockfile).at_least(:once)
+        # so the lock method raises Puppet::LockError
+        allow(lockfile).to receive(:lock).and_return(false)
+      end
+
+      it "should notify that a run is already in progres" do
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+        expect(Puppet).to receive(:notice).with(/Run of .* already in progress; skipping .* exists/)
+        @agent.run
+      end
+
+      it "should inform that a run is already in progres and try to run every X seconds if waitforlock is used" do
+        # so the locked file exists
+        allow(File).to receive(:file?).and_return(true)
+        # so we don't have to wait again for the run to exit (default maxwaitforcert is 60)
+        # first 0 is to get the time, second 0 is to inform user, then 1000 so the time expires
+        allow(Time).to receive(:now).and_return(0, 0, 1000)
+        allow(Puppet).to receive(:info)
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+
+        Puppet[:waitforlock] = 1
+        Puppet[:maxwaitforlock] = 2
+        expect(Puppet).to receive(:info).with(/Another puppet instance is already running; --waitforlock flag used, waiting for running instance to finish./)
+        expect(Puppet).to receive(:info).with(/Will try again in #{Puppet[:waitforlock]} seconds./)
+        @agent.run
+      end
+
+      it "should notify that the run is exiting if waitforlock is used and maxwaitforlock is exceeded" do
+        # so we don't have to wait again for the run to exit (default maxwaitforcert is 60)
+        # first 0 is to get the time, then 1000 so that the time expires
+        allow(Time).to receive(:now).and_return(0, 1000)
+        client = AgentTestClient.new
+        expect(AgentTestClient).to receive(:new).and_return(client)
+
+        Puppet[:waitforlock] = 1
+        expect(Puppet).to receive(:notice).with(/Exiting now because the maxwaitforlock timeout has been exceeded./)
+        @agent.run
+      end
+    end
+    
     describe "when should_fork is true", :if => Puppet.features.posix? && RUBY_PLATFORM != 'java' do
       before do
         @agent = Puppet::Agent.new(AgentTestClient, true)
@@ -291,7 +337,7 @@ describe Puppet::Agent do
         expect(client).not_to receive(:handling)
         expect(Puppet).to receive(:log_exception).with(be_an_instance_of(Puppet::Agent::RunTimeoutError), anything)
 
-        expect(@agent.run).to eq(1)
+        expect(@agent.run).to eq(nil)
       end
     end
   end