puppet 6.16.0-universal-darwin → 7.0.0-universal-darwin

data/spec/integration/parser/compiler_spec.rb

@@ -834,6 +834,17 @@ describe Puppet::Parser::Compiler do
           MANIFEST
         end.to raise_error(/Foo\[bar\]:\s+parameter 'a' expects a value for key 'd'\s+parameter 'a' unrecognized key 'c'/m)
       end
+
+      it 'handles Sensitive type in resource array' do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          define foo(Sensitive[String] $password) {
+            notify{ "${title}": message => "${password}" }
+          }
+          foo { ['testA', 'testB']: password =>Sensitive('some password') }
+        MANIFEST
+        expect(catalog).to have_resource("Notify[testA]").with_parameter(:message, 'Sensitive [value redacted]')
+        expect(catalog).to have_resource("Notify[testB]").with_parameter(:message, 'Sensitive [value redacted]')
+      end
     end
 
     context 'when using typed parameters in class' do

data/spec/integration/parser/node_spec.rb

@@ -117,15 +117,6 @@ describe 'node statements' do
       expect(catalog).to have_resource('Notify[matched]')
     end
 
-    it 'selects a node that is a prefix of the agent name' do
-      Puppet[:strict_hostname_checking] = false
-      catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("node.name.com"))
-      node 'node.name' { notify { matched: } }
-      MANIFEST
-
-      expect(catalog).to have_resource('Notify[matched]')
-    end
-
     it 'does not treat regex symbols as a regex inside a string literal' do
       catalog = compile_to_catalog(<<-MANIFEST, Puppet::Node.new("nodexname"))
       node 'node.name' { notify { 'not matched': } }

data/spec/integration/parser/pcore_resource_spec.rb

@@ -68,16 +68,6 @@ describe 'when pcore described resources types are in use' do
                 end
               end
             RUBY
-            'cap.rb' => <<-EOF
-            module Puppet
-            Type.newtype(:cap, :is_capability => true) do
-              @doc = "Docs for capability"
-              @isomorphic = false
-              newproperty(:message) do
-                desc "Docs for 'message' property"
-              end
-            end;end
-            EOF
            } } },
         }
       }}})
@@ -126,14 +116,10 @@ describe 'when pcore described resources types are in use' do
         test3 { 'x/y':
           message => 'x/y works'
         }
-        cap { 'c':
-          message => 'c works'
-        }
       MANIFEST
       expect(catalog.resource(:test1, "a")['message']).to eq('a works')
       expect(catalog.resource(:test2, "b")['message']).to eq('b works')
       expect(catalog.resource(:test3, "x/y")['message']).to eq('x/y works')
-      expect(catalog.resource(:cap, "c")['message']).to eq('c works')
     end
 
     it 'the validity of attribute names are checked' do
@@ -158,20 +144,6 @@ describe 'when pcore described resources types are in use' do
       expect(catalog.resource(:test1, "a")['noop']).to eq(true)
     end
 
-    it 'capability is propagated to the catalog' do
-      genface.types
-      catalog = compile_to_catalog(<<-MANIFEST)
-        test2 { 'r':
-          message => 'a resource'
-        }
-        cap { 'c':
-          message => 'a cap'
-        }
-      MANIFEST
-      expect(catalog.resource(:test2, "r").is_capability?).to eq(false)
-      expect(catalog.resource(:cap, "c").is_capability?).to eq(true)
-    end
-
     it 'a generated type describes if it is isomorphic' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')
@@ -181,15 +153,6 @@ describe 'when pcore described resources types are in use' do
       end
     end
 
-    it 'a generated type describes if it is a capability' do
-      generate_and_in_a_compilers_context do |compiler|
-        t1 = find_resource_type(compiler.topscope, 'test1')
-        expect(t1.is_capability?).to be(false)
-        t2 = find_resource_type(compiler.topscope, 'cap')
-        expect(t2.is_capability?).to be(true)
-      end
-    end
-
     it 'a generated type returns parameters defined in pcore' do
       generate_and_in_a_compilers_context do |compiler|
         t1 = find_resource_type(compiler.topscope, 'test1')

data/spec/integration/type/file_spec.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'spec_helper'
 
 require 'puppet_spec/files'
@@ -657,9 +658,9 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
 
     CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
       describe "when checksum_type is #{checksum_type}" do
-        # FileBucket uses the globally configured default for lookup by digest, which right now is MD5.
+        # FileBucket uses the globally configured default for lookup by digest, which right now is SHA256.
         it_should_behave_like "files are backed up", {:checksum => checksum_type} do
-          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.md5(x)} }
+          let(:filebucket_digest) { Proc.new {|x| Puppet::Util::Checksums.sha256(x)} }
         end
       end
     end
@@ -1160,7 +1161,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
       source_prefix = Puppet::Util::Platform.windows? ? '/' : ''
 
       # the URI can be round-tripped through unescape
-      expect(URI.unescape(uri_path)).to eq(source_prefix + source)
+      expect(Puppet::Util.uri_unescape(uri_path)).to eq(source_prefix + source)
       # and is properly UTF-8
       expect(uri_path.encoding).to eq (Encoding::UTF_8)
 
@@ -1727,7 +1728,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "644" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end
@@ -1741,7 +1742,7 @@ describe Puppet::Type.type(:file), :uses_checksums => true do
                                                #{test_cmd} "555" == "$(#{stat_cmd} ^)"
                                                }))
       report = catalog.apply.report
-      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{md5}/)
+      expect(report.resource_statuses["File[#{path}]"].events.first.message).to match(/defined content as '{sha256}/)
       expect(report.resource_statuses["File[#{path}]"]).not_to be_failed
       expect(Puppet::FileSystem.exist?(path)).to be_truthy
     end

data/spec/integration/util/execution_spec.rb

@@ -50,6 +50,28 @@ describe Puppet::Util::Execution, unless: Puppet::Util::Platform.jruby? do
       Puppet::Util::Execution.execute(str, sensitive: true)
       expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'"))
     end
+
+    it "allows 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 "returns 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 "raises 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 "#execute (non-Windows)", :if => !Puppet::Util::Platform.windows? do

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

@@ -33,8 +33,8 @@ describe Puppet::Util::Windows::ADSI::User,
 
   describe '.[]' do
     it 'should return string attributes as UTF-8' do
-      administrator = Puppet::Util::Windows::ADSI::User.new('Administrator')
-      expect(administrator['Description'].encoding).to eq(Encoding::UTF_8)
+      user = Puppet::Util::Windows::ADSI::User.new('Guest')
+      expect(user['Description'].encoding).to eq(Encoding::UTF_8)
     end
   end
 

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

@@ -0,0 +1,231 @@
+# 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

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