puppet 6.21.1-x64-mingw32 → 7.4.1-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/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/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,6 +11,7 @@ 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
 

data/spec/spec_helper.rb

@@ -145,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"
@@ -152,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

@@ -24,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.

data/spec/unit/application/facts_spec.rb

@@ -50,4 +50,90 @@ describe Puppet::Application::Facts do
     }.to exit_with(0)
      .and output(expected).to_stdout
   end
+
+  context 'when show action is called' do
+    let(:expected) { <<~END }
+      {
+        "filesystems": "apfs,autofs,devfs",
+        "macaddress": "64:52:11:22:03:25"
+      }
+    END
+
+    before :each do
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+      allow(Facter).to receive(:resolve).and_return(values)
+      app.command_line.args = %w{show}
+    end
+
+    it 'correctly displays facts with default formatting' do
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(expected).to_stdout
+    end
+
+    it 'displays a single fact value' do
+      app.command_line.args << 'filesystems' << '--value-only'
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output("apfs,autofs,devfs\n").to_stdout
+    end
+
+    it "warns and ignores value-only when multiple fact names are specified" do
+      app.command_line.args << 'filesystems' << 'macaddress' << '--value-only'
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(expected).to_stdout
+       .and output(/it can only be used when querying for a single fact/).to_stderr
+    end
+
+    {
+      "type_hash" => [{'a' => 2}, "{\n  \"a\": 2\n}"],
+      "type_array" => [[], "[\n\n]"],
+      "type_string" => ["str", "str"],
+      "type_int" => [1, "1"],
+      "type_float" => [1.0, "1.0"],
+      "type_true" => [true, "true"],
+      "type_false" => [false, "false"],
+      "type_nil" => [nil, ""],
+      "type_sym" => [:sym, "sym"]
+    }.each_pair do |name, values|
+      it "renders '#{name}' as '#{values.last}'" do
+        fact_value = values.first
+        fact_output = values.last
+
+        allow(Facter).to receive(:resolve).and_return({name => fact_value})
+
+        app.command_line.args << name << '--value-only'
+        expect {
+          app.run
+        }.to exit_with(0)
+         .and output("#{fact_output}\n").to_stdout
+      end
+    end
+  end
+
+  context 'when default action is called' do
+    let(:expected) { <<~END }
+      ---
+      filesystems: apfs,autofs,devfs
+      macaddress: 64:52:11:22:03:25
+    END
+
+    before :each do
+      Puppet::Node::Facts.indirection.terminus_class = :facter
+      allow(Facter).to receive(:resolve).and_return(values)
+      app.command_line.args = %w{--render-as yaml}
+    end
+
+    it 'calls show action' do
+      expect {
+        app.run
+      }.to exit_with(0)
+       .and output(expected).to_stdout
+      expect(app.action.name).to eq(:show)
+    end
+  end
 end

data/spec/unit/application/filebucket_spec.rb

@@ -114,15 +114,15 @@ describe Puppet::Application::Filebucket do
       end
 
       it "should default to the first good server_list entry if server_list is set" do
-        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 200)
+        stub_request(:get, "https://foo:8140/status/v1/simple/server").to_return(status: 200)
         Puppet[:server_list] = "foo,bar,baz"
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "foo"))
         @filebucket.setup
       end
 
       it "should walk server_list until it finds a good entry" do
-        stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 502)
-        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 200)
+        stub_request(:get, "https://foo:8140/status/v1/simple/server").to_return(status: 502)
+        stub_request(:get, "https://bar:8140/status/v1/simple/server").to_return(status: 200)
         Puppet[:server_list] = "foo,bar,baz"
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "bar"))
         @filebucket.setup
@@ -130,6 +130,8 @@ describe Puppet::Application::Filebucket do
 
       # FileBucket catches any exceptions raised, logs them, then just exits
       it "raises an error if there are no functional servers in server_list" do
+        stub_request(:get, "https://foo:8140/status/v1/simple/server").to_return(status: 404)
+        stub_request(:get, "https://bar:8140/status/v1/simple/server").to_return(status: 404)
         stub_request(:get, "https://foo:8140/status/v1/simple/master").to_return(status: 404)
         stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 404)
         Puppet[:server] = 'horacio'
@@ -145,7 +147,7 @@ describe Puppet::Application::Filebucket do
       end
 
       it "should take both the server and port specified in server_list" do
-        stub_request(:get, "https://foo:632/status/v1/simple/master").to_return(status: 200)
+        stub_request(:get, "https://foo:632/status/v1/simple/server").to_return(status: 200)
         Puppet[:server_list] = "foo:632,bar:6215,baz:351"
         expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => 632 })
         @filebucket.setup
@@ -185,11 +187,11 @@ describe Puppet::Application::Filebucket do
         @filebucket.get
       end
 
-      it "should call the client getfile method with the given md5" do
-        md5="DEADBEEF"
-        allow(@filebucket).to receive(:args).and_return([md5])
+      it "should call the client getfile method with the given digest" do
+        digest = 'DEADBEEF'
+        allow(@filebucket).to receive(:args).and_return([digest])
 
-        expect(@client).to receive(:getfile).with(md5)
+        expect(@client).to receive(:getfile).with(digest)
 
         @filebucket.get
       end
@@ -223,12 +225,12 @@ describe Puppet::Application::Filebucket do
     end
 
     describe "the command restore" do
-      it "should call the client getfile method with the given md5" do
-        md5="DEADBEEF"
-        file="testfile"
-        allow(@filebucket).to receive(:args).and_return([file, md5])
+      it "should call the client getfile method with the given digest" do
+        digest = 'DEADBEEF'
+        file = 'testfile'
+        allow(@filebucket).to receive(:args).and_return([file, digest])
 
-        expect(@client).to receive(:restore).with(file,md5)
+        expect(@client).to receive(:restore).with(file, digest)
 
         @filebucket.restore
       end
@@ -236,55 +238,55 @@ describe Puppet::Application::Filebucket do
 
     describe "the command diff" do
       it "should call the client diff method with 2 given checksums" do
-        md5a="DEADBEEF"
-        md5b="BEEF"
+        digest_a = 'DEADBEEF'
+        digest_b = 'BEEF'
         allow(Puppet::FileSystem).to receive(:exist?).and_return(false)
-        allow(@filebucket).to receive(:args).and_return([md5a, md5b])
+        allow(@filebucket).to receive(:args).and_return([digest_a, digest_b])
 
-        expect(@client).to receive(:diff).with(md5a,md5b, nil, nil)
+        expect(@client).to receive(:diff).with(digest_a, digest_b, nil, nil)
 
         @filebucket.diff
       end
 
-      it "should call the clien diff with a path if the second argument is a file" do
-        md5a="DEADBEEF"
-        md5b="BEEF"
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5a).and_return(false)
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5b).and_return(true)
-        allow(@filebucket).to receive(:args).and_return([md5a, md5b])
+      it "should call the client diff with a path if the second argument is a file" do
+        digest_a = 'DEADBEEF'
+        digest_b = 'BEEF'
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_a).and_return(false)
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_b).and_return(true)
+        allow(@filebucket).to receive(:args).and_return([digest_a, digest_b])
 
-        expect(@client).to receive(:diff).with(md5a, nil, nil, md5b)
+        expect(@client).to receive(:diff).with(digest_a, nil, nil, digest_b)
 
         @filebucket.diff
       end
 
-      it "should call the clien diff with a path if the first argument is a file" do
-        md5a="DEADBEEF"
-        md5b="BEEF"
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5a).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5b).and_return(false)
-        allow(@filebucket).to receive(:args).and_return([md5a, md5b])
+      it "should call the client diff with a path if the first argument is a file" do
+        digest_a = 'DEADBEEF'
+        digest_b = 'BEEF'
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_a).and_return(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_b).and_return(false)
+        allow(@filebucket).to receive(:args).and_return([digest_a, digest_b])
 
-        expect(@client).to receive(:diff).with(nil, md5b, md5a, nil)
+        expect(@client).to receive(:diff).with(nil, digest_b, digest_a, nil)
 
         @filebucket.diff
       end
 
       it "should call the clien diff with paths if the both arguments are files" do
-        md5a="DEADBEEF"
-        md5b="BEEF"
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5a).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(md5b).and_return(true)
-        allow(@filebucket).to receive(:args).and_return([md5a, md5b])
+        digest_a = 'DEADBEEF'
+        digest_b = 'BEEF'
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_a).and_return(true)
+        allow(Puppet::FileSystem).to receive(:exist?).with(digest_b).and_return(true)
+        allow(@filebucket).to receive(:args).and_return([digest_a, digest_b])
 
-        expect(@client).to receive(:diff).with(nil, nil, md5a, md5b)
+        expect(@client).to receive(:diff).with(nil, nil, digest_a, digest_b)
 
         @filebucket.diff
       end
 
       it "should fail if only one checksum is given" do
-        md5a="DEADBEEF"
-        allow(@filebucket).to receive(:args).and_return([md5a])
+        digest_a = 'DEADBEEF'
+        allow(@filebucket).to receive(:args).and_return([digest_a])
 
         expect { @filebucket.diff }.to raise_error Puppet::Error
       end