puppet 6.14.0 → 6.15.0

data/spec/unit/application/filebucket_spec.rb

@@ -114,12 +114,31 @@ describe Puppet::Application::Filebucket do
         @filebucket.setup
       end
 
-      it "should default to the first server_list entry if set" do
+      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)
         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)
+        Puppet[:server_list] = "foo,bar,baz"
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "bar"))
+        @filebucket.setup
+      end
+
+      # 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/master").to_return(status: 404)
+        stub_request(:get, "https://bar:8140/status/v1/simple/master").to_return(status: 404)
+        Puppet[:server] = 'horacio'
+        Puppet[:server_list] = "foo,bar"
+
+        expect{@filebucket.setup}.to exit_with(1)
+      end
+
       it "should fall back to server if server_list is empty" do
         Puppet[:server_list] = ""
         expect(Puppet::FileBucket::Dipper).to receive(:new).with(hash_including(Server: "puppet"))
@@ -127,8 +146,9 @@ 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)
         Puppet[:server_list] = "foo:632,bar:6215,baz:351"
-        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => "632" })
+        expect(Puppet::FileBucket::Dipper).to receive(:new).with({ :Server => "foo", :Port => 632 })
         @filebucket.setup
       end
     end

data/spec/unit/configurer_spec.rb

@@ -148,7 +148,7 @@ describe Puppet::Configurer do
       configurer = Puppet::Configurer.new("test_tuuid", "test_jid")
 
       report = Puppet::Transaction::Report.new(nil, "test", "aaaa")
-      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid').and_return(report)
+      expect(Puppet::Transaction::Report).to receive(:new).with(anything, anything, 'test_tuuid', 'test_jid', anything).and_return(report)
       expect(configurer).to receive(:send_report).with(report)
 
       configurer.run

data/spec/unit/defaults_spec.rb

@@ -188,8 +188,31 @@ describe "Defaults" do
     end
 
     it "raises an exception if facter-ng could not be loaded" do
-      allow(Puppet).to receive(:require).with('facter-ng').and_return(false)
+      allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_raise(LoadError)
+
       expect{ Puppet.settings[:facterng] = true }.to raise_exception ArgumentError, 'facter-ng could not be loaded'
     end
+
+    context 'set logger' do
+      before do
+        @original_facter = Object.const_get(:Facter)
+
+        Object.send(:remove_const, :Facter)
+        Object.const_set(:Facter, Module.new)
+
+        allow_any_instance_of(Puppet::Settings::BooleanSetting).to receive(:require).with('facter-ng').and_return(true)
+        allow(Facter).to receive(:respond_to?).and_return(false)
+      end
+
+      after do
+        Object.const_set(:Facter, @original_facter)
+      end
+
+      it 'calls setup_facter_logging!' do
+        allow(Puppet::Util::Logging).to receive(:setup_facter_logging!).and_return(true)
+        Puppet.settings[:facterng] = true
+        expect(Puppet::Util::Logging).to have_received(:setup_facter_logging!).once
+      end
+    end
   end
 end

data/spec/unit/environments_spec.rb

@@ -35,6 +35,7 @@ describe Puppet::Environments do
         FS::MemoryFile.a_directory("modules"),
         FS::MemoryFile.a_directory("manifests"),
       ]),
+      FS::MemoryFile.a_missing_file("missing")
     ])
   end
 
@@ -90,6 +91,13 @@ describe Puppet::Environments do
       end
     end
 
+    it "proceeds with non-existant env dir" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree.children.last) do |loader|
+        expect(loader.list).to eq([])
+      end
+    end
+
     it "gets a particular environment" do
       loader_from(:filesystem => [directory_tree],
                   :directory => directory_tree.children.first) do |loader|

data/spec/unit/file_system_spec.rb

@@ -970,6 +970,16 @@ describe "Puppet::FileSystem" do
           mode = Puppet::FileSystem.stat(dest).mode
           expect(mode & 07777).to eq(0400)
         end
+
+        it 'preserves file ownership' do
+          allow(Puppet::FileSystem).to receive(:lstat)
+            .with(Puppet::FileSystem.pathname(dest))
+            .and_return(double(uid: 1, gid: 2))
+
+          expect(FileUtils).to receive(:chown).with(1, 2, /#{dest}/)
+
+          Puppet::FileSystem.replace_file(dest, 0644) { |f| f.write(content) }
+        end
       end
 
       context 'on windows', if: Puppet::Util::Platform.windows? do

data/spec/unit/http/client_spec.rb

@@ -4,10 +4,9 @@ require 'puppet/http'
 
 describe Puppet::HTTP::Client do
   let(:uri) { URI.parse('https://www.example.com') }
-  let(:pool) { Puppet::Network::HTTP::Pool.new }
   let(:puppet_context) { Puppet::SSL::SSLContext.new }
   let(:system_context) { Puppet::SSL::SSLContext.new }
-  let(:client) { described_class.new(pool: pool, ssl_context: puppet_context, system_ssl_context: system_context) }
+  let(:client) { described_class.new(ssl_context: puppet_context, system_ssl_context: system_context) }
   let(:credentials) { ['user', 'pass'] }
 
   it 'creates unique sessions' do
@@ -50,7 +49,7 @@ describe Puppet::HTTP::Client do
     end
 
     it 'connects using the default ssl context' do
-      expect(pool).to receive(:with_connection) do |_, verifier|
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
         expect(verifier.ssl_context).to equal(puppet_context)
       end
 
@@ -60,24 +59,32 @@ describe Puppet::HTTP::Client do
     it 'connects using a specified ssl context' do
       other_context = Puppet::SSL::SSLContext.new
 
-      expect(pool).to receive(:with_connection) do |_, verifier|
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
         expect(verifier.ssl_context).to equal(other_context)
       end
 
-      client.connect(uri, ssl_context: other_context)
+      client.connect(uri, options: {ssl_context: other_context})
     end
 
     it 'connects using the system store' do
-      expect(pool).to receive(:with_connection) do |_, verifier|
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
         expect(verifier.ssl_context).to equal(system_context)
       end
 
-      client.connect(uri, include_system_store: true)
+      client.connect(uri, options: {include_system_store: true})
+    end
+
+    it 'does not create a verifier for HTTP connections' do
+      expect(client.pool).to receive(:with_connection) do |_, verifier|
+        expect(verifier).to be_nil
+      end
+
+      client.connect(URI.parse('http://www.example.com'))
     end
 
     it 'raises an HTTPError if both are specified' do
       expect {
-        client.connect(uri, ssl_context: puppet_context, include_system_store: true)
+        client.connect(uri, options: {ssl_context: puppet_context, include_system_store: true})
       }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
     end
   end
@@ -110,10 +117,8 @@ describe Puppet::HTTP::Client do
 
   context "when closing" do
     it "closes all connections in the pool" do
-      pool = double('pool')
-      expect(pool).to receive(:close)
+      expect(client.pool).to receive(:close)
 
-      client = described_class.new(pool: pool)
       client.close
     end
   end
@@ -180,18 +185,18 @@ describe Puppet::HTTP::Client do
 
         other_context = Puppet::SSL::SSLContext.new
 
-        client.get(uri, ssl_context: other_context)
+        client.get(uri, options: {ssl_context: other_context})
       end
 
       it 'uses the system store' do
         stub_request(:get, uri).to_return(body: "abc")
 
-        client.get(uri, include_system_store: true)
+        client.get(uri, options: {include_system_store: true})
       end
 
       it 'raises an HTTPError if both are specified' do
         expect {
-          client.get(uri, ssl_context: puppet_context, include_system_store: true)
+          client.get(uri, options: {ssl_context: puppet_context, include_system_store: true})
         }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
       end
     end
@@ -237,18 +242,18 @@ describe Puppet::HTTP::Client do
 
         other_context = Puppet::SSL::SSLContext.new
 
-        client.head(uri, ssl_context: other_context)
+        client.head(uri, options: {ssl_context: other_context})
       end
 
       it 'uses the system store' do
         stub_request(:head, uri)
 
-        client.head(uri, include_system_store: true)
+        client.head(uri, options: {include_system_store: true})
       end
 
       it 'raises an HTTPError if both are specified' do
         expect {
-          client.head(uri, ssl_context: puppet_context, include_system_store: true)
+          client.head(uri, options: {ssl_context: puppet_context, include_system_store: true})
         }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
       end
     end
@@ -261,25 +266,25 @@ describe Puppet::HTTP::Client do
         expect(request.headers).to_not include('X-Puppet-Profiling')
       end
 
-      client.put(uri, content_type: 'text/plain', body: "")
+      client.put(uri, "", headers: {'Content-Type' => 'text/plain'})
     end
 
     it "stringifies keys and encodes values in the query" do
       stub_request(:put, "https://www.example.com").with(query: "foo=bar%3Dbaz")
 
-      client.put(uri, params: {:foo => "bar=baz"}, content_type: 'text/plain', body: "")
+      client.put(uri, "", params: {:foo => "bar=baz"}, headers: {'Content-Type' => 'text/plain'})
     end
 
     it "includes custom headers" do
       stub_request(:put, "https://www.example.com").with(headers: { 'X-Foo' => 'Bar' })
 
-      client.put(uri, headers: {'X-Foo' => 'Bar'}, content_type: 'text/plain', body: "")
+      client.put(uri, "", headers: {'X-Foo' => 'Bar', 'Content-Type' => 'text/plain'})
     end
 
     it "returns the response" do
       stub_request(:put, uri)
 
-      response = client.put(uri, content_type: 'text/plain', body: "")
+      response = client.put(uri, "", headers: {'Content-Type' => 'text/plain'})
       expect(response).to be_an_instance_of(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
@@ -288,27 +293,39 @@ describe Puppet::HTTP::Client do
     it "sets content-length and content-type for the body" do
       stub_request(:put, uri).with(headers: {"Content-Length" => "5", "Content-Type" => "text/plain"})
 
-      client.put(uri, content_type: 'text/plain', body: "hello")
+      client.put(uri, "hello", headers: {'Content-Type' => 'text/plain'})
     end
 
+     it 'raises an ArgumentError if `body` is missing' do
+       expect {
+         client.put(uri, nil, headers: {'Content-Type' => 'text/plain'})
+       }.to raise_error(ArgumentError, /'put' requires a string 'body' argument/)
+     end
+
+     it 'raises an ArgumentError if `content_type` is missing from the headers hash' do
+       expect {
+         client.put(uri, '')
+       }.to raise_error(ArgumentError, /'put' requires a 'content-type' header/)
+     end
+
     context 'when connecting' do
       it 'uses a specified ssl context' do
         stub_request(:put, uri)
 
         other_context = Puppet::SSL::SSLContext.new
 
-        client.put(uri, content_type: 'text/plain', body: "", ssl_context: other_context)
+        client.put(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: other_context})
       end
 
       it 'uses the system store' do
         stub_request(:put, uri)
 
-        client.put(uri, content_type: 'text/plain', body: "", include_system_store: true)
+        client.put(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {include_system_store: true})
       end
 
       it 'raises an HTTPError if both are specified' do
         expect {
-          client.put(uri, content_type: 'text/plain', body: "", ssl_context: puppet_context, include_system_store: true)
+          client.put(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: puppet_context, include_system_store: true})
         }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
       end
     end
@@ -318,25 +335,25 @@ describe Puppet::HTTP::Client do
     it "includes default HTTP headers" do
       stub_request(:post, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
 
-      client.post(uri, content_type: 'text/plain', body: "")
+      client.post(uri, "", headers: {'Content-Type' => 'text/plain'})
     end
 
     it "stringifies keys and encodes values in the query" do
       stub_request(:post, "https://www.example.com").with(query: "foo=bar%3Dbaz")
 
-      client.post(uri, params: {:foo => "bar=baz"}, content_type: 'text/plain', body: "")
+      client.post(uri, "", params: {:foo => "bar=baz"}, headers: {'Content-Type' => 'text/plain'})
     end
 
     it "includes custom headers" do
       stub_request(:post, "https://www.example.com").with(headers: { 'X-Foo' => 'Bar' })
 
-      client.post(uri, headers: {'X-Foo' => 'Bar'}, content_type: 'text/plain', body: "")
+      client.post(uri, "", headers: {'X-Foo' => 'Bar', 'Content-Type' => 'text/plain'})
     end
 
     it "returns the response" do
       stub_request(:post, uri)
 
-      response = client.post(uri, content_type: 'text/plain', body: "")
+      response = client.post(uri, "", headers: {'Content-Type' => 'text/plain'})
       expect(response).to be_an_instance_of(Puppet::HTTP::Response)
       expect(response).to be_success
       expect(response.code).to eq(200)
@@ -345,14 +362,14 @@ describe Puppet::HTTP::Client do
     it "sets content-length and content-type for the body" do
       stub_request(:post, uri).with(headers: {"Content-Length" => "5", "Content-Type" => "text/plain"})
 
-      client.post(uri, content_type: 'text/plain', body: "hello")
+      client.post(uri, "hello", headers: {'Content-Type' => 'text/plain'})
     end
 
     it "streams the response body when a block is given" do
       stub_request(:post, uri).to_return(body: "abc")
 
       io = StringIO.new
-      client.post(uri, content_type: 'text/plain', body: "") do |response|
+      client.post(uri, "", headers: {'Content-Type' => 'text/plain'}) do |response|
         response.read_body do |data|
           io.write(data)
         end
@@ -361,24 +378,36 @@ describe Puppet::HTTP::Client do
       expect(io.string).to eq("abc")
     end
 
+    it 'raises an ArgumentError if `body` is missing' do
+      expect {
+        client.post(uri, nil, headers: {'Content-Type' => 'text/plain'})
+      }.to raise_error(ArgumentError, /'post' requires a string 'body' argument/)
+    end
+
+    it 'raises an ArgumentError if `content_type` is missing from the headers hash' do
+      expect {
+        client.post(uri, "")
+      }.to raise_error(ArgumentError, /'post' requires a 'content-type' header/)
+    end
+
     context 'when connecting' do
       it 'uses a specified ssl context' do
         stub_request(:post, uri)
 
         other_context = Puppet::SSL::SSLContext.new
 
-        client.post(uri, content_type: 'text/plain', body: "", ssl_context: other_context)
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {body: "", ssl_context: other_context})
       end
 
       it 'uses the system store' do
         stub_request(:post, uri)
 
-        client.post(uri, content_type: 'text/plain', body: "", include_system_store: true)
+        client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {include_system_store: true})
       end
 
       it 'raises an HTTPError if both are specified' do
         expect {
-          client.post(uri, content_type: 'text/plain', body: "", ssl_context: puppet_context, include_system_store: true)
+          client.post(uri, "", headers: {'Content-Type' => 'text/plain'}, options: {ssl_context: puppet_context, include_system_store: true})
         }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
       end
     end
@@ -424,18 +453,18 @@ describe Puppet::HTTP::Client do
 
         other_context = Puppet::SSL::SSLContext.new
 
-        client.delete(uri, ssl_context: other_context)
+        client.delete(uri, options: {ssl_context: other_context})
       end
 
       it 'uses the system store' do
         stub_request(:delete, uri)
 
-        client.delete(uri, include_system_store: true)
+        client.delete(uri, options: {include_system_store: true})
       end
 
       it 'raises an HTTPError if both are specified' do
         expect {
-          client.delete(uri, ssl_context: puppet_context, include_system_store: true)
+          client.delete(uri, options: {ssl_context: puppet_context, include_system_store: true})
         }.to raise_error(Puppet::HTTP::HTTPError, /The ssl_context and include_system_store parameters are mutually exclusive/)
       end
     end
@@ -445,19 +474,19 @@ describe Puppet::HTTP::Client do
     it "submits credentials for GET requests" do
       stub_request(:get, uri).with(basic_auth: credentials)
 
-      client.get(uri, user: 'user', password: 'pass')
+      client.get(uri, options: {user: 'user', password: 'pass'})
     end
 
     it "submits credentials for PUT requests" do
       stub_request(:put, uri).with(basic_auth: credentials)
 
-      client.put(uri, content_type: 'text/plain', body: "hello", user: 'user', password: 'pass')
+      client.put(uri, "hello", headers: {'Content-Type' => 'text/plain'}, options: {user: 'user', password: 'pass'})
     end
 
     it "returns response containing access denied" do
       stub_request(:get, uri).with(basic_auth: credentials).to_return(status: [403, "Ye Shall Not Pass"])
 
-      response = client.get(uri, user: 'user', password: 'pass')
+      response = client.get(uri, options: {user: 'user', password: 'pass'})
       expect(response.code).to eq(403)
       expect(response.reason).to eq("Ye Shall Not Pass")
       expect(response).to_not be_success
@@ -468,7 +497,7 @@ describe Puppet::HTTP::Client do
         expect(req.headers).to_not include('Authorization')
       end
 
-      client.get(uri, user: nil, password: 'pass')
+      client.get(uri, options: {user: nil, password: 'pass'})
     end
 
     it 'omits basic auth if password is nil' do
@@ -476,7 +505,7 @@ describe Puppet::HTTP::Client do
         expect(req.headers).to_not include('Authorization')
       end
 
-      client.get(uri, user: 'user', password: nil)
+      client.get(uri, options: {user: 'user', password: nil})
     end
   end
 
@@ -502,7 +531,7 @@ describe Puppet::HTTP::Client do
       stub_request(:put, start_url).to_return(redirect_to(url: bar_url))
       stub_request(:put, bar_url).to_return(status: 200)
 
-      response = client.put(start_url, body: "", content_type: 'text/plain')
+      response = client.put(start_url, "", headers: {'Content-Type' => 'text/plain'})
       expect(response).to be_success
     end
 
@@ -528,7 +557,7 @@ describe Puppet::HTTP::Client do
       stub_request(:get, start_url).with(basic_auth: credentials).to_return(redirect_to(url: bar_url))
       stub_request(:get, bar_url).with(basic_auth: credentials).to_return(status: 200)
 
-      client.get(start_url, user: 'user', password: 'pass')
+      client.get(start_url, options: {user: 'user', password: 'pass'})
     end
 
     it "redirects given a relative location" do
@@ -555,7 +584,7 @@ describe Puppet::HTTP::Client do
       stub_request(:put, start_url).with(body: data).to_return(redirect_to(url: bar_url))
       stub_request(:put, bar_url).with(body: data).to_return(status: 200)
 
-      response = client.put(start_url, body: data, content_type: 'text/plain')
+      response = client.put(start_url, data, headers: {'Content-Type' => 'text/plain'})
       expect(response).to be_success
     end
 
@@ -698,7 +727,7 @@ describe Puppet::HTTP::Client do
       allow(http2).to receive(:started?).and_return(true)
 
 
-      pool = Puppet::Network::HTTP::Pool.new()
+      pool = Puppet::Network::HTTP::Pool.new(15)
       client = Puppet::HTTP::Client.new(pool: pool)
 
       # The "with_connection" method is required to yield started connections
@@ -746,4 +775,34 @@ describe Puppet::HTTP::Client do
       client.get(uri)
     end
   end
+
+  context "persistent connections" do
+    before :each do
+      stub_request(:get, uri)
+    end
+
+    it 'defaults keepalive to http_keepalive_timeout' do
+      expect(client.pool.keepalive_timeout).to eq(Puppet[:http_keepalive_timeout])
+    end
+
+    it 'reuses a cached connection' do
+      allow(Puppet).to receive(:debug)
+      expect(Puppet).to receive(:debug).with(/^Creating new connection/)
+      expect(Puppet).to receive(:debug).with(/^Using cached connection/)
+
+      client.get(uri)
+      client.get(uri)
+    end
+
+    it 'can be disabled' do
+      Puppet[:http_keepalive_timeout] = 0
+
+      allow(Puppet).to receive(:debug)
+      expect(Puppet).to receive(:debug).with(/^Creating new connection/).twice
+      expect(Puppet).to receive(:debug).with(/^Using cached connection/).never
+
+      client.get(uri)
+      client.get(uri)
+    end
+  end
 end