puppet 5.5.16-x64-mingw32 → 5.5.21-x64-mingw32

data/spec/unit/daemon_spec.rb

@@ -224,7 +224,6 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should reexec itself if the agent is not running" do
-      expect(agent).to receive(:running?).and_return(false)
       daemon.agent = agent
       expect(daemon).to receive(:reexec)
 

data/spec/unit/face/facts_spec.rb

@@ -45,6 +45,15 @@ CONF
       subject.upload
     end
 
+    it "passes the current environment" do
+      env = Puppet::Node::Environment.remote('qa')
+      expect(model.indirection).to receive(:save).with(anything, nil, :environment => env)
+
+      Puppet.override(:current_environment => env) do
+        subject.upload
+      end
+    end
+
     it "uses settings from the agent section of puppet.conf" do
       expect(facter_terminus).to receive(:find).with(have_attributes(key: 'puppet.node.test')).and_return(test_data)
 

data/spec/unit/face/plugin_spec.rb

@@ -50,6 +50,14 @@ describe Puppet::Face[:plugin, :current] do
       expect(receive_count).to eq(3)
       expect(render(result)).to eq('Downloaded these plugins: /a, /b, /c')
     end
+
+    it "uses persistent HTTP pool" do
+      allow_any_instance_of(Puppet::Configurer::Downloader).to receive(:evaluate) do
+        expect(Puppet.lookup(:http_pool)).to be_instance_of(Puppet::Network::HTTP::Pool)
+      end.and_return([])
+
+      pluginface.download
+    end
   end
 
   context "download when server_agent_version is 5.3.3" do

data/spec/unit/file_system/uniquefile_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Puppet::FileSystem::Uniquefile do
+  include PuppetSpec::Files
+
   it "makes the name of the file available" do
     Puppet::FileSystem::Uniquefile.open_tmp('foo') do |file|
       expect(file.path).to match(/foo/)
@@ -67,6 +69,15 @@ describe Puppet::FileSystem::Uniquefile do
     Puppet::FileSystem::Uniquefile.open_tmp('foo') { |tmp| }
   end
 
+  it "reports when a parent directory does not exist" do
+    dir = tmpdir('uniquefile')
+    lock = File.join(dir, 'path', 'to', 'lock')
+
+    expect {
+      Puppet::FileSystem::Uniquefile.open_tmp(lock) { |tmp| }
+    }.to raise_error(Errno::ENOENT, %r{No such file or directory - A directory component in .* does not exist or is a dangling symbolic link})
+  end
+
   context "Ruby 1.9.3 Tempfile tests" do
     # the remaining tests in this file are ported directly from the ruby 1.9.3 source,
     # since most of this file was ported from there

data/spec/unit/forge/forge_spec.rb

@@ -97,10 +97,8 @@ describe Puppet::Forge do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
-    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
-    expect(proxy_class).to receive(:new).with(host, port).and_return(proxy)
+    expect(Net::HTTP).to receive(:new).with(host, port, *proxy_args).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/forge/repository_spec.rb

@@ -234,10 +234,8 @@ describe Puppet::Forge::Repository do
   def mock_proxy(port, proxy_args, result, &block)
     http = double("http client")
     proxy = double("http proxy")
-    proxy_class = double("http proxy class")
 
-    expect(Net::HTTP).to receive(:Proxy).with(*proxy_args).and_return(proxy_class)
-    expect(proxy_class).to receive(:new).with("fake.com", port).and_return(proxy)
+    expect(Net::HTTP).to receive(:new).with("fake.com", port, *proxy_args).and_return(proxy)
 
     expect(proxy).to receive(:open_timeout=)
     expect(proxy).to receive(:read_timeout=)

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -9,19 +9,9 @@ describe Puppet::Resource::Catalog::Compiler do
   let(:node_name) { "foo" }
   let(:node) { Puppet::Node.new(node_name)}
 
-  before do
-    allow(Facter).to receive(:to_hash).and_return({})
-  end
-
   describe "when initializing" do
     before do
-      expect(Puppet).to receive(:version).and_return(1)
-      expect(Facter).to receive(:value).with('fqdn').and_return("my.server.com")
-      expect(Facter).to receive(:value).with('ipaddress').and_return("my.ip.address")
-    end
-
-    it "should gather data about itself" do
-      Puppet::Resource::Catalog::Compiler.new
+      allow(Puppet).to receive(:version).and_return(1)
     end
 
     it "should cache the server metadata and reuse it" do
@@ -38,8 +28,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding catalogs" do
     before do
-      allow(Facter).to receive(:value).and_return("whatever")
-
       allow(node).to receive(:merge)
       allow(Puppet::Node.indirection).to receive(:find).and_return(node)
       @request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil, :node => node_name)
@@ -246,10 +234,10 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when handling a request with facts" do
     before do
-      Puppet::Node::Facts.indirection.terminus_class = :memory
       allow(Facter).to receive(:value).and_return("something")
 
-      @facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      facts = Puppet::Node::Facts.new('hostname', "fact" => "value", "architecture" => "i386")
+      Puppet::Node::Facts.indirection.save(facts)
     end
 
     def a_legacy_request_that_contains(facts, format = :pson)
@@ -267,6 +255,8 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when extracting facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should do nothing if no facts are provided" do
         request = Puppet::Indirector::Request.new(:catalog, :find, "hostname", nil)
         request.options[:facts] = nil
@@ -276,21 +266,21 @@ describe Puppet::Resource::Catalog::Compiler do
 
       it "should deserialize the facts without changing the timestamp" do
         time = Time.now
-        @facts.timestamp = time
-        request = a_request_that_contains(@facts)
+        facts.timestamp = time
+        request = a_request_that_contains(facts)
         facts = compiler.extract_facts_from_request(request)
         expect(facts.timestamp).to eq(time)
       end
 
       it "accepts PSON facts from older agents" do
-        request = a_legacy_request_that_contains(@facts)
+        request = a_legacy_request_that_contains(facts)
 
         facts = compiler.extract_facts_from_request(request)
-        expect(facts).to eq(@facts)
+        expect(facts).to eq(facts)
       end
 
       it "rejects YAML facts" do
-        request = a_legacy_request_that_contains(@facts, :yaml)
+        request = a_legacy_request_that_contains(facts, :yaml)
 
         expect {
           compiler.extract_facts_from_request(request)
@@ -298,7 +288,7 @@ describe Puppet::Resource::Catalog::Compiler do
       end
 
       it "rejects unknown fact formats" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
         request.options[:facts_format] = 'unknown-format'
 
         expect {
@@ -308,15 +298,17 @@ describe Puppet::Resource::Catalog::Compiler do
     end
 
     context "when saving facts from the request" do
+      let(:facts) { Puppet::Node::Facts.new("hostname") }
+
       it "should save facts if they were issued by the request" do
-        request = a_request_that_contains(@facts)
+        request = a_request_that_contains(facts)
 
         options = {
           :environment => request.environment,
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
 
@@ -328,7 +320,7 @@ describe Puppet::Resource::Catalog::Compiler do
           :transaction_uuid => request.options[:transaction_uuid],
         }
 
-        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(@facts, nil, options)
+        expect(Puppet::Node::Facts.indirection).not_to receive(:save).with(facts, nil, options)
         compiler.find(request)
       end
     end
@@ -336,7 +328,6 @@ describe Puppet::Resource::Catalog::Compiler do
 
   describe "when finding nodes" do
     it "should look node information up via the Node class with the provided key" do
-      allow(Facter).to receive(:value).and_return("whatever")
       request = Puppet::Indirector::Request.new(:catalog, :find, node_name, nil)
       allow(compiler).to receive(:compile)
 
@@ -414,9 +405,37 @@ describe Puppet::Resource::Catalog::Compiler do
     end
   end
 
+  describe "after finding nodes when checking for a PE version" do
+    include PuppetSpec::Compiler
+
+    let(:pe_version_file) { '/opt/puppetlabs/server/pe_version' }
+    let(:request) { Puppet::Indirector::Request.new(:catalog, :find, node_name, nil) }
+
+    before :each do
+      Puppet[:code] = 'notify { "PE Version: $pe_serverversion": }'
+    end
+
+    it "should not add 'pe_serverversion' when FOSS" do
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be_nil
+    end
+
+    it "should add 'pe_serverversion' when PE" do
+      allow(File).to receive(:readable?).with(pe_version_file).and_return(true)
+      allow(File).to receive(:zero?).with(pe_version_file).and_return(false)
+      allow(File).to receive(:read).with(pe_version_file).and_return('2019.2.0')
+
+      allow(Puppet::Node.indirection).to receive(:find).with(node_name, anything).and_return(node)
+      catalog = compiler.find(request)
+
+      expect(catalog.resource('notify', 'PE Version: 2019.2.0')).to be
+    end
+  end
+
   describe "when filtering resources" do
     before :each do
-      allow(Facter).to receive(:value)
       @catalog = double('catalog')
       allow(@catalog).to receive(:respond_to?).with(:filter).and_return(true)
     end

data/spec/unit/indirector/resource/ral_spec.rb

@@ -47,7 +47,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should convert ral resources into regular resources" do
-      my_resource = double("my user resource")
+      my_resource = double("my user resource", :title => "my user resource")
       my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
       expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
@@ -55,7 +55,7 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource = double("my user resource")
+      my_resource = double("my user resource", title: "my user resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("root")
 
@@ -73,11 +73,11 @@ describe "Puppet::Resource::Ral" do
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = double("my user resource")
+      wrong_resource = double("my user resource", title: "my user resource")
       allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
       allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
 
-      my_resource = double("wrong resource")
+      my_resource = double("wrong resource", title: "wrong resource")
       allow(my_resource).to receive(:to_resource).and_return(my_resource)
       allow(my_resource).to receive(:[]).with(:name).and_return("bob")
 

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
     expect(Zlib::GzipReader).to receive(:open).with(sourcefile).and_yield(reader)
     expect(minitar).to receive(:find_valid_files).with(reader).and_return([name])
     entry = MockFileStatEntry.new(mode)
-    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name]).
+    expect(Archive::Tar::Minitar).to receive(:unpack).with(reader, destdir, [name], :fsync => false).
         and_yield(type, name, {:entry => entry})
     entry
   end

data/spec/unit/network/http/api/indirected_routes_spec.rb

@@ -38,19 +38,27 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if there is no environment specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {})
+      }.to raise_error(bad_request_error)
     end
 
     it "should fail if the environment is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"})
+      }.to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not match the prefix" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params)
+      }.to raise_error(bad_request_error)
     end
 
     it "should fail if the indirection does not have the correct version" do
-      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params)
+      }.to raise_error(bad_request_error)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
@@ -74,7 +82,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params)
+      }.to raise_error(bad_request_error)
     end
 
     it "should use the remainder of the URI as the indirection key" do
@@ -86,7 +96,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if no indirection key is specified" do
-      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to raise_error(bad_request_error)
+      expect {
+        handler.uri2indirection("GET", "#{master_url_prefix}/node", params)
+      }.to raise_error(bad_request_error)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
@@ -126,7 +138,9 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
     end
 
     it "should fail if an indirection method cannot be picked" do
-      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(method_not_allowed_error)
+      expect {
+        handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params)
+      }.to raise_error(method_not_allowed_error)
     end
 
     it "should not URI unescape the indirection key" do
@@ -146,9 +160,11 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
       expect(handler).to receive(:check_authorization) do |_, _, arg|
         expect(arg).not_to include(:environment)
       end
-      expect(lambda { handler.uri2indirection("GET",
-                                              "#{master_url_prefix}/node/bar",
-                                              {:environment => 'bogus'}) }).to raise_error(not_found_error)
+      expect {
+        handler.uri2indirection("GET",
+                                "#{master_url_prefix}/node/bar",
+                                {:environment => 'bogus'})
+      }.to raise_error(not_found_error)
     end
 
     it "should not URI unescape the indirection key as passed through to a call to check_authorization" do
@@ -327,7 +343,8 @@ describe Puppet::Network::HTTP::API::IndirectedRoutes do
 
       expect {
         handler.call(request, response)
-      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError, /No supported formats are acceptable/)
+      }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAcceptableError,
+                       %r{No supported formats are acceptable \(Accept: application/json, text/pson\)})
     end
 
     it "should return [] when searching returns an empty array" do

data/spec/unit/network/http/connection_spec.rb

@@ -135,7 +135,7 @@ describe Puppet::Network::HTTP::Connection do
   end
 
   context "when response indicates an overloaded server" do
-    let(:http) { double('http') }
+    let(:http) { double('http', :started? => true) }
     let(:site) { Puppet::Network::HTTP::Site.new('http', 'my_server', 8140) }
     let(:verify) { Puppet::SSL::Validator.no_validator }
     let(:httpunavailable) { Net::HTTPServiceUnavailable.new('1.1', 503, 'Service Unavailable') }
@@ -158,6 +158,7 @@ describe Puppet::Network::HTTP::Connection do
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+      allow(http).to receive(:finish)
 
       result = subject.get('/foo')
 
@@ -167,6 +168,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should return a 503 response if Retry-After is not convertible to an Integer or RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'foo'
       allow(http).to receive(:request).and_return(httpunavailable)
+      allow(http).to receive(:finish)
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
@@ -176,9 +178,21 @@ describe Puppet::Network::HTTP::Connection do
       expect(result.code).to eq(503)
     end
 
+    it "should close the connection before sleeping" do
+      allow(http).to receive(:request).and_return(httpunavailable, httpok)
+
+      pool = Puppet.lookup(:http_pool)
+      expect(pool).to receive(:with_connection).with(site, anything).and_yield(http)
+
+      expect(http).to receive(:finish)
+
+      subject.get('/foo')
+    end
+
     it "should sleep and retry if Retry-After is an Integer" do
       httpunavailable['Retry-After'] = '42'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
 
       pool = Puppet.lookup(:http_pool)
       expect(pool).to receive(:with_connection).with(site, anything).twice.and_yield(http)
@@ -193,6 +207,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should sleep and retry if Retry-After is an RFC 2822 Date" do
       httpunavailable['Retry-After'] = 'Wed, 13 Apr 2005 15:18:05 GMT'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
 
       now = DateTime.new(2005, 4, 13, 8, 17, 5, '-07:00')
       allow(DateTime).to receive(:now).and_return(now)
@@ -210,6 +225,7 @@ describe Puppet::Network::HTTP::Connection do
     it "should sleep for no more than the Puppet runinterval" do
       httpunavailable['Retry-After'] = '60'
       allow(http).to receive(:request).and_return(httpunavailable, httpok)
+      allow(http).to receive(:finish)
       Puppet[:runinterval] = 30
 
       pool = Puppet.lookup(:http_pool)
@@ -266,4 +282,30 @@ describe Puppet::Network::HTTP::Connection do
 
     subject.get('/path')
   end
+
+  describe 'connection request errors' do
+    it "logs and raises generic http errors" do
+      generic_error = Net::HTTPError.new('generic error', double("response"))
+      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(generic_error)
+
+      expect(Puppet).to receive(:log_exception).with(anything, /^.*failed: generic error$/)
+      expect { subject.get('/foo') }.to raise_error(generic_error)
+    end
+
+    it "logs and raises timeout errors" do
+      timeout_error = Timeout::Error.new
+      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(timeout_error)
+
+      expect(Puppet).to receive(:log_exception).with(anything, /^.*timed out after .* seconds$/)
+      expect { subject.get('/foo') }.to raise_error(timeout_error)
+    end
+
+    it "logs and raises eof errors" do
+      eof_error = EOFError
+      expect_any_instance_of(Net::HTTP).to receive(:request).and_raise(eof_error)
+
+      expect(Puppet).to receive(:log_exception).with(anything, /^.*interrupted after .* seconds$/)
+      expect { subject.get('/foo') }.to raise_error(eof_error)
+    end
+  end
 end