puppet 8.3.1-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/integration/util/settings_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-require 'puppet_spec/files'
-
-describe Puppet::Settings do
-  include PuppetSpec::Files
-
-  def minimal_default_settings
-    { :noop => {:default => false, :desc => "noop"} }
-  end
-
-  def define_settings(section, settings_hash)
-    settings.define_settings(section, minimal_default_settings.update(settings_hash))
-  end
-
-  let(:settings) { Puppet::Settings.new }
-
-  it "should be able to make needed directories" do
-    define_settings(:main,
-      :maindir => {
-          :default => tmpfile("main"),
-          :type => :directory,
-          :desc => "a",
-      }
-    )
-    settings.use(:main)
-
-    expect(File.directory?(settings[:maindir])).to be_truthy
-  end
-
-  it "should make its directories with the correct modes" do
-    Puppet[:manage_internal_file_permissions] = true
-    define_settings(:main,
-        :maindir => {
-            :default => tmpfile("main"),
-            :type => :directory,
-            :desc => "a",
-            :mode => 0750
-        }
-    )
-
-    settings.use(:main)
-
-    expect(Puppet::FileSystem.stat(settings[:maindir]).mode & 007777).to eq(0750)
-  end
-
-  it "will properly parse a UTF-8 configuration file" do
-    rune_utf8 = "\u16A0\u16C7\u16BB" # ᚠᛇᚻ
-    config = tmpfile("config")
-    define_settings(:main,
-      :config => {
-        :type => :file,
-        :default => config,
-        :desc => "a"
-      },
-      :environment => {
-        :default => 'dingos',
-        :desc => 'test',
-      }
-    )
-
-    File.open(config, 'w') do |file|
-      file.puts <<-EOF
-[main]
-environment=#{rune_utf8}
-      EOF
-    end
-
-    settings.initialize_global_settings
-    expect(settings[:environment]).to eq(rune_utf8)
-  end
-
-  it "reparses configuration if configuration file is touched", :if => !Puppet::Util::Platform.windows? do
-    config = tmpfile("config")
-    define_settings(:main,
-      :config => {
-        :type => :file,
-        :default => config,
-        :desc => "a"
-      },
-      :environment => {
-        :default => 'dingos',
-        :desc => 'test',
-      }
-    )
-
-    Puppet[:filetimeout] = '1s'
-
-    File.open(config, 'w') do |file|
-      file.puts <<-EOF
-[main]
-environment=toast
-      EOF
-    end
-
-    settings.initialize_global_settings
-    expect(settings[:environment]).to eq('toast')
-
-    # First reparse establishes WatchedFiles
-    settings.reparse_config_files
-
-    sleep 1
-
-    File.open(config, 'w') do |file|
-      file.puts <<-EOF
-[main]
-environment=bacon
-      EOF
-    end
-
-    # Second reparse if later than filetimeout, reparses if changed
-    settings.reparse_config_files
-    expect(settings[:environment]).to eq('bacon')
-  end
-end

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

@@ -1,207 +0,0 @@
-require 'spec_helper'
-require 'puppet/util/windows'
-
-describe Puppet::Util::Windows::ADSI::User,
-  :if => Puppet::Util::Platform.windows? do
-
-  describe ".initialize" do
-    it "cannot reference BUILTIN accounts like SYSTEM due to WinNT moniker limitations" do
-      system = Puppet::Util::Windows::ADSI::User.new('SYSTEM')
-      # trying to retrieve COM object should fail to load with a localized version of:
-      # ADSI connection error: failed to parse display name of moniker `WinNT://./SYSTEM,user'
-      #     HRESULT error code:0x800708ad
-      #           The user name could not be found.
-      # Matching on error code alone is sufficient
-      expect { system.native_object }.to raise_error(/0x800708ad/)
-    end
-  end
-
-  describe '.each' do
-    it 'should return a list of users with UTF-8 names' do
-      begin
-        original_codepage = Encoding.default_external
-        Encoding.default_external = Encoding::CP850 # Western Europe
-
-        Puppet::Util::Windows::ADSI::User.each do |user|
-          expect(user.name.encoding).to be(Encoding::UTF_8)
-        end
-      ensure
-        Encoding.default_external = original_codepage
-      end
-    end
-  end
-
-  describe '.[]' do
-    it 'should return string attributes as UTF-8' do
-      user = Puppet::Util::Windows::ADSI::User.new('Guest')
-      expect(user['Description'].encoding).to eq(Encoding::UTF_8)
-    end
-  end
-
-  describe '.groups' do
-    it 'should return a list of groups with UTF-8 names' do
-      begin
-        original_codepage = Encoding.default_external
-        Encoding.default_external = Encoding::CP850 # Western Europe
-
-
-        # lookup by English name Administrator is OK on localized Windows
-        administrator = Puppet::Util::Windows::ADSI::User.new('Administrator')
-        administrator.groups.each do |name|
-          expect(name.encoding).to be(Encoding::UTF_8)
-        end
-      ensure
-        Encoding.default_external = original_codepage
-      end
-    end
-  end
-
-  describe '.current_user_name_with_format' do
-    context 'when desired format is NameSamCompatible' do
-      it 'should get the same user name as the current_user_name method but fully qualified' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(fully_qualified_user_name).to match(/^.+\\#{user_name}$/)
-      end
-
-      it 'should have the same SID as with the current_user_name method' do
-        user_name = Puppet::Util::Windows::ADSI::User.current_user_name
-        fully_qualified_user_name = Puppet::Util::Windows::ADSI::User.current_sam_compatible_user_name
-
-        expect(Puppet::Util::Windows::SID.name_to_sid(user_name)).to eq(Puppet::Util::Windows::SID.name_to_sid(fully_qualified_user_name))
-      end
-    end
-  end
-end
-
-describe Puppet::Util::Windows::ADSI::Group,
-  :if => Puppet::Util::Platform.windows? do
-
-  let (:administrator_bytes) { [1, 2, 0, 0, 0, 0, 0, 5, 32, 0, 0, 0, 32, 2, 0, 0] }
-  let (:administrators_principal) { Puppet::Util::Windows::SID::Principal.lookup_account_sid(administrator_bytes) }
-
-  describe '.each' do
-    it 'should return a list of groups with UTF-8 names' do
-      begin
-        original_codepage = Encoding.default_external
-        Encoding.default_external = Encoding::CP850 # Western Europe
-
-        Puppet::Util::Windows::ADSI::Group.each do |group|
-          expect(group.name.encoding).to be(Encoding::UTF_8)
-        end
-      ensure
-        Encoding.default_external = original_codepage
-      end
-    end
-  end
-
-  describe '.members' do
-    it 'should return a list of members resolvable with Puppet::Util::Windows::ADSI::Group.name_sid_hash' do
-      temp_groupname = "g#{SecureRandom.uuid}"
-      temp_username  = "u#{SecureRandom.uuid}"[0..12]
-      # From https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/password-must-meet-complexity-requirements
-      specials = "~!@#$%^&*_-+=`|\(){}[]:;\"'<>,.?/"
-      temp_password = "p#{SecureRandom.uuid[0..7]}-#{SecureRandom.uuid.upcase[0..7]}-#{specials[rand(specials.length)]}"
-
-      # select a virtual account that requires an authority to be able to resolve to SID
-      # the Dhcp service is chosen for no particular reason aside from it's a service available on all Windows versions
-      dhcp_virtualaccount = Puppet::Util::Windows::SID.name_to_principal('NT SERVICE\Dhcp')
-
-      # adding :SidTypeGroup as a group member will cause error in IAdsUser::Add
-      # adding :SidTypeDomain (such as S-1-5-80 / NT SERVICE or computer name) won't error
-      #   but also won't be returned as a group member
-      # uncertain how to obtain :SidTypeComputer (perhaps AD? the local machine is :SidTypeDomain)
-      users = [
-        # Use sid_to_name to get localized names of SIDs - BUILTIN, SYSTEM, NT AUTHORITY, Everyone are all localized
-        # :SidTypeWellKnownGroup
-        # SYSTEM is prefixed with the NT Authority authority, resolveable with or without authority
-        { :sid => 'S-1-5-18', :name => Puppet::Util::Windows::SID.sid_to_name('S-1-5-18') },
-        # Everyone is not prefixed with an authority, resolveable with or without NT AUTHORITY authority
-        { :sid => 'S-1-1-0', :name => Puppet::Util::Windows::SID.sid_to_name('S-1-1-0') },
-        # Dhcp service account is prefixed with NT SERVICE authority, requires authority to resolve SID
-        # behavior is similar to IIS APPPOOL\DefaultAppPool
-        { :sid => dhcp_virtualaccount.sid, :name => dhcp_virtualaccount.domain_account },
-
-        # :SidTypeAlias with authority component
-        # Administrators group is prefixed with BUILTIN authority, can be resolved with or without authority
-        { :sid => 'S-1-5-32-544', :name => Puppet::Util::Windows::SID.sid_to_name('S-1-5-32-544') },
-      ]
-
-      begin
-        # :SidTypeUser as user on localhost, can be resolved with or without authority prefix
-        user = Puppet::Util::Windows::ADSI::User.create(temp_username)
-        # appveyor sometimes requires a password
-        user.password = temp_password
-        user.commit()
-        users.push({ :sid => user.sid.sid, :name => Puppet::Util::Windows::ADSI.computer_name + '\\' + temp_username })
-
-        # create a test group and add above 5 members by SID
-        group = described_class.create(temp_groupname)
-        group.commit()
-        group.set_members(users.map { |u| u[:sid]} )
-
-        # most importantly make sure that all name are convertible to SIDs
-        expect { described_class.name_sid_hash(group.members) }.to_not raise_error
-
-        # also verify the names returned are as expected
-        expected_usernames = users.map { |u| u[:name] }
-        expect(group.members.map(&:domain_account)).to eq(expected_usernames)
-      ensure
-        described_class.delete(temp_groupname) if described_class.exists?(temp_groupname)
-        Puppet::Util::Windows::ADSI::User.delete(temp_username) if Puppet::Util::Windows::ADSI::User.exists?(temp_username)
-      end
-    end
-
-    it 'should return a list of Principal objects even with unresolvable SIDs' do
-      members = [
-        # NULL SID is not localized
-        double('WIN32OLE', {
-          :objectSID => [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-          :Name => 'NULL SID',
-          :ole_respond_to? => true,
-        }),
-        # unresolvable SID is a different story altogether
-        double('WIN32OLE', {
-          # completely valid SID, but Name is just a stringified version
-          :objectSID => [1, 5, 0, 0, 0, 0, 0, 5, 21, 0, 0, 0, 5, 113, 65, 218, 15, 127, 9, 57, 219, 4, 84, 126, 88, 4, 0, 0],
-          :Name => 'S-1-5-21-3661721861-956923663-2119435483-1112',
-          :ole_respond_to? => true,
-        })
-      ]
-
-      admins_name = Puppet::Util::Windows::SID.sid_to_name('S-1-5-32-544')
-      admins = Puppet::Util::Windows::ADSI::Group.new(admins_name)
-
-      # touch the native_object member to have it lazily loaded, so COM objects can be stubbed
-      admins.native_object
-      without_partial_double_verification do
-        allow(admins.native_object).to receive(:Members).and_return(members)
-      end
-
-      # well-known NULL SID
-      expect(admins.members[0].sid).to eq('S-1-0-0')
-      expect(admins.members[0].account_type).to eq(:SidTypeWellKnownGroup)
-
-      # unresolvable SID
-      expect(admins.members[1].sid).to eq('S-1-5-21-3661721861-956923663-2119435483-1112')
-      expect(admins.members[1].account).to eq('S-1-5-21-3661721861-956923663-2119435483-1112')
-      expect(admins.members[1].account_type).to eq(:SidTypeUnknown)
-    end
-
-    it 'should return a list of members with UTF-8 names' do
-      begin
-        original_codepage = Encoding.default_external
-        Encoding.default_external = Encoding::CP850 # Western Europe
-
-        # lookup by English name Administrators is not OK on localized Windows
-        admins = Puppet::Util::Windows::ADSI::Group.new(administrators_principal.account)
-        admins.members.map(&:domain_account).each do |name|
-          expect(name.encoding).to be(Encoding::UTF_8)
-        end
-      ensure
-        Encoding.default_external = original_codepage
-      end
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe 'Process', if: Puppet::Util::Platform.windows? do
-  describe '.create' do
-    context 'with common flags' do
-      it do
-        Process.create(
-          app_name: 'cmd.exe /c echo 123',
-          creation_flags: 0x00000008,
-          process_inherit: false,
-          thread_inherit: false,
-          cwd: 'C:\\'
-        )
-      end
-
-      context 'when FFI call fails' do
-        before do
-          allow(Process).to receive(:CreateProcessW).and_return(false)
-        end
-
-        it 'raises SystemCallError' do
-          expect do
-            Process.create(
-              app_name: 'cmd.exe /c echo 123',
-              creation_flags: 0x00000008
-            )
-          end.to raise_error(SystemCallError)
-        end
-      end
-    end
-
-    context 'with logon' do
-      context 'without password' do
-        it 'raises error' do
-          expect do
-            Process.create(
-              app_name: 'cmd.exe /c echo 123',
-              creation_flags: 0x00000008,
-              with_logon: 'test'
-            )
-          end.to raise_error(ArgumentError, 'password must be specified if with_logon is used')
-        end
-      end
-
-      context 'with common flags' do
-        before do
-          allow(Process).to receive(:CreateProcessWithLogonW).and_return(true)
-        end
-
-        it do
-          Process.create(
-            app_name: 'cmd.exe /c echo 123',
-            creation_flags: 0x00000008,
-            process_inherit: false,
-            thread_inherit: false,
-            with_logon: 'test',
-            password: 'password',
-            cwd: 'C:\\'
-          )
-        end
-
-        context 'when FFI call fails' do
-          before do
-            allow(Process).to receive(:CreateProcessWithLogonW).and_return(false)
-          end
-
-          it 'raises SystemCallError' do
-            expect do
-              Process.create(
-                app_name: 'cmd.exe /c echo 123',
-                creation_flags: 0x00000008,
-                with_logon: 'test',
-                password: 'password'
-              )
-            end.to raise_error(SystemCallError)
-          end
-        end
-      end
-    end
-
-    describe 'validations' do
-      context 'when args is not a hash' do
-        it 'raises TypeError' do
-          expect do
-            Process.create('test')
-          end.to raise_error(TypeError, 'hash keyword arguments expected')
-        end
-      end
-
-      context 'when args key is invalid' do
-        it 'raises ArgumentError' do
-          expect do
-            Process.create(invalid_key: 'test')
-          end.to raise_error(ArgumentError, "invalid key 'invalid_key'")
-        end
-      end
-
-      context 'when startup_info is invalid' do
-        it 'raises ArgumentError' do
-          expect do
-            Process.create(startup_info: { invalid_key: 'test' })
-          end.to raise_error(ArgumentError, "invalid startup_info key 'invalid_key'")
-        end
-      end
-
-      context 'when app_name and command_line are missing' do
-        it 'raises ArgumentError' do
-          expect do
-            Process.create(creation_flags: 0)
-          end.to raise_error(ArgumentError, 'command_line or app_name must be specified')
-        end
-      end
-
-      context 'when executable is not found' do
-        it 'raises Errno::ENOENT' do
-          expect do
-            Process.create(app_name: 'non_existent')
-          end.to raise_error(Errno::ENOENT)
-        end
-      end
-    end
-
-    context 'when environment is not specified' do
-      it 'passes local environment' do
-        stdout_read, stdout_write = IO.pipe
-        ENV['TEST_ENV'] = 'B'
-
-        Process.create(
-          app_name: 'cmd.exe /c echo %TEST_ENV%',
-          creation_flags: 0x00000008,
-          startup_info: { stdout: stdout_write }
-        )
-
-        stdout_write.close
-        expect(stdout_read.read.chomp).to eql('B')
-      end
-    end
-
-    context 'when environment is specified' do
-      it 'does not pass local environment' do
-        stdout_read, stdout_write = IO.pipe
-        ENV['TEST_ENV'] = 'B'
-
-        Process.create(
-          app_name: 'cmd.exe /c echo %TEST_ENV%',
-          creation_flags: 0x00000008,
-          environment: '',
-          startup_info: { stdout: stdout_write }
-        )
-
-        stdout_write.close
-        expect(stdout_read.read.chomp).to eql('%TEST_ENV%')
-      end
-
-      it 'supports :environment as a string' do
-        stdout_read, stdout_write = IO.pipe
-
-        Process.create(
-          app_name: 'cmd.exe /c echo %A% %B%',
-          creation_flags: 0x00000008,
-          environment: 'A=C;B=D',
-          startup_info: { stdout: stdout_write }
-        )
-
-        stdout_write.close
-        expect(stdout_read.read.chomp).to eql('C D')
-      end
-
-      it 'supports :environment as a string' do
-        stdout_read, stdout_write = IO.pipe
-
-        Process.create(
-          app_name: 'cmd.exe /c echo %A% %C%',
-          creation_flags: 0x00000008,
-          environment: ['A=B;X;', 'C=;D;Y'],
-          startup_info: { stdout: stdout_write }
-        )
-
-        stdout_write.close
-        expect(stdout_read.read.chomp).to eql('B;X; ;D;Y')
-      end
-    end
-  end
-
-  describe '.setpriority' do
-    let(:priority) { Process::BELOW_NORMAL_PRIORITY_CLASS }
-
-    context 'when success' do
-      it 'returns 0' do
-        expect(Process.setpriority(0, Process.pid, priority)).to eql(0)
-      end
-
-      it 'treats an int argument of zero as the current process' do
-        expect(Process.setpriority(0, 0, priority)).to eql(0)
-      end
-    end
-
-    context 'when invalid arguments are sent' do
-      it 'raises TypeError' do
-        expect {
-          Process.setpriority('test', 0, priority)
-        }.to raise_error(TypeError)
-      end
-    end
-
-    context 'when process is not found' do
-      before do
-        allow(Process).to receive(:OpenProcess).and_return(0)
-      end
-      it 'raises SystemCallError' do
-        expect {
-          Process.setpriority(0, 0, priority)
-        }.to raise_error(SystemCallError)
-      end
-    end
-
-    context 'when priority is not set' do
-      before do
-        allow(Process).to receive(:SetPriorityClass).and_return(false)
-      end
-
-      it 'raises SystemCallError' do
-        expect {
-          Process.setpriority(0, 0, priority)
-        }.to raise_error(SystemCallError)
-      end
-    end
-  end
-end