puppet 6.13.0-x86-mingw32 → 6.18.0-x86-mingw32

data/spec/integration/indirector/facts/facter_spec.rb

@@ -43,9 +43,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--modulepath', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--modulepath', factdir, '-e', 'notify { $custom: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed(Puppet.version)
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as '#{Puppet.version}'/).to_stdout
     end
 
     it "should resolve external facts" do
@@ -58,9 +59,10 @@ describe Puppet::Node::Facts::Facter do
       Puppet.initialize_settings(['--pluginfactdest', factdir])
       apply = Puppet::Application.find(:apply).new(double('command_line', :subcommand_name => :apply, :args => ['--pluginfactdest', factdir, '-e', 'notify { $foo: }']))
 
-      expect do
-        expect { apply.run }.to exit_with(0)
-      end.to have_printed('bar')
+      expect {
+        apply.run
+      }.to exit_with(0)
+       .and output(/defined 'message' as 'bar'/).to_stdout
     end
   end
 

data/spec/integration/indirector/report/yaml.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+require 'puppet/transaction/report'
+require 'puppet/indirector/report/yaml'
+
+describe Puppet::Transaction::Report::Yaml do
+  describe '#save' do
+    subject(:indirection) { described_class.indirection }
+
+    let(:request) { described_class.new }
+    let(:certname) { 'ziggy' }
+    let(:report) do
+      report = Puppet::Transaction::Report.new
+      report.host = certname
+      report
+    end
+    let(:file) { request.path(:me) }
+
+    before do
+      indirection.terminus_class = :yaml
+    end
+
+    it 'is saves a report' do
+      indirection.save(report)
+    end
+
+    it 'saves the instance of the report as YAML to disk' do
+      indirection.save(report)
+      content = Puppet::Util::Yaml.safe_load_file(
+        Puppet[:lastrunreport], [Puppet::Transaction::Report]
+      )
+      expect(content.host).to eq(certname)
+    end
+
+    it 'allows mode overwrite' do
+      Puppet.settings.setting(:lastrunreport).mode = '0644'
+      indirection.save(report)
+
+      if Puppet::Util::Platform.windows?
+        require 'puppet/util/windows/security'
+        mode = Puppet::Util::Windows::Security.get_mode(file)
+      else
+        mode = Puppet::FileSystem.stat(file).mode
+      end
+
+      expect(mode & 07777).to eq(0644)
+    end
+
+    context 'when mode is invalid' do
+      before do
+        Puppet.settings.setting(:lastrunreport).mode = '9999'
+      end
+
+      after do
+        Puppet.settings.setting(:lastrunreport).mode = '0644'
+      end
+
+      it 'raises Puppet::DevError ' do
+        expect{
+          indirection.save(report)
+        }.to raise_error(Puppet::DevError, "replace_file mode: 9999 is invalid")
+      end
+    end
+
+    context 'when repport is invalid' do
+      it 'logs error' do
+        expect(Puppet).to receive(:send_log).with(:err, /Could not save yaml ziggy: can't dump anonymous class/)
+
+        report.configuration_version = Class.new
+        indirection.save(report)
+      end
+    end
+
+    context 'when report cannot be saved' do
+      it 'raises Errno::EISDIR' do
+        FileUtils.mkdir_p(file)
+        expect {
+          indirection.save(report)
+         }.to raise_error(Errno::EISDIR, /last_run_report.yaml/)
+      end
+    end
+  end
+end

data/spec/integration/network/http_pool_spec.rb

@@ -24,14 +24,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
   let(:server) { PuppetSpec::HTTPSServer.new }
 
   context "when calling deprecated HttpPool methods" do
-    let(:ssl_host) {
-      # use server's cert/key as the client cert/key
-      host = Puppet::SSL::Host.new
-      host.key = Puppet::SSL::Key.from_instance(server.server_key, host.name)
-      host.certificate = Puppet::SSL::Certificate.from_instance(server.server_cert, host.name)
-      host
-    }
-
     before(:each) do
       ssldir = tmpdir('http_pool')
       Puppet[:ssldir] = ssldir
@@ -43,16 +35,6 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
       File.write(Puppet[:hostprivkey], server.server_key.to_pem)
     end
 
-    # Can't use `around(:each)` because it will cause ssl_host to be
-    # created outside of any rspec example, and $confdir won't be set
-    before(:each) do
-      Puppet.push_context(ssl_host: ssl_host)
-    end
-
-    after (:each) do
-      Puppet.pop_context
-    end
-
     def connection(host, port)
       Puppet::Network::HttpPool.http_instance(host, port, use_ssl: true)
     end
@@ -98,8 +80,26 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
                            %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
         end
       end
-    end
 
+      it "doesn't generate a Puppet::SSL::Host deprecation warning" do
+        server.start_server do |port|
+          http = connection(hostname, port)
+          res = http.get('/')
+          expect(res.code).to eq('200')
+        end
+
+        expect(@logs).to eq([])
+      end
+
+      it "detects when the server has closed the connection and reconnects" do
+        server.start_server do |port|
+          http = connection(hostname, port)
+
+          expect(http.request_get('/')).to be_a(Net::HTTPSuccess)
+          expect(http.request_get('/')).to be_a(Net::HTTPSuccess)
+        end
+      end
+    end
 
     context "when using single use HTTPS connections" do
       include_examples 'HTTPS client'
@@ -107,7 +107,7 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
 
     context "when using persistent HTTPS connections" do
       around :each do |example|
-        pool = Puppet::Network::HTTP::Pool.new
+        pool = Puppet::Network::HTTP::Pool.new(15)
         Puppet.override(:http_pool => pool) do
           example.run
         end
@@ -116,6 +116,79 @@ describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
 
       include_examples 'HTTPS client'
     end
+
+    shared_examples_for "an HttpPool connection" do |klass, legacy_api|
+      before :each do
+        Puppet::Network::HttpPool.http_client_class = klass
+      end
+
+      it "connects using the scheme, host and port from the http instance preserving the URL path and query" do
+        request_line = nil
+
+        response_proc = -> (req, res) {
+          request_line = req.request_line
+        }
+
+        server.start_server(response_proc: response_proc) do |port|
+          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
+          path  = "http://bogus.example.com:443/foo?q=a"
+          http.get(path)
+
+          if legacy_api
+            # The old API uses 'absolute-form' and passes the bogus hostname
+            # which isn't the host we connected to.
+            expect(request_line).to eq("GET http://bogus.example.com:443/foo?q=a HTTP/1.1\r\n")
+          else
+            expect(request_line).to eq("GET /foo?q=a HTTP/1.1\r\n")
+          end
+        end
+      end
+
+      it "requires the caller to URL encode the path and query when using absolute form" do
+        request_line = nil
+
+        response_proc = -> (req, res) {
+          request_line = req.request_line
+        }
+
+        server.start_server(response_proc: response_proc) do |port|
+          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
+          params = { 'key' => 'a value' }
+          encoded_url = "https://#{hostname}:#{port}/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}"
+          http.get(encoded_url)
+
+          if legacy_api
+            expect(request_line).to eq("GET #{encoded_url} HTTP/1.1\r\n")
+          else
+            expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
+          end
+        end
+      end
+
+      it "requires the caller to URL encode the path and query when using a path" do
+        request_line = nil
+
+        response_proc = -> (req, res) {
+          request_line = req.request_line
+        }
+
+        server.start_server(response_proc: response_proc) do |port|
+          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
+          params = { 'key' => 'a value' }
+          http.get("/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}")
+
+          expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
+        end
+      end
+    end
+
+    describe Puppet::Network::HTTP::Connection do
+      it_behaves_like "an HttpPool connection", described_class, true
+    end
+
+    describe Puppet::Network::HTTP::ConnectionAdapter do
+      it_behaves_like "an HttpPool connection", described_class, false
+    end
   end
 
   context "when calling HttpPool.connection method" do

data/spec/integration/node/environment_spec.rb

@@ -76,6 +76,21 @@ describe Puppet::Node::Environment do
     expect(mods[0].path).to eq(File.join(base, "dir1", "mod"))
   end
 
+  it "should not yield a module with the same name as a defined Bolt project" do
+    project_path = File.join(tmpfile('project'), 'bolt_project')
+    FileUtils.mkdir_p(project_path)
+    project = Struct.new("Project", :name, :path, :load_as_module?).new('project', project_path, true)
+
+    Puppet.override(bolt_project: project) do
+      base = tmpfile("base")
+      FileUtils.mkdir_p([File.join(base, 'project'), File.join(base, 'other')])
+      environment = Puppet::Node::Environment.create(:env, [base])
+      mods = environment.modules
+      expect(mods.length).to eq(2)
+      expect(mods.map(&:path)).to eq([project_path, File.join(base, 'other')])
+    end
+  end
+
   shared_examples_for "the environment's initial import" do |settings|
     it "a manifest referring to a directory invokes parsing of all its files in sorted order" do
       settings.each do |name, value|

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/type/file_spec.rb

@@ -1160,7 +1160,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)
 

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

@@ -82,6 +82,9 @@ describe Puppet::Util::Windows::ADSI::Group,
     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
@@ -110,6 +113,8 @@ describe Puppet::Util::Windows::ADSI::Group,
       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 })
 
@@ -160,7 +165,7 @@ describe Puppet::Util::Windows::ADSI::Group,
 
       # 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 (unresolvable)')
+      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
 

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