puppet 6.19.0-x64-mingw32 → 7.3.0-x64-mingw32

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
@@ -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/windows/adsi_spec.rb

@@ -157,7 +157,9 @@ describe Puppet::Util::Windows::ADSI::Group,
 
       # touch the native_object member to have it lazily loaded, so COM objects can be stubbed
       admins.native_object
-      allow(admins.native_object).to receive(:Members).and_return(members)
+      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')

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

@@ -146,16 +146,6 @@ describe Puppet::Util::Windows::Registry do
         utf_8_bytes = ENDASH_UTF_8 + TM_UTF_8
         utf_8_str = utf_8_bytes.pack('c*').force_encoding(Encoding::UTF_8)
 
-        # this problematic Ruby codepath triggers a conversion of UTF-16LE to
-        # a local codepage which can totally break when that codepage has no
-        # conversion from the given UTF-16LE characters to local codepage
-        # a prime example is that IBM437 has no conversion from a Unicode en-dash
-        expect(Win32::Registry).not_to receive(:export_string)
-
-        # also, expect that we're using our variants of keys / values, not Rubys
-        expect(Win32::Registry).not_to receive(:each_key)
-        expect(Win32::Registry).not_to receive(:each_value)
-
         hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS | regsam) do |reg|
           reg.write("#{guid}", Win32::Registry::REG_SZ, utf_16_str)
 

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

@@ -822,7 +822,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet::Util::Platform.window
     end
 
     describe "locked files" do
-      let (:explorer) { File.join(Dir::WINDOWS, "explorer.exe") }
+      let (:explorer) { File.join(ENV['SystemRoot'], "explorer.exe") }
 
       it "should get the owner" do
         expect(winsec.get_owner(explorer)).to match(/^S-1-5-/)

data/spec/lib/puppet_spec/puppetserver.rb

@@ -103,7 +103,7 @@ class PuppetSpec::Puppetserver
   end
 
   def register_mounts(mounts: {})
-    register_mount('/status/v1/simple/master', proc { |req, res|  }, nil)
+    register_mount('/status/v1/simple/server', proc { |req, res|  }, nil)
     register_mount('/puppet/v3/node', mounts[:node], NodeServlet)
     register_mount('/puppet/v3/catalog', mounts[:catalog], CatalogServlet)
     register_mount('/puppet/v3/file_metadatas', mounts[:file_metadatas], FileMetadatasServlet)

data/spec/lib/puppet_spec/settings.rb

@@ -11,8 +11,14 @@ module PuppetSpec::Settings
     :confdir      => { :type => :directory, :default => "test", :desc => "confdir" },
     :codedir      => { :type => :directory, :default => "test", :desc => "codedir" },
     :vardir       => { :type => :directory, :default => "test", :desc => "vardir" },
+    :publicdir    => { :type => :directory, :default => "test", :desc => "publicdir" },
     :rundir       => { :type => :directory, :default => "test", :desc => "rundir" },
-  }
+  }.freeze
+
+  TEST_APP_DEFAULT_VALUES = TEST_APP_DEFAULT_DEFINITIONS.inject({}) do |memo, (key, value)|
+    memo[key] = value[:default]
+    memo
+  end.freeze
 
   def set_puppet_conf(confdir, settings)
     write_file(File.join(confdir, "puppet.conf"), settings)

data/spec/spec_helper.rb

@@ -84,10 +84,7 @@ RSpec.configure do |config|
   config.filter_run_when_matching :focus
 
   config.mock_with :rspec do |mocks|
-    # We really should have this on, but it breaks a _lot_ of tests. We'll
-    # need to go through and fix those tests first before it can be enabled
-    # for real.
-    mocks.verify_partial_doubles = false
+    mocks.verify_partial_doubles = true
   end
 
   tmpdir = Puppet::FileSystem.expand_path(Dir.mktmpdir("rspecrun"))
@@ -148,6 +145,7 @@ RSpec.configure do |config|
 
     base = PuppetSpec::Files.tmpdir('tmp_settings')
     Puppet[:vardir] = File.join(base, 'var')
+    Puppet[:publicdir] = File.join(base, 'public')
     Puppet[:confdir] = File.join(base, 'etc')
     Puppet[:codedir] = File.join(base, 'code')
     Puppet[:logdir] = "$vardir/log"
@@ -155,6 +153,7 @@ RSpec.configure do |config|
     Puppet[:hiera_config] = File.join(base, 'hiera')
 
     FileUtils.mkdir_p Puppet[:statedir]
+    FileUtils.mkdir_p Puppet[:publicdir]
 
     Puppet::Test::TestHelper.before_each_test()
   end

data/spec/unit/agent_spec.rb

@@ -3,9 +3,13 @@ require 'puppet/agent'
 require 'puppet/configurer'
 
 class AgentTestClient
-  def run
+  def initialize(transaction_uuid = nil, job_id = nil)
+  end
+
+  def run(client_args)
     # no-op
   end
+
   def stop
     # no-op
   end
@@ -20,8 +24,6 @@ end
 
 describe Puppet::Agent do
   before do
-    allow(Puppet::Status.indirection).to receive(:find).and_return(Puppet::Status.new("version" => Puppet.version))
-
     @agent = Puppet::Agent.new(AgentTestClient, false)
 
     # make Puppet::Application safe for stubbing; restore in an :after block; silence warnings for this.
@@ -51,11 +53,10 @@ describe Puppet::Agent do
 
   it "should create an instance of its client class and run it when asked to run" do
     client = double('client')
-    expect(AgentTestClient).to receive(:new).and_return(client)
-
-    expect(client).to receive(:run)
+    allow(AgentTestClient).to receive(:new).with(nil, nil).and_return(client)
 
     allow(@agent).to receive(:disabled?).and_return(false)
+    expect(client).to receive(:run)
     @agent.run
   end
 
@@ -92,7 +93,6 @@ describe Puppet::Agent do
 
   describe "when being run" do
     before do
-      allow(AgentTestClient).to receive(:lockfile_path).and_return("/my/lock")
       allow(@agent).to receive(:disabled?).and_return(false)
     end
 
@@ -188,7 +188,7 @@ describe Puppet::Agent do
         allow(lockfile).to receive(:lock).and_return(false)
       end
 
-      it "should notify that a run is already in progres" do
+      it "should notify that a run is already in progress" 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/)

data/spec/unit/application/agent_spec.rb

@@ -202,7 +202,6 @@ describe Puppet::Application::Agent do
       allow(Puppet::Resource::Catalog.indirection).to receive(:terminus_class=)
       allow(Puppet::Resource::Catalog.indirection).to receive(:cache_class=)
       allow(Puppet::Node::Facts.indirection).to receive(:terminus_class=)
-      allow(Puppet).to receive(:settraps)
     end
 
     it "should not run with extra arguments" do

data/spec/unit/application/config_spec.rb

@@ -1,12 +1,232 @@
+# coding: utf-8
 require 'spec_helper'
 require 'puppet/application/config'
 
 describe Puppet::Application::Config do
-  it "should be a subclass of Puppet::Application::FaceBase" do
-    expect(Puppet::Application::Config.superclass).to equal(Puppet::Application::FaceBase)
+  include PuppetSpec::Files
+
+  # different UTF-8 widths
+  # 1-byte A
+  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+  # 4-byte 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+  MIXED_UTF8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ𠜎
+
+  let(:app) { Puppet::Application[:config] }
+
+  before :each do
+    Puppet[:config] = tmpfile('config')
+  end
+
+  def initialize_app(args)
+    app.command_line.args = args
+    # ensure global defaults are initialized prior to app defaults
+    Puppet.initialize_settings(args)
+  end
+
+  def read_utf8(path)
+    File.read(path, :encoding => 'UTF-8')
+  end
+
+  def write_utf8(path, content)
+    File.write(path, content, 0, :encoding => 'UTF-8')
+  end
+
+  context "when printing" do
+    it "prints a value" do
+      initialize_app(%w[print certname])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(a_string_matching(Puppet[:certname])).to_stdout
+    end
+
+    it "prints a value from a section" do
+      File.write(Puppet[:config], <<~END)
+        [main]
+        external_nodes=none
+        [server]
+        external_nodes=exec
+      END
+
+      initialize_app(%w[print external_nodes --section server])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(a_string_matching('exec')).to_stdout
+    end
+
+    it "doesn't require the environment to exist" do
+      initialize_app(%w[print certname --environment doesntexist])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(a_string_matching(Puppet[:certname])).to_stdout
+    end
   end
 
-  it "should set `environment_mode` to :not_required" do
-    expect(Puppet::Application::Config.get_environment_mode).to equal(:not_required)
+  context "when setting" do
+    it "sets a value in its config file" do
+      initialize_app(%w[set certname www.example.com])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+
+      expect(File.read(Puppet[:config])).to eq("[main]\ncertname = www.example.com\n")
+    end
+
+    it "sets a value in the server section" do
+      initialize_app(%w[set external_nodes exec --section server])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+
+      expect(File.read(Puppet[:config])).to eq("[server]\nexternal_nodes = exec\n")
+    end
+
+    {
+      %w[certname WWW.EXAMPLE.COM] => /Certificate names must be lower case/,
+      %w[log_level all] => /Invalid loglevel all/,
+      %w[disable_warnings true] => /Cannot disable unrecognized warning types 'true'/,
+      %w[strict on] => /Invalid value 'on' for parameter strict/,
+      %w[digest_algorithm rot13] => /Invalid value 'rot13' for parameter digest_algorithm/,
+      %w[http_proxy_password a#b] => /Passwords set in the http_proxy_password setting must be valid as part of a URL/,
+    }.each_pair do |args, message|
+      it "rejects #{args.join(' ')}" do
+        initialize_app(['set', *args])
+
+        expect {
+          app.run
+        }.to exit_with(1)
+         .and output(message).to_stderr
+      end
+    end
+
+    it 'sets unknown settings' do
+      initialize_app(['set', 'notarealsetting', 'true'])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+
+      expect(File.read(Puppet[:config])).to eq("[main]\nnotarealsetting = true\n")
+    end
+  end
+
+  context "when deleting" do
+    it "deletes a value" do
+      initialize_app(%w[delete external_nodes])
+
+      File.write(Puppet[:config], <<~END)
+        [main]
+        external_nodes=none
+      END
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/Deleted setting from 'main': 'external_nodes=none'/).to_stdout
+
+      expect(File.read(Puppet[:config])).to eq("[main]\n")
+    end
+
+    it "warns when deleting a value that isn't set" do
+      initialize_app(%w[delete external_nodes])
+
+      File.write(Puppet[:config], "")
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(a_string_matching("Warning: No setting found in configuration file for section 'main' setting name 'external_nodes'")).to_stderr
+
+      expect(File.read(Puppet[:config])).to eq("")
+    end
+
+    it "deletes a value from main" do
+      initialize_app(%w[delete external_nodes])
+
+      File.write(Puppet[:config], <<~END)
+        [main]
+        external_nodes=none
+      END
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/Deleted setting from 'main': 'external_nodes=none'/).to_stdout
+
+      expect(File.read(Puppet[:config])).to eq("[main]\n")
+    end
+
+    it "deletes a value from main a section" do
+      initialize_app(%w[delete external_nodes --section server])
+
+      File.write(Puppet[:config], <<~END)
+        [main]
+        external_nodes=none
+        [server]
+        external_nodes=exec
+      END
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/Deleted setting from 'server': 'external_nodes'/).to_stdout
+
+      expect(File.read(Puppet[:config])).to eq("[main]\nexternal_nodes=none\n[server]\n")
+    end
+  end
+
+  context "when managing UTF-8 values" do
+    it "reads a UTF-8 value" do
+      write_utf8(Puppet[:config], <<~EOF)
+        [main]
+        tags=#{MIXED_UTF8}
+      EOF
+
+      initialize_app(%w[print tags])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output("#{MIXED_UTF8}\n").to_stdout
+    end
+
+    it "sets a UTF-8 value" do
+      initialize_app(['set', 'tags', MIXED_UTF8])
+
+      expect {
+        app.run
+      }.to exit_with(0)
+
+      expect(read_utf8(Puppet[:config])).to eq(<<~EOF)
+        [main]
+        tags = #{MIXED_UTF8}
+      EOF
+    end
+
+    it "deletes a UTF-8 value" do
+      initialize_app(%w[delete tags])
+
+      write_utf8(Puppet[:config], <<~EOF)
+        [main]
+        tags=#{MIXED_UTF8}
+      EOF
+
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(/Deleted setting from 'main': 'tags=#{MIXED_UTF8}'/).to_stdout
+
+      expect(read_utf8(Puppet[:config])).to eq(<<~EOF)
+        [main]
+      EOF
+    end
   end
 end